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
zcmb<-^>JfjWMqH=W(GS35br=0M8p9?G0gB~fwCAF92hJZI2jxmWEiBuY7sJUC2)pC
z7K90-83Z7FkR7ZbW&wy`U|>L_8?~6h5-=KBAK1PH5P1ePx?~Di8v~3+*2l)cz~Es9
z*3IDIhDsZVLG)ROLui;jCI$uukiG^Ri24Q}RQdzRBMb}-Fq#9Z9i$3`EkFh^FfgFg
zDo}MW8l)B^6!5ep1;max2k{>|9m5Gy#lQfgL25xFflo_PK<)&wiNVllU<iWRhbvrm
zK<$IkQ13E;>=j{PU;w$&-7l0OJTu_0PraeSrP{k32P5xYSnFPR3giw|1_p*(3=ClP
zps-<5RaN9;WSMf3VS(_bgVPKICvbW&F)(eO&8z05#@OHqQhS?$f#D7V1H*lg0SpWb
z525rUDE)+if#Ep=1H(%O28LG*3=D4=7#Q9{<=!zcFnolvLDW|U28M4S1_J}bcLoNA
zp9~BPzo7iz3=9l^p==QK4@5vc$jr#Vz{<$Lz|P3PU@w}Wz_@7Dn-km9&bf*HHh#F{
z*6EZL_AUQU?^$)+<v_R6A5XDHn-{un-#>WuP2igKyW!jpCE5LL!n`ih;pQi6BG{&%
zGftXvi@Rpgj*BxF?KpMG+BMDgg>GZqryV=ayttb1sWd-gOKZJ*&8Hm~lYWF3>a%Fg
zy5}ssx1Md^)9)cCHeR-N{WdR!>Aq-Xerj`)ModGNb$Q+-DG80^kq4Zc#an;uaJAw{
zP?(%(5PR%J`Ex}9t&f~9<fekWgA2EbFfa&VkxY?efF*qtS!;Rh;)$Ht#qAZai<>iJ
zxA&ARcJ(D3*u~GXV;2v=VXu@Vc6)ayVmBuQhkMqtV>jmm4)Jtp?B=WB@Rz>~cJ;rd
zu#4B=FyC4VyE~8JQ2&h;yZUKL*zLU`k6ryOM(pBWaM+uN!<-r%@i?0SyZMtju#0cO
zA-)5Ldze|V`?mu}x^-h<U{FHIDG-i44)uX-*xgx=BR@*uNavY2(q|Tq@L!4}9=|Cw
zFbG1Nj6yo%$k!Kf<d@wz;w2A9x~jsF&Trx{M+`@PIgBHn6yOkljw7G?<1pV7N4e*W
z!~H@y#BFiJyBdyka!d((I+=~b{bz8PlYk>VpTtp~%#p;N{%_$>uYx0e3h-c0S4=qE
zc@#&wwZaiE516sLvlU0WwZah&917Uo`5Q+({>0(mEjZF`0S@(nINbA74tu;;;mGg*
zal}_Vj&OUWfZhC=ILv>BBOG4gC<m-?l&c$=u-m(n1$#X5;)uuBO4#G8ABQ{JaKy_o
z9QO9&P=6PPzux0Wx94%xJC|_S+m0h%3~|J7D2{s52}e8UI}UgD;HY;V;0Ol`9O+pN
zNBJOvLtGU{eRLH^x&0GI_?Y2n=UCt{KOTqs4+&sTS2;M+l`*dLjKkhrIMVH89O1u^
z8@qdSaJYvDN4e3A!#!;{!a)Z|`1|1~x4m$fzXC@(zk{Rx^2X8c=;y&+ZfwKh-$ESj
z5yz2#t8wHn104R<!clH_;;7%{am1Gf4)>JfDEIVmh|j{|&ObQ9K@NvGdvT<P9vtB#
zgu{FR9QmRVhj;^y{QCw+yKyIudMXx&dqi-=R|Ssz#e$>WRL2p{eK^wja~$H<irCZh
zWE|z~3LN&n#t{x{aHK2Hm<YE1{v#ai|5-T9;a0(3E_vfnKMzN}lZd07DZ!Di@8j_A
zHyq)tfWw_$INGJ4@h}CH9uR~RjwAgC;K)a8IQ-j$BVFyokuQ>Q*lUWzU%ax|)71_f
z>E{@Ze$8?m;rtv&J^mes`gt<g-NS~XeewuLy)XwyI|tP12E`d9mJlQpj`B871bez&
zg(JQ|!+_Y*LogTi_G%0cduIw@4+k9v1_o^AFU1jV|8S(AP8{v<7aZ9A>x`qEUx34$
zQ#k6inK;tzZ8ng-5)2KYpb=sQh6T{5DFNp@K86dcK_kWt46tGLHQ;ua2*U?Yh<aF<
z9OVLq8xO+)Wyk=!CDfcq7O45*5cM$gUrB((MHp^)L&P<p>V?7On*@VF3`86>1`U#`
zhMLcy0x_Q*B*?(P;0LZ3_!u^<g18elHu4Ibenc34ctOmOfU5W6hq$u=YEC9p{0%e6
zJrWELA|UE_K&)YK6N9Kfpb8Oynd1p{rv;ijQ@KFq@G)F~x(8N<J1~O8B^VUKAm&3z
z28In_bNCn<PC?uc8lwj}NlXZ0uYelFUS*IV0|Ub>u)p{iE^LITmxqd<f`&r?G`?Ws
z51{IKH$l|H<{TWr@hif>;Q?_8%wK!K>O~lCK*J4|XQy#O-1A@?#63Kq49CF0P!Dx~
z3Do`IIU)uI22rSg7eM`c66(&kV0Vfzyl{uu3p4)}IN$Lw6hOln;#vlVr;?y><71e%
z9U=m?mf->`NL+*=0?qwj!0mG$h6boPworS2^FrMJ0UGbHc^orvIPfv_Lc<LfJ}1HU
ziZD!orcYS-s6f-R0yLehgPLyy_7@++0#E~hfq?<0eug;2UI%DAZiK3D28WLbLjyFN
zVd|5?=7=yHKntI>VE6Db6hOlPrhW~$z0Jd*0QE0S95e|g$RNRx01baw{&EtAx(BKr
zp01$ffB{rJEFX1&>nR?F4W^LrhkAoy3pD%-py3ZQpCLXzJvTouzPKc@s3bm~A>K2@
zH$Ek`C^bE^xFoeG#Me0|KQA>TF)1e%B8OcjKDi<>J}omZF(<Psl_4iHskkI1SzBAL
zIA6~U#Lb1X(vy?pi$Od?ka#kPWyTO6m68)s#t<KsSDwp|o0^-OUzW-c9~E3;XdWM5
zl2Mdj9-ow$5}%lplb>7$QjlCw36?i9fXU~i=B1Zp#HSV&<rf8bCxa9fr<O3pgM5~p
z9iN<$9iNt%nFI1~MMZo;YEf}M$h9Sv@nr@K@u7L;nRzMkL8-;1xgeYUjMH*UjLOU`
zGV@AOi}Dh43=NVJi!+nsQxZ!OJ<D9pQZmysONw0?;-d&DH7(9e&jYChhY{Edi6yD=
zsTIko1tppJc?|JUA)dh{h87?nmL(QtCgzpICnhJS78f(bgY|#|0Ay2eiJ@^(X<kWY
zZYsp1&PJ{vze1Fy6{VsW8xIO<bdQ1qIv1;9E=I1PC<rbwGJyqZerZX3ep-A{VqSV`
zd|GZvfOm2gR=v(fu0h^@!6oJ(r&Jgk8X7@@tGJ{nGcVmUIk?2oFgYW!D88g9F|(xD
zGubsb(KFfA6&!%UB^H_a#qmjr#i=Hqd6^~7hG2*Ip^LkK#lb<6Sdv<iSpsnisdie%
z`^G01r6!i7x(4Nff+D!Y&=Th3oc#36WJutGLbkZ1C?_?Kp{zKspeQr1B#oiCq$oMJ
z0G##=4dXo$i!<VrDoav}1H8+?X8CysmsrHdr=*r7X66_f#0M0CBC9Ah1EjJbKPNM}
z($FN{H$E>lH6<P*?3xSG3HDY}YI<f~d~#w*at1W+i&CMn50+2OOF@xMFHI~;iBC)}
zEX^!Rh3bHa6{Y5+CKjhM#0ONyyQG3s9VoO2Bx^&9g8XtrgLqJq%}mQoPRvUIrCfq(
z+|U%FFSVi|KQA?pxQqeTlv-2_N@0cu@n$Bj3;~s)d6~)iDXH;}#jbfEMoKU^1u+Cv
zI)Q>Y-mw@>AQ)8O1XQ{f6~#N}q$U<I1XMcb=N9CoR>V6NJ42Za5C#6p$)!a_sVNKr
zm2Nrti6!wNl?AB`0hJ&s-m^HkG^qq4;FF)19`9Hjng<Gq)D#dGWJE<WScfa9i~;eB
zisD^i+1M8pX{p5w0hNBGxk;%-@y;2k$=L`l*o^onGV%y0y(SieT;dw!9c&U0Dlo!e
zrH-LdT7FS(VhJS4g0fSHCr-Ke(%k%%l1yWU`1sP4%rY>GVB8uRSEUx^$LANt7vz^C
zqRZF_WSL)ZiCIp5a$-)ZvmwZJAjbulSe6#2#-}AFr<Qmk`PU+^G`FBMFS!Jq@q@fW
z;)A^5+ChmE&Vgiff-W;O$Vjb-M=FWo2Ea-X0?8eR*B~h|q_iL>HQq0^oFSmnKPf9U
zxg_2>F((JYWC*Bq$xJSRO2ZPZTTy;4BzZdKr9cxVM16d4YKdn_YA!=SrDtwIeo;w0
zg!0W#Da`>TLFdGR;?kVdc=yzjfP8SJgOZ&Slk$r|#a(cTWl3sLZf0I$NopB5bGs$x
z6sHE46qP2IfcYUsr7&)CabZyjLvmsgs3J+pEK5lS#e8mQ4u}y@>62Lu^8hGu#)Dm-
zS(O@J!T^<YEGS6L1LYQIHUcYg$uCXH0Vi~rw_Q>}IW;uI%>ouI&iQ#IiJ5tz+yGMq
zHXW9ip@9MlPlkZX;MBs>)V$=>cyN$|%T^;(Sb+?x71KbeCNm#YGUnuf>L@?Vn$QqZ
z6M`}rS|tfhP2frvwfaOVD?mj6vQuEW7w$G_bi(=W&<F(;uzvY@urLp(1bGV7T!I$>
zo_WP3iFwJXzNsY{`6=KMgdw03mFMgR^CH+G;BvyyBpxmbsv8ZB<DC+VQ{!_J^Agij
zi#((JED9=<GV@Xl4b33+jiDi^{EAOb1U20}gG(%60q5x!Tw<OKDHc6bT(ewV%Un%z
z@)J{B{elhS%`y`6QgTvVlUxmrKsw^fixLY8Qj1&-4dQ)a*0}}+msrL-=2e25KtbNY
zF7cp7OS~_{HSzfcsYQw4_6#Tp;ECBU5!{{%2@XJa0wl*9nj<_3aYhk_V*`SX;$1<d
zU}j!fes(IToI!Gme-_jv0>Oph0Q}xF!{xpBsE}ZsC2UkkFcyD?V0Z~qh8r4yn@fpF
znPrBcmMkdnK|vS~j>gQqw0uw*8xrP+uCO>WJ~=0`xEM`gu%Bgoe0pAKd~!vFp>bYn
zIi$s$Sdw4lnFVfZg?JKHf@&S81&-CO;6%?Xu=70OEL5FFhVk)bxj0-3N;{yejo#pm
z0yUt}GO$T`Mq&xPNeF9PS;oghHG`a(o|+e5Rszm<nYjfyo<2#2u71G=@rFk6zNI-O
znemB5MTwQ30d8PHGq~RP<ox{X%v4wZD6j;=(D>y1ykc;%>gk1&d4fyK%2Ja-K^klp
zADrkJY!>h8ikjEV;<H>`U4y_Tn#TL)m!-yoG=N*Uo<2ziu3jLmmhr*P@vg3}!LISH
zu4Voq2J!wOhVibUIsPH>uJQiCCFW57d7>!y0%<8REdf<eo?gL$VA~DNKy^lXYEgVK
zv@rF|_43IzaCLQcH8hEjFUu^>EQyEapJ2cE;6PAK4QgSJ1}7-?hzm}`(cq+J>NLU|
zoZt>mL1|HHd|75uNoisZsLb@lD8)gdsO1i*Ggkm<L!p+BG*9kk@nO*ZdvQsAQDS;3
zG_xbuy+juuu7<|(zVSt=#i=Fnpd!t+3|2G*5m_{NlTkEy#0PuRrDzyRVTB{#kA_uA
zDn^xqBU8h|3e*a>M2vmqrshJ1Q}PnQ1AoaGMWDgJMDSo>2)_1AGU4_NR7r3!Xs8KP
zPJmh}$)Gk1%}WAWv?HAJ3o7xoBZ9nxv9=^Yy=<bI5+V4?3mowp5FZ>um-1rxg(!~3
z*=UI3YwqGrqd3ZGScrxojhYo#7MG;vB1X;pf=dv^5_BXSG$)Y@8o5r)$xP3SFH6h;
z4~>MUCT16<rh&$Of>P5UlNOk&JWEoG;{8%9z=J8E;Y82?2-<)mbQlCSln_t}ABO=k
z5aUh|1)!1<x$BAU1>}K0bUDxvcR^-qa%y>IaVnx~0~#?xI07`H6;J{iL3OQ2j&~|e
zOG_<69_tKFErE<~F@UBTAiZvK2H!!03wbG^@fy(RJJJXtv9ku?afzbTf}F(URM*_x
z0Pkebz#7EC@j=j$Z^)3Z8+ddSG{&1zl$w|lTmqVVfejRgAc?u8=A@RSI)lcC^FVP1
zk&7=WE{+GyBL!5tg5p0ou`CrL12+<^Bpo!>6i^9~f>;uomkb&KPEB!71(^rd?g$yF
zhbUtRsC4)AfhcxQEeXlUEQUych2Z9cd7#7w9dUL`1<ejXd>51oYG{JS4-v8GSW;31
zjVAcOrAJ~hiZEo@5jGSB)$0qHB?zbl55vVn2fRSzQSm{ki7Azc^cb94f?^zaBoV3}
zYFIEh9YIWjBwtVz!A3bDqpHY5gYb9)n+4NRTvC)$3Yu*pBaxUPk{M{64?4aYoLT}J
zoP^{{#HgEJYPo9#`6)WL6qK$INfB+x58_=|$Up**A)qp#2sCI`QVEL((A-yid{R7U
zqLCq>5;PVZmReK{nj;LT1Z7Fcm@zC%LL<=`Je6ex8+wHX9XthqGBqqN!E8`70;bp{
zH3u{*4OJWu9(*A+N1LQ&=B2nM=Yq<Tc)$D-PtfE`ZfaghDroKoG%O8IQLrIX3hV*p
zb#STSP5NY`X%X0|a3e@J!LpzfG~t(+ob8&7$PPiN1)xF`9J=5VA2M?do@>f0LCo~R
zMy^fc5n}NLB}InD@CGr63z<nVfVQd(38)5-ZbOnsFt|>GBoD|4G6B6N#pQ_wu0g?I
zyFxrsh8aQjrsWqUr>4Z0f+xp8vvZ(C7zCMshFAl!I4m)zG!<FEGcP5z0wNF(onG_F
z&(AI`0F`Q$1*xzU@0*$%?^cuwnsEos^+P8+5upPb=O^F?n6rFSbMuQp(}4M)xPTQj
z?uhIT8fs09Pf5*9%u5F?W&q6;keb#l;(g;&ixP`LwGO1TKpUzA#~m4k704H`;?S`e
zG?fC)lj!rFh>0c8jHe%{b^|TBfKNk$Dhb$>Bxuqpq$n{tH7OB16X{lzm<yg^^2y9g
zh0IbS*Fmm%#id1{x&&NRxu=#mm1gFYKxT2kLZI>qQbU0zb|5TB?F6afAR^%U5MGsl
zYgn)lWXc^hk(*eY3M~skl?$>H5Op^!0--9P>OG5LB`bIaB^Nv+m!AxY3QN#<GT35p
zo`5W?KnQ|5fMLNUNCNQc5!@aCHS2;>(~3cc5tuhLG)v1bN=+}yF9prV=jY@XfjgB1
zb%El6WL<`kA)sWUtuZP`(*f#p8yZ3uae&vyfPw<F<isc?KQ}Qm57G*T3nH(ifeRw9
z1c3>fW#*M7=47VCCl;lbf=YY_cOOqD=XfJMBRx|%+XT)sG+}Uec8)jJGuAVNvJAkq
ziJpO;0Yq6uM7*({iJlQE*U*B&IU>T*$ur(i&sfhAnPY^+K{3M61W88E7)8#=5LwO;
zg$H#x#32j}43PD6pk-i?6;&V>WGx&M18nsiNDQ<R4YbOUg8{UqAG8jViGd5Wtc!tx
zft!Jcfro*Ofd{0Jfg5fr6IdQ1%7A1V69W$e69YF`C0GmC43G$n#|vigfk}|fAO^@>
z5X}I!2jp@X<_G%&<SGsZ76y>{u$6ou9mp;NnZ^XR9da@QNFK7f474^9;$n~($kiaz
zL2Qr@AvA~-W&o)Ig$0NQaurA|$TS|PkGR3E0qF+Gf@}nZGl&h+0n!N)1DOI71Nn)G
zL5Kn51CUyfJV-4_9>NBh29jZ7V5BijVSubr2CbznmC6LKwDf~6P-J9aW~hP6gU<F4
z$;{*hsg6<skqit|CQf5xVBlj&f$|~xc^HuO=OO7&j924iVBloPhpG=ytK?>2U}va=
z@)M%eIYB9>5pF*>Lnu@~D0~WjOlM+X5N7Cxs?PxP1sP^R`IQ&fb2BjTGpvO2i@<zd
zhHX&(<@MRDpx8YO<)?u4b1|HQ@{7UhIT-Fj`GsJ4HilPF{zvh@T%gk_enR=BVD-!l
z?5dFPDAAn60g5#d&_NcU^FyHLhCt$(fq~&N$QKL@0cheEE<(g3(8M=ff{16Ji7P<Y
zJr<ye8(e{?uRs%@09_Z|fF>Sr8nU9b15F%e?hG_>0qA<v1!&?Mu0!lyfhJzC8e;wi
zH1P(gy*tpvVdfq{6R&{UdjU;c0(!p64K#6>`VVO0F!evs#9`_MpzB^?@udM>AFF^v
z+yIBT0}k;39O4N$#0zkUH{cNOKo^IG&jNIDsJ}Mg5Wj&YE&yGh%m7Vyu<$8>iff>W
zFMx`Bpo#y0n%jUTe!vw{-gTgfKhS`PA3zg70A1&N0!{n^)chN0;ya-H2T&U3eg@FN
zEes3{FVMs<FhSDo4>a+DSV*nO0o{K9Gv@)+JpyRrF!v~+i8Da?8c-T$4$M6UXyP#U
zIG~A7fVw9DO`KsR#GMgn;xPAQpox1x`2|oK-8~g(;xPAgpowpQx@QKOxB}EYE6~Ib
zK*e{Ui90~|FPuOVhq>PXntoyK`~X$&fF^DLONVIUFmoc%#4Vuw1SkzN9~LheXyUMN
zs6Z1BfQG{gG;sqrNP6CYCN7`}5#NC(p0E=legaMW1Jqw1(8ZzqG9;koCCvQ_(ES${
zXyPxR`XkW96ShIpPX?O!0;qTans@+|-vFgy_FjOh??4kzfbuUuX_$Hj=>CEiXyON;
z<-i9t@d;3I4rn<CGbi8}#Qg$j;;?dF0ZqICs@?!id;?V60!^F&%J+cMFnblC>I2Zk
zVd*UaP5b~f{4>zS??B?c08QNB9z;9=x?c)rFN}X68q$`BiSOG935OGC;s;Ja%(;Lj
z?f?}RK-*X30Ck4~nmEk;4rt;q|HAf>fJ)PaNbR^2&~h3i4m+m{)PjKN1BurnsfX<o
zLKlyKme1(ou<{;V99Hh4i^Ix4ba7aDfG!T(H-jz?3lDU0*gi0HaacY;7l)-&baB{z
zAarq9dPEo3fW{lTI4nNV#UCKW%T-W>Kye0AI3tT+fTmxNImqG*p!pPC{DVIveS-Qp
z$m(JHu|Vowk>VZJUO*S00Ie6$#TVcZ-+)6L*1khG2e$tVT^v?kqKm`IKXmaENa29&
zFIYPiUHu27@Q0mI2Z{m#r0|EGM+Xv@Kob7~5`bb@{{UqEHl*-`wcpXjEs)H44>bcs
zB_N3-pM6(>Bn~<!52O}^7x*FK7g>A)lKKviLMZ-#L)-!>zL3>7;1GX+L%aYfeIlFl
z11VmR#Ve5V3$pkEBzHoahF~A8KoSR?6$ln&U|`sQBn~=%5GMWt$(<Kqf}rytk;Kc9
z;_C;J_zNWU3y|^=vN#8lf5C@sLiGqBiG$8KgbFiAAc?<*34-<-BZ;$s5(`wW14$fo
z?jlr}VFHr)X_z1b1A_*%UH}<^EWQ9q{eL9&JCOW^EdBsVJ?Q*KxE7>%1fAsw6X!q@
z{{RyNxd%!7F_QQUByptUO&K;Ii9bV9zXM4ed=4a3?f{bb52zT3dVnMjI!6*D2EqkM
z`2~`5K%xu`6-eU9qjC*M;-E7xA*vY|I*`Qg!UP!@7$zWzgU0b-QZtamxnP0}3=Auf
z#6f33z@#=HiNp7JGB7agKoXaRDP~|`IDjPn2TA+{k~nmT2P}I5Nn95!0wHc7iJL%#
zz~loYaZ|7egm{4@4myt$BFez<0ZH5jCdk0R@B>L4wpSM{jg$`WfdwE02a-7Kyit&h
z0Ft;DNC1i@ki<Vj#Xyt-l6Wvk0E#t`#GgXNK$HQJcpOLoiY<`DQ=wuY$^l6nbnYog
z41_(9#GzeZkT634k~r*WU64csl6W;p0E!Ec@-?z}0+M>zIjkTp8A#%{Kmt%)fF#}o
z6$4QfNaF1v0Vr-j67PbFfv657@jj3M6i+}Bp9B>HQ8SRlr-KBbcm<L;=!`a~FvA8U
z@$E1{P&!8vKZqoL0!jQ3lK2HAanM<@FsU0z;%8xk3=9kpki?-wgkaehNaD~TMX>k}
zByrH$h+shm28J2Xc0Q;amVyZ~Ffc4Y5?_rZE`b!kK1kvoNaAad!~>ATL1$IKq#}^S
zVSCj<atTP{TR{R)oPi|14=M(tBmy9%BWNrg<Oh%#2rD3oLwYnIQ3eJLBymU&2qJEP
zBo1nWLPQxDERe)OcEH3Pki=nqDv+E9k~lX=0Ez>U#38c;5QzvRamZW;L_7gW95VX>
z5zjyp=Z6S^$pR#C<Qb0&Byq^>23R>m1Clssz5^o4z|estE({X{)fY(Ou(KdQ(le06
zML_~kyZ}iYdL%YjW(ATs?CcJZ#0DgBNss^(??4ilfr^2s14!bsAOR>ofg~;m6$4Qh
zki=nUP=Lg5Ac=$KIY43{`~XQ@5hMV`FObBM&ujgFBn~^f0Hoyyk~nneA0*7c5Qs>(
zY7h}H$$=!U4i<qB0!ZTUGYvrJIUtE^LX?6@1tf7Tun2_EKoZx62!TlhByl~k2!yae
z64!?afk_7>aRaajgz!KTH-rd*$p9pABd`dBh(HoIh6sVl1SD}Yun2_6KoU2H2!Y80
zBykI{2!yCW5{I4r0+MM!61M^gKye3>xHVJ^L`^^vw*v`4@eCw!d#D(QT7V=DnjZs+
zf$$0>aYv8<6mLKhcY=z6s2xb+&L9COK7b_d0u=*MCy>NJX9|PFK==ZZxI0Jyif<r^
zdqBlN)B_}OPmll<zd#cAhKhlx4@ly^AOR@;fh6t+6$4X2i1hCd7Jv{ONa6tyAuuU`
zBpwJBfe;c%;z1B0FsXnf9s(AD5E@A0p!q|HC<B85l6V+Q5Om%?l6W|hxC4@S1d_N1
zl6WMNcmR@k6q0xZl6W+dcmk4m43c;Tl6WkVcma}lJd$_?l6V4=cmtAnB9eFql6Vr5
z_yi>JWF+w!NaCRRVwltdB=IzuAgCXKB%Y2Wz5z)*14(=bk~r*4B#`t0Bys4~5FlZO
z6G-COU=av$0ZBXuA_OLHAc^OKMIgijByrF@HAIww;RTX-K1>kQPe&3jL=yjjBwmCh
z&Jc`9|HVk+97y6NNa6xW;-yI95=i1@Na6}e;uT2Z8c5=mNa6-a;?OHQz_J!d;-L9{
zupk2ig9DOy9ZV23uZ<*Lk0c&|B;J4|9)Tp@h$NnXB;Jf9o`EFZf+SvmB;JZ7UV$VI
zI>Q$x)qo`42@_;sVCX;+??w`zfF$07Bt8R49CYR{Olkp=ct1=Kl>U*#Cm@M$KoXyb
zB)$Vl9CWrLOzHrVIP|I#u+#}8apa2|E+C0d1FM7(H;}|<K!m{L10?a8U=axM0!e%p
zL<mfNKoSR?tq&Fi^`nu*=fDI(bO<8-&js<Jm;*_C9#jlO2_T8j2MIv21d=%H3^$OJ
z0+RS5kN^~GAc-%Aih(EtB=IF60VuXW5?=}x15pl0;>$n+Q0##uz8oqBq5_b_SAYbd
zI08w0B~%PVB_N5f0trBI29o$%s2GSUKoVaM5`f|gB=HSUF%Z>&Bn~_K3nbowB)$nG
z0L2rK#5Y65K-3H*@f{!mC|-ahz7r}2qE;Y@?*a)x@dhMu&>a9!VTK(@;(K6%p#C+I
z_+BLO6G-Cwk;E?`i61}`zkwuv7)ksAlK2rM@fS$qN0G!oAc-GC690iDejG`h0Xk0y
z>QkOT66Zh?hn-Cak`_P`2VaN-5(KsXk;KnH#Xyt-lK45002FH=iJymxfhYqcap=+_
zkT8P<k~nk;5m?*-N&FgE1VVTqi9?tEfF%Nu#BYE_Mv2i77!85Z5Eu=C;Sd6!`Q?6j
zG{52S=w>~6pP9j<^*{;J{|g??M>rt0>VMNm_n8^~t3J8U%)l@2!0=xc#0U5EUOxE$
z|Nnp0Tlbk6GC)JPFE4=kmq2{b(Cy0uVE!o(A2ek9as!xu2*d|9B3~{5^LK&xpeeDJ
z6TtjUAU<d)_hkc^zY4?$Rktq-!2CrZK4|FnWdfK#3&aOag}n>_^CyA$peeAI4q$#4
zhz}aleQ5yZH-Y$|q1=}WV15;d4;sRKDFEgdf%u@I+m{Srein!i8nS));UCDqNgzIG
zsP^RpFh2^!2My7_ya470f%u@I*_Q{vd@m3mG$i|S1DNjw;)8}_UoHUitw4Ox5bVnd
zV7?KE4;p%X*#PEif%u>y*Ovugz7mKJnzDPD0Om`9_@JTJmjPhD5Qq<&5_stV=5vAg
zpsBo<24FrDhz}Z)eW?KE|GLM_kO3NseJKFue**DAL$EIy!2DMrK4|Fm<%ho@|33op
zK|`)DAAtF{Kzz_p>&pvZ{v{9}G{pMy0GNLY#0L$nzT5!j9|G|~Q-v=Vfcd*Xe9#c<
z%L!oqCJ-MqwED6E%wGlKgN9UJ7J&JSKzz_p>dOQ$e-?-j8bW;;0On5u@j*kUFCD=A
zE)X9yWctzo%x?nmK~owp6~O!|5Fa!}`BDJPF9PvFL#Zzr!2B!_A2fve^1~mH|C2y`
z(9r422Vi~_hz}YveR%=Q4+8N)L!~bdfcah^K4^&a<pwa{3B(6YeZE`(=39aIpefIn
z6To~U5Fa#j`mzDc*8=fDL#8haz<ebTA2d|@G6Bq&0`WmZq%Q-&d?64YG&K6s0nFzD
z@j*kPFAczaCJ-MqW%^P9%>Q+lnIQu-Rr*o@%>M-9gN909GJyH7Kzz^;>B|qlLH>UP
z;)8}pUp@fyZ-MxrA<>r?!2C-fK4>WP<pD7N6o?NR0)4pw%s&L;gN8m|E&%g)f%u@M
zG%qKB`I|s|&=Ba$1~7jWhz}b2d|3eIF9PvFL!K`a!2DStK4_@(WdN8z3B(6Y*}ilD
z^SeNN(2(a#12De{#0O1*y;K16t3Z6v(C145Fuw@I2Mu|?WB~KCKzz_p=gSYjK>kkx
z@j*kJFCT#UQ6N5OX!GR-Fh2;y2MuYyJOJi<f%u>);g=i0d?yeeG_?700hn(E;)8}X
zUrqq?jX-?RQ0B`9FkcJA2MuAqECBPBKzz{9<;w&xUkbzr4OzYn0P}@Fe9%zkO9wEY
z3&aNvQNA<)^O-<=(9q;d1u*~D9cG3M(2(Ry0Wkj)h!2{Qe#rplzXI_=Lz6E*`~>;`
z5r_{Ol6?69%)bTVgN7nsUI6nif%u>y$d?De{8J!4Xz20f1~C5+hz}Zae7OM3-v#1>
zrn+BF0P{D2_@JT3mknV4Di9wu<oL1x%wGiJgDRkx31I##5Fa$e_%Z;@p9JEAh8ABs
zfcae@K4?hsr2&}V1mc5+5??BS`Bfl3XbAD80GM9{;)8|`UowFCSs*@W$nfQdA0YoH
zf%u>)^_LI8{3s9~G<5j#0+=5J;)8|^UmgJSy+C}>P~poBV7?QG4;mtTxd6<!0`WmZ
zgD)q5`9>f<Xh`s71DLM`;)9kDy(|Fpl|X#Z(BR7iFkcG92Mr0n3;^?mKzz_p;7bQE
zp9{nXP3gZh0P~qZe9(~KO9e3h*KKBo4A9cdmjYn^ClDVrH29JM%zp*qgN6iOe)taZ
z|056|G!*#q0hoUa#0L!lzPteDUjp$#Q~xgyfcd9De9%zf%MD=uArK!l1o(0Rn7<3e
z2MztboB-x;0`WmZelHuq{8b=6Xvx6K0x*9Oh!0xI^)dm>p9SKBh5}y(fccX^e9%&Y
zmkwZl7l;oU5`1X@<~M=(prOE*3SfQ}hz}Y9d?^6t7lHVoB?m7V!2B!_A2byB^20Zf
z|C2y`&=BCu2Vi~_h(8f@9qk1$KM2GJElqfN0L=FS@j*j?FE@bsP9Q#L=<nqMFy9Kq
z2MzhXoB-w<f%u@IzLyPPz7~iNTGH^c0L)hc@j*j=FB8CgDG(nt)b}y~%ohUjK|_2m
z9l(4p5Fa$O_tF5&X9Dp-LwYY2!2Dmgm>DuaLwPR+!2C}jK4=K<B?FlM3d9Eu-M#$q
z73BX%AU<fw?&Sk8{}zZ3S_=H~0+@dZ#0L%Cy*vQsp91kgLv}AWfcb|&e9%zc%LQQm
zE)X9yME7z6n7;|c2Mx`=Yyk6Df%u>yxt9fCzSR|GhBQ$4gPY&M9-Y5Ey6Yu8TK|`@
zzL5L%|G!7KHHgC&4KB~34}0{owx4EZ@aW#70$Nz-(b=K`y4=jex<)0Sg!RSipa1`R
z^s=TvmCRsfU;rtZ0HUq;sDRe=m9V}z3Q=VTRrP`iqUr&Nw%(%x8bK>zeK8-RN&>11
zbmue3ECaBr8WoEY))zGpC0|cLT-3n`F{lAVTi2*)l(4>t1S#o!|6=1`u**(Cm0~!a
zzs2SM|Nk$ve*XXe(&|50?L6FSB|vKb{rLa?CEx%5{{!}eTCgwdzJavy&OZlojp>TZ
z%nTmAqLQZ=89X|Vd-SsYRAy#K^We`r2qI3T@#h@m7i532^UwePjv-(JLIYm>{t7a}
z^oa^HSX1ZG7dIj9W&#=7D>}Ok<iqzKy{0G6f|R&2yr}r||G#JF5s%LIFJ!;}|L@cJ
z{Ke5f|Nnb*zTXFG*S?tX10o1&FM+M`=qyp;@aWA^5qQx9vaY*Cg<~fu$#`_W2N~4e
z3>qT!&~65e(E9Ycs2F%0{J{#+<**CXQuF9FeFJh|^9x3gP8St}7t^{yUVI0#*&7tv
zy{su`KtWKWBH-D{qT<o(qN3nodAx-6#hLFQ?}=V*Wnl2=H5EI<%mC7~?f3uxP?v?k
zT=wY;DD8o`o$q&o(z|Ep5r|uQO_zae?{?zw&}QnM3>wDtIQWAF<P?X_5EX-6pw`<9
zCWM=|{{UIa+5t{Sm~OIwxXBUXCacpBH!1xF+3%v_0P4f>d-T?*80-RdyF5Do{lDPR
z`nH4v6ySfpLBci!thz=;z@zghl6UVyrCUM4-1+{6E=XDD(bum%x-rylgsP2%s%3<!
zg@#Ot3df7PpFxg-MHeVI96URZ>;g3hJ-XdEJha(7dQDF#Gc$k#gn#`D&+c|mTzYD^
zgW?hrjUYdD=BNaKQh)-;6W2T8(boeG3)Wb0!mm+LfJL7HB>H&430zdH1sr|+ryxP~
z{pbJx{M%eq5^VmLvUoI~`0vpx$_x(1_dcD^{)-#}Sz-h(OKMaUpdkb`arak9049T?
zyYu}EZjdri2)&s22_%!P@j?R>eVs>NfZ87*lPW&_|L+M7KX4&c2{obc>;L~R{(#)y
zdGv({C>eIXf3XKd_uA?zGc&vh_GDmqVg2d<{}<mt`S#Uh28IbQv|+X!g6g~lw(b23
zA+W^r7g8W&mqI1?LM2mwLKEx@?@yq#WvT-T^UmWQokw42f_%`+8UzZ$UeVW0ko?-|
z3QF*zr<fUDocICHueqN=etiBy6y(g#=P!EiGcka?$O_{3vhqR9Sl+|{$|jJwFuiz^
znc+nXG*9b*5=7_w7gs<I>t(%r5?thzp;)>Aq#+ojp!4|)ZKw^4!Tk3xUPHY(`N#kN
z6Tm6$Ma4(3msTo)%9rDwoyT8<ft|zaegbT|1lT$MJv;e5dQG`cFf+XP1`3{TX917a
z1Esb;o!?(v{qX<4kLBx9`xn{YK#^sm0;)q;Uz`Oy_x_8mA3*7NE~rQBWBHiBbtVe~
z!wXRT3e95oJUZ|HzwmmCXSXZJ&=Ov-xKHOhpU(IHFL*W|Rd~I?qx0|!-R~gN_k+_m
zI5FgaEa=@^@$dit7Y_HB7(BXNH-IuQpGR-)0<a<A{Oj3y?<Kez>D_AqQYs2k+PgR6
zA1G$-zhDD#yZ3?yNIY8q^SAy2)i~X)8K7FBdoO65#PFL(uLyYJ<Hbs_U%;Xs$6G7@
z{|B$j_Bh@O(hjOrJ*@YFy6PpYFV2AyOZQ$2kU1c8IYG5zcPnTh#iM(##{d8Sk<1N*
zm<tm1INk~xd;uGFycMJ!%(ULS<L`e^JzWMd7c{^EcJFP7dw=``h4Nm|I17@wKi|Ve
zJ&w0>AlwVm4mEcL#9TR0;^<y_0&LFQ1EA2cyu;tR3T*sd5FZk)-#{s*d+!R6I&d^R
zg$RH~U?3{4eEk34r+X=A2*#s(E+~3DK_+!UOak#C>efIsf`(!s0<%FHJO97<3@#N9
zdvxyw4U4?^B+S6z(Y+TmWa8O*|HWfr28NejAnUvL{`d=u#CtCmiZL+wb}t9bvUqmS
z2Q@svR)SW8dUo#z@gX)?e*FL6w|hCbnCzYpN=jgLVvGz7p4~`EOYkE&t$~_K5RD9A
zjp-Sl-SG)vEnZ+P^$8H^haW)d>pdX6%MhLcgm?4<$j)>H&+d2$uvSZmR%p9x8CbDB
zMD0vaUh4e*;v=Yp?A{9+g#tx#%U@8!t@-f(|I5!{kAs_OtS_=a$)@?R1h`$|(cKEl
zV;<cW5VL$ilAZTon7#$20jS(u&_I-D=W!p)-=(ZCc7f7T=Y5an!yYeu_!$^pzwqdm
ze<1?V`0_2NVFAhM&`jyk3CXM;&4(3U9s;?f^YDwQplsNA|Haui|Nnb5?*&=FP{QNU
z4Q9PK{{H{}7eQcq4!_9y{Qv(;Rgk`J`4?+JX|wbG%X?sJtUY?21t1mA6p#eShRINs
z%^-o!`!9Jwts`g?)uUOTv4qnD<oV^Gz|nvA|NrX`pav}593PN2kU7SGK_%~hP$BZ-
z?f?HT7o(da1vV!PBn%A=J3a=6m%hLM|9^4q?f?I;?}PNN`Skz)%k;nh|4%?P;VeL&
z?ln!60+*klDnSe!b*$?_rE|Aw1*90AxF1yOzV~Q8AmGvI%J5<%s9J+G<HFv89QXXi
zzfYj1p=akGaKRiJ@Z#=kki;`kbF%a3i~XQb?q-dE7^?^|)(XwoD1@>9-+**Kf3f`2
z|Nj#LJbG=fN-{INm<=k8dTk$p*!`eZ?IRFz7ew3u5tl*4IS_FYL>z%Ap9NA5DhXd~
z{tq>6Gf2o6BE1L1b_A&>%CriQav_j%kZGVM;b%}pb?;FD^^84wTU5Z=4%~$71f|{1
z_b(oTONQq!PJ&c+zJGD?<NyCJ%0S7Z*H%@Anc+pUBLl;J(8%VCWv@WZ;p3j2M_zn)
z0ySMkMM9ZC^)c^ZNDIakRP1yf_2_*5g6jsP3T}c3z2^4md=84kL$5(*Jb&@(Iz&DR
zB!9d$0$P5)RsgwrE=W<YZQNC6h8KchHn<Xbu@$7L7hFfYSP5Z+Dw7v;LG13m9w47@
z1SOm1y<h|RTR_E>M>m-FV)~o^|6hVu$$RwLPL^h7c+u$q@`P<Wh+XRd^W}k;AQv77
zB}+kwFZDvezEnR1N{RPh_<#8S9}*x_5lWvqg3J<ShA91W5TaBCt~3jx6cl#5Axduq
zgH6475E6Ev`s5`$B-*b^F*Ce)ZO_2qfe4wG(*Hrp?){4m*O(Yy%zh4PT+}XjvFI8T
z!^=D1=&IfEV#+m;nR`LC=Zg+7+g9=lGsBBBAls45IuFv&dH;pUtN;IBZ}RA^-SHw4
ztQ?}%7i4HPNKLP8l{hoQi+FnmhL^Mc!Tde<1vrR6o_PljLs4#sXIP+~(E%l<UfWoZ
zKa}mk&8`<GUjG085)?(CHpGipSD6@In*RU)|0O7<JUZ{cSOJpv2IT^9Hhp0MvZU8E
z6Dj|LO3z-_{rkY}ryCW>O~R&q%nUxgTT}!X85mxyeFt*iVNesQ=)?d2uj@QI--F`Q
z_2vKnFh#E)di3s50d3lP5qA|7YBeeaFG9eqJu0AqoEPp;4k+)uu!3?x-J}<~AWrul
zNN#HVU$XjzH7FpL_;kL1A$XOE;q_IJ*<h!90)<3#jfw$72^XlhV(>x$l#9AuR6O9-
z$v;r+bl!gv26A?<?R!uzerpR#PY?%!oWAP{6T{1JaPmM1E(HlXfl@saC>!<KZUJfC
z1lC%kQUKD|1X7|2)@NHM!OZYt3Ro86MUa9-kOI;Fu&6!s3>0+W7Pv4d0rrX-1cE}x
zRC7NlNxy#)2rf4cg9a`@w>|n;zAs^YVFU6(?;h|F#tVLsiEBWqr}OaZm!OaUhw_ih
zObjolg3=JUlOGAPsMmCp1jtyhecPXcYEw~*!=OH|=}QpR`5qQsFK)hp^%dkHIs*_o
z|AO4q%erh2IAQEBLrxf(dyo>w6i^ZH{_p?)FJJwI`S=3JT1cNm(GC>oqILmbADe^H
zS?Bu~@o<}$f|T}}<{@luhS;nFvDp>H=J&gq8D1!XilffMueqT~5FEa+g!l9k6T{0U
zaNUSdu>kBnXax1H0T<mbc3*-NmzzO4O29h6DZ2RC|Nk$W;DO2labT-BJW!LKfCKe0
zs6gsAodPbx5P{nA8WyOhK<au;FN?u-t^m2bmv!cDaG++DA_r>BZlpl9fBpae%UOT^
z|9?3Z)ZXZ|eJ9Gy@IuEL6qeAMr}OZOpBI@JUhet>3-u_FeUMOJZ39v%dcqGJ>IXqV
z+4=s(OHej}1=Jpp=Gh2u*F63I|7GRh|NmcbzJvLI17u>aX(Gb!&%jj&YyU2=4_1^Q
z`ygl+GsBD4S1{+Cehg3cG7#rjLY!j+bxsu6Ikw#(uLW8$Fua5mk2NY4piCqKa^G)|
z?~$VVI@m#bR5(CI(yt33-|bNW?UsG<_5u^b%QK*`0A~e1kmbFm-yvZSDphqLE>DHH
z{9Q4)1ci27H9#&u4a#txM?sZk0mz!p_b((so&lTp?-8hSFg=ej?+)1YtY>$ELt-9^
zc@uUrGrXuqn5O_W4^&=5O5$}8^Xd`i^+3$4g_!4uVx9xYJZ*$|7eK!2eE*^XB-C4@
z;_>3$c}Q4*hKpZ31aoRs99~=pvASzipbh^QV0YYq;Q-Rt-2yJEK|SMC&>)h>3vmfh
zs;N=2c)<&0IlN$ovJ75ygUxDD0d+?}9oOZcVhA)mjOe_+p6r1zwd4|50@gKteHf%3
zG$0EW26uK}w}ZsMm4WVgCWe>pkV17LC`H&?z*-MY58(;vvL(ocq943LzBPRb3M)|k
z0IJpy7W21+{{R0UYzxftm(F055m{&7IVOgeDj>nm!!Hkm3s!LEFMIU=|I5w){{NqF
z_XZ@USU|S-n%YW(b1^6-Jpx<DS`8}8x=mg7f)haO7DmuW2&l~rN>nduL9L0-!>>g=
zdTl@QF*Ce4_XX6}`2S)Hs66Rz1x;Cdbc4Ie9-XbAUbu(#UJpp;))5@N_g~C>4$|@*
zlpF3n{Qv*;35bh|9)Q#0YDg^(a!~-pMK3{4={DU2%3r;rr#GXz=ryPi>^%Bf+@sev
z9^@h$u#3P=$a;_`yFp{2-Oy69vjtpAf(Fk8N?2cj(`)DZ7i?fBy?^oU$^ZYa&qCbu
z=swsz(g^n)0C~QfH4@?;C5U^h(cBY_<eu}q%nUEqK!%(^P1^S$FLt}ANPz113efmz
z0mvmBC9E%0Ksl%L{fioqcF<Vc3s8Cd`r->wi1ru3;6(oZ1;~6*W_AYgyZ1oSZEuST
zsJQ{@y4?i%y7T=D!)KtL6KF)C^Z5%AsB&<#zPCjMl)@p(S3#9CJp)I}i&x-idjI0n
zQ&@R<;~qF993{bN1>})!U{|vGgMy&jR02})8*W1FUj>4aM6c~B9%cq`4+u2U-TD5-
ztNRdpCc(|GfSCUfQCWsT%m>wr9^IxpAcfn-ji}~-1bL~~)=Q3=;e|V*)71qv-{|T8
z|M1zBUS|!6Z})(s0NizFi+;K8!T<l!havI(=`Prpm-*nnya4t9>(8y=tS~7LxmMV-
zm6_p1{u9v12Y4bt1ZwLZkfS=Ezc4ussfO2p_`SBdAV)5OG`$i*>}e2oD2Uw!Vs{>W
z3EDsJ(QC^H5-S6V_1gXdwW+fp>>D6<9E3ermYLy25QJR`5_f~Jb3tq?2zv#Htp{O0
z2eFkt!eW#S;#W>ch=cOl6OcQ*S!+Q--EHayDuQ}N<2Rt@wR%v}=(Y6+83r10^ysw>
z0XgI(xVdfnL5!K<#a;+o8>D6<cq9d!6~BON?B1iY0yI$s9<tg5iiuv<+Z#ZQxIHRA
zKoXrTDjz_!b&ZNb3F`}fP!{Zb{~{e??{$#*u@LiXKpjr-h+VJkevr5;L_7r~ZV6#8
z2Z`%K*f}6^MF=|q#1@6HZ9r-`A?#id`!A>&-fQ~?q~;@py#d623SnOXv2Q}yKS1oW
z5OyF)??DLr1*o9k3Sr*?u~$Oax*#=kA#53t-iZ*lC`h~&!gc|PS3=ksAa*W<%?nbK
z2w^LL#6uzMDWEQ?Cxk5zQez8Ye*@WT2w`spu~i}Ll_0hxge?wI&kJE!gTxsj?0gXW
z>pSomOQ=WZ-(a8abPkVhc~8qbC8{3X)e;`??34?RR&aJ=eUSj-G#~bOea)l0mH{*X
z#u**!81vHO?*IQF#^DJb&2J>S!WBF^|D||zv#5f`3P7bGhv9)^?ivjI+YUASLd<9w
zZUW`I8WncXghscE3P*~EF+@)Z>x(U5yN*a4_COi2_UL@)0UEIem5_!H;Unx~x4?PZ
zog1FFzko`;Ue>3e)YmJzEeknsuh_uM@M7`<c;2?S4Jol6fKzOZipGnu<B;5a4kXg~
z{Dm8ozYoecgYrS;%L~h!poTTH;_05F0vhr3=$rv=)9eKmeVs>NTm_}{UTCB5$1zYl
zV2=vuyp9*Ip&W3}=pKmE`Tj*1*q);==7F?zzJGD;2FQv%;8Oj?&D;O~zeu_F|No2q
zU}31uoy}kyy+IPoZh(BW87yE05||27*|{1lpb2%8Bh>IpkX$#Y(_0TRnF}hd1eJ~g
zoAv%h5=inbC|Wv?zF>t)+JYs&zi<UfUVuuz0GZGYYLM|AV`6y80_v8EfEBI<J75J=
z-2srg&i5}ez=j=tvEknT|1TedTQx^tEQU(nz7F!r_ZN?E{r~?W52~{br1BW3y#pFy
zT5%K-TMGC8|91>^4Dsnzy}F*60i3i!DblAqAC$b&lccBR-4gAFY7K@G`L1AvW6l~3
zpsBWoU;j&(`L`VcwJq5_I`29D7dhh5eAwXi1z4hIeGv{yZs;kN={9I+_J{;1Cpg9)
z-Upfw2PM<2TmSzz)Tn4Mlz=Ba1&+C>XfV780XO2_zsR`<E3<>HgVQiKq82s)g-b7M
z<a%b%wD+fU<TNa^o|)mrc~Efl+IDa-GrTya3zi0z^%<ZD?Tt}U@aTN%(fpbNG^WyW
zgo(k!@^$HZkdwZH^mQHvF>{VEF?e>~@c=1*eI8VWgIPykBwquCd$q=kU$?;-<%Q5)
zkihd7Ue`eF+V?MlZvOxO;x5S3okw4My#o=Pd-wnU2_C(+OF;t+#vmv4LS`smFdt!J
z@ag>j;`d=lWEF$l0Fr$15-O4iw&4GZn^1lr#H<<>2~d;dFi5l;WEi-1xdQTI=ld5r
zaAOvM6m-6SAq5t(-3$tpjXI!)ca4g~i<ZMo46pZ30L3cUxDt?RgmJA<<L-j|0d`d|
zNI~cO7pK7@wkaUvlHkUff{pX&we<msdqKq&UdTdqO$F<MI-LU~h_Fi%YF8ml&5P%U
zm>6E)1-VV(#qC3o@CgRX+P-0DW_a;R8{!Rx7ki<yreIm9`71zz2=jM>5)!C?0aNp$
z9m)J^kmAnwFFxOf%rO@r=9p#YuK|rfe)H*k{$J$qOVFAppWYM|2@mMl18Cs3SGH;m
zGs6qhLre_(+aS$Mm;oT^&UgPs4ub~2rhtt{Rp8MpYP$xMmO<|B-2!f@gUbHS_b*bx
z%3V|nZ2p(%dGyMPBD(}M74Cqr1+*-}xAQN^iIt#S)O_Oq>obsHSiUQuWC$LYjt9qy
zXpJ4HtTinKoA><1Tu{!1^p>5jg4Di$@#+?=>wn=gNCZ4Vs|e9;2hnW~*8TrQJXrT(
z&=59wqT@fvy58CuFVqf#Y^j~_LKe)}3tGATLJ-WZ-SL70#OS>Lq5-76*LEYQ`W4p#
zMJafS64X(8dH`eqWX$#E0VammD<B@SML4MsoCri$+k#Y@E?EtVs{b#}fGQu*P=ik=
z*hx8HCqag}CqN7ZEjxeF0%3zDKVMXUESLx$>&=A-gJwWqB!bwT_g~xu83`H)4gjfp
z2v+9`VqWv;wf!Q(%<v*g6YO}9FF}siIKag45;WQ1(RujwMzDHOkoskihIi#9aKW~U
z8C*Go3Mg>-*~{v&5|kK3C6kc{HMm!T=D$H%1muLX`<WPCMuW$@!5zxp%m4qs1Pu*C
zjFy8Kt<C~B`VZLgtZ!F<joz1pZ1jc|pxK!l|Np<<2%VX~cM<F~eu&dR#mpXv{<RSO
zbxGht6*QgX(Q8@&(jR>TTpWTH6);?el!z-puI=6nno$NdidbKmgCe2x{)>K)L@y*V
znD>M7_5BysH(<#v5oCEMII(U52dL<IYjE72SP6>T=Py2hGcq{2fjvLr63D*yFLvw$
zDT5fh2E^{X|3c-)|Nk%6UjQ`|S|QWaa~FVX(ixz&UoT8Sg?4xC0*_wT4Umq~WKhaN
zc61X+p!5EVTi^;8oS5Xn!3(j-8DvrKUT|VEhp<8O+b^^sY;X#a2eCWvznBhj_>21>
zTRZQ+5C^*pJe~bQ`ttw(FP4Gx-r*PfpbFBi|NsBu<9Sd8y7$Jv|Nj|Ej6J%+tQW5@
zfo7qg>ia<ILEf<53)<WOTK@!cBFO(>SAT!;>f`_aug`mQ9`@+n3tm#zy%$vPe1Flr
z7aVBd3{Vahd;cPTFB8MdO`tJTP)qg21&{+E5u&I8O5vh*Rv=BL<|`l(5`PU80pPe`
zx%mJ8>)9TV#S0$Rdw2W;FC4IiI%n!NShZdaGPKt;L<pQjLD?k|96C2VdS%_0fm5kO
z0w|S9c=Vd`fdo2_zxZ|)n#k_In0*0k=L=_$*P&@?`yNPI(udn3dj9`^@X4z_y{-)&
zy{2;onHj*9x$A;mjtmS8$6Xsh%P7F}oQGeSr-FLg_dxak8<2y0S@$jl_0nn=fChmO
zX(S(%LVHCk;z5C7TDTMv3X!15fVxB%<dW{%29I9X36OMU4bszj|HWjGDo|8`q5_ua
z<Ss%ya|{$Ho%dhlffRKfe*GF!+WDV@7r+bDKz54mwE#!Jwq+oz|G&5g&RF0a0ZyQG
zAakHjS+pCZ6p}!vLD=8~+O->$0G_{S0*Q6rfAI@sMz5{505ijji7Fsl_JY)bVkUk!
z6T|Dv9#8`Vp&CwtG=O{oUT5;c3MAaS7qrIYg&u?r+L-e~3Bm?VV!aRpu{-a-=(_^T
z>?LR6UOTD^vQ+euImo@Hx51(M{{=J17UcZ+3FNoV`!Bq%fWi#y-Trg`|Gz8&&Cq~H
zcNIWp_L?^G!;{uOkRhF*r1fSoIBD&Tg(a=cAc4-~FJ@ncCoP9_Ad{cJcmc}!P*2C~
zf+Vdg;Ii%e3m*_4D(3)Vciw-o11$Icg#m~Ul~Vz+JMX`k12)U{ENG<8SQ+F|c<3_j
zVq$oC5wtQ<19Sj-(iwP&Yz9Yz=mj%yh@4ykiR_P{q}h4+Wz}y`sfJX%-T)_)`!5V2
zb|r%BI<5q^3ltNen4G$kiQ#1)r~rhzuVp91Uw=S`Ld6Q8VlO~q;85GP2pnqdF|bgp
z1qpN>e~}7Sa{mSISxAs=y#(reg8eb;G}s@Y%HuWI!=fAze=sfq#moB_nwLN=Em%{i
z#NVS=)C?3Ey)`Nk9-syjxUUiL;^7V^hK4;Vp!GEjCA^>^X3&`RixuF(iyD=R7YBBL
z!Ur^Nz753cy#GQE<SbD8XEmrkTCjtO;q^UGCA<SV#}s$w|Nqykp<R*pFYccOcSSrH
zN_c%bpC5Bk@nCpy`V&}8gP}y+qw_tabF%%@|NpN!K*hsah-?P5^Ad2(MJ0pb#dPpe
zllw2$Uj()GI}gA31}@-hKx;ce%cso23A08;;YBWZc=G*=RH%;Hi~s*Sg4%NmHvdZ;
zJbFcS7J(z%2fnQF^~wMLeXLVdI7-!D)Pu4>Z;eXA3stcG_b+Ur1&Aofg>yjtwb#2m
zKs~XB3JnI(3ew{*DnNrA%`Pe&2Cuh=f(Hnj-)Nxp{Ui(zfO<xq?_aDl2CZnb_Bak&
zhzcIj;PUv-U&{Kz6&$JWU&KNcwEi!F%4maRKx4efqZMo*4>upth>nF0HnyGwH!SQR
z0}`H{M_(j^%EeyRo`v8PrWyrmn7sFdtYY+E$jtD930%;F)(gK_ehQ=;G!t@m8z|Yn
ze{t0aQi$1J0O#J<4}ChHdv@M=v346M$|0qvAjnQo^>y?`k|HQKh}MH#-)ma25ERDm
zUo1Ee)(q-r7`!M3>0IK`YwPukiQz?uJV-;0iUFv37O{<q;bjfD(FJyn#Hs)PU!Mf^
zwC$kI*>?W_{}+xYKzRW&$Z+*6*ytB;p+$=72~ehZ|3dfl|Nk#`fI_G9=!*;BeEa@I
z1vFX(UcB21@m?BO#MT^CCjXTKImPxf$XOpjY|sMWYL6F(plYokYNZ948D3nJV_<-^
z1Vum=_L|lTfbtx85*b{6_OePZ00;P%2vC-O4{gcan-41dLC)#5Wda%0A;$o&FFW7A
z&;ljE&gU;Kor6{3JC1{*!*u2kkYmB^wP|2Cu<oA^Haj8$6q(N<b*E_)$ZS)P*^qw5
zEs)DP-@j-&2hJ=<Uvq&XfaArdEugdqTD5F>zl8M#GbqkG-@k|k>Fi}qff)Ta9NB1f
zkkPlGMNrd;|Nmd_gP64p)vWE{l<@uqKgg`kqpzQM^s)*=3|xa^;I(<6#V=3;4M7I(
zoB&BoM~;Ca5bRk|aM}<xG6a=ArrPsCiRt-^U`V8b3W*<}@acU2VgcBo_b)!nfYuW3
zQBeR5^>!Zhv3y>_`a&7xrf$dx7-;<wXiWs9#lQ)b0nc#swt%-ZKxE#7g034f?BxLt
zrMn=J&exzd2cS7QkU^k<GY`w-rHP=R$apb(Gsu~sGGpRqCWhDGauhu3)C84?cu@gm
z1-!@uu{!U+cm}GAx?wIp3~_NG$S#<RE#H^Se-RG~p&4+?L2ZH-$ZRBdA(aD~2G$pP
zAd$|yARVB<fS4-@7JUDr@C;~u^$}1eS_+;So&Zh)M_;S}6)~OfUpzPhTJTsW0O?db
zIu26#{l%^0|Np;8g(|IuDpdt}p!4ucNYfv({KB*IC?wEUfZ_+qBdjl`fz5i0>aIqR
zvd;G}Zi3A0-J=2yHJ?pP3@^b;IA9`HAQ8k0pxH;j2?bRBy#d90uPCQJC<aWK=7O@~
z`xjcLVQruSgwlf$rT6r}O0Um>DE$xi6?jH-$<hD+UuymP|Nr$nk8TeRP;Cf~@Xj9S
zE*Sxj;|?64)wRbQ1Q=d4NHH)t?gj1g2KfoBvKKjOmLB{6-?il}f6GJ2GQ}4q8<`kh
zUIDEmfJQqcZfZg5I^TemZUf2ot^qG30+|Y$u=fBjatQ~iYI#yR`SohYJs?XVR=>Up
z8u|Dt37Y|KI1CS(i_)M%P4t~E*uT$bL;TBs3Kle>5T&5fcNs+KVTjT_vmx2-2`H0*
z`uWhBy#*AOy)`NsFIH_}VtB~~U&O)<F$okOF%Xj~Atn_;Eu951=_ROf0dlXaB*<yD
zi$T+PjUYCt*!uq>cmt@kd;j7zSou+(&i^kQph7z!B_zm-zlZ<-e|-T`WK28+_AbZ|
zkEB3mivHIDd-umIh#wRnM!f{hoI|w4L9~EOS`X232BPKYEJz5wh2#}blWr2oW3WWH
zbv+ZqOK!Af76pevIpqI~86e3YzagCN^$>qBBOL94Y*IE<{_zP=@!SiUM}83s5(O_&
z@P@J+UO0kSu(e*+H7XJ%tS@{)(a`z+#Zr(vVVWh@GcmkA=+SF?pPQNCg{}kx!wb=a
z|Np<Za2&Ke2DAvE^XTiX9=*2fL17MFw9xtf#a?kpsR>?44XX2?`@q0O%Tth(yCLhn
zd@R40u)eqq6#<o_K9=wKTM|LT?0XOY{|{XpW_yu~nc>BHkg2`4e?cx;3}%B`X`M%3
z6t81qc&Q5-KkGaSO5I><t!q>SN_V{!g9yL;1!_Q}*cyvuE2!`Vm1>}}dhZKoP)gVa
zG6|HhKyu*n9PD~^s4j3(-P;0Q`U29$`hpiK1M&q(56nE)7oR~%0~Vsk)`IFv$Zj`~
zGH?b58+`_>tVSinqx0^I`D>XNUPgi(-D_(M^8H3JNSJ~wh6LLjkoxXDkWAg%0;!`c
zkMp-4{P+L=OWA**MDzYd7|1@D<(?o;=ld52K~-X}?Ie)F5g>zmZPP%(>H}h9ovGJ{
zS_ZNn<ZMU@0@}7E3YEe1_wR$C#s)MQo?C;<-&erOp#EOIhKb>2BDlB$FZMh7Vk$_)
zA1q?~^Ai)pi{+xAkf>1+cu@s5vqnYXMZp?Sqw@cY43J3g9+d;2%>$ixUqnFp3z!%f
zUU)+}piKM14#ok=7(zJ-AdU)@;{f7_gE^os3on?pM@0c7%mC$pE-!rXc{QkP*rW0Q
zv?l5qm;;)Ex&vnIQ8@q-J`d$A0C5gMISnArRxk%t{H+GF_NXL)gy(@c-JtRQDIiwo
z`xiV%L7m4M6^<88AQAA&i;C5t!UL4Xdu{K0WMX*HB?2n0Y%hS=bt0e^7r46}0MgOB
z2fVoRg)@lL4VoOZ1Zh75PAOnznyZ-@USEe4XuW&EWgw_Py9WyKUeVv`Ab*;EnF=Y;
zWWWW+;n$@Q^|1)`>mce+L)0IEs(*7Bk|K|+0vWSMWdkT6x37Xk-1=2a3@>@W9@(Sv
z0wgmREb|_e876@w--9v(WXWsLK4?gQBuk;jfi{S~$N+14{vrWPzkd+{(%Ayi*$oOf
zPlzx`n;l4IHe5!36%)hjv!F^u6|Cm@3t2Gz|Ai<>VG%ft-oM}g3qF6r0H*)H_^}eS
ziV0*2QiZk|6cW8qZ(Lgm@h#YSCs%@e`~1a0Fb($GHjoLz@PRw=J@8P^07s>0s~X4v
z)4C~;P+tblZXnOpKn!_N0y4o4ltDnnA4nz%WG8smG6JmT`HO&+Obo9tfyNR$-@gzB
zxv%r?>q{QsKrw-;7I>irGHEZUD(bZ@d&|V|!bS+1)j+it4^&;m3nnN_<He5^Objo(
zL5u#t0|=43!LA3@o2x*(aC$|LtAbsBU^1lMd~p!mxq?`{dj+US0A=5eE0`D@THZp2
z3c!uE`74+hT5dxGK(o*<`k;ypd^#V$XoPYEUX+6zkOmq@0z2TwF0cbYiB=Qh05^yO
z>?cElFCARiK;y=01t>be(V!19rw8P9q=<Y4@(wH_c|mr9mIH$lCj*oNPQ#y<Gcmjj
z1h>ZCzj(GBWajf1_rUc37uP_Nh@m2Lhyy_()By_IUeTp0;1HTO2@*ob4j_fl%;m5U
z>R*l?Lbc1$LMR8S7#u?JP>#ThP>=&a=ZkoPT0_rYi0=OX-?#J4OVGwDs1OrG=yew)
zCr{o955y;epyEW75#q*Q6Cr`9bO5B_@JrAshY&3Z2rU~STFxnhy>%R_<^6t$7AH_g
z3S4yUT?X^p=4GHD`~PC~GA4$XcAzbiU<GqP3VQdbfX@DV(GOMA4pJla3)a|tu>)i*
zxRY!Nu{R82uRqk@a)`aJ-Jp$4aZvb!lf5m-cyJ~$2C-lksew3P`(;2@tp{yygp@jW
zKz;;kWrC`)c=2N?%oFdHGBLbN2RXjiHs}o#!wUv}NZ!$SaTz3)_7hb4flJxLApRy$
zTI;ptf5pV`;wm3RsQ@UOEd|Mf&KCh~YVQ31Vk(Hw2rgp4-HA}RGpeDMTf8WQvJ_sV
zgH-FmGvtZw;P3$@H%S3-RGKM)<3)c0B)Ns}g9YVWgwl5)r}v6-LzJ>WmFnyRrA+Yh
z+>1LPX($Gs@!}!6K^boYME6-mutmrEA!+6vsL<)%qawk~!0_VW5=gK~yx0z6b-sV0
z4=U1;vR*zYVqsZt5=ap&>$O5T;H+1%go)v$<sVSczJHO8EEBf`lBmK!DmH_+#J+#w
ziLAl~s=@@MVj^hIE6hG6kVp(Xku`4v2O`LCS3oh<EBa9Z?6+5a5Wfk5{D$QCO`yO4
zr<5CuK??V%fJ^_=i$P9${^IarCWe=#po9fhvjr^t{>2)Q@N)1j{r4~Cg9V?zm=31@
zzvu@^Mt+Ay)`zWdCpki#6bErqIMhk?;CckH0AC*FBv9SwgzPF)uno^&=z?qjjmU!v
zXN?zfATDU%If%>gf*-_v0!g#QFPRu#DDuD?7oQg~F}!^A6O=lRfI3%?L44g`AU-&?
zEZzoAEw3L#$_f*N+go|TX>yS~D3nZR_d<g6Fu2&Y<pEi<iyJ<g6|)T#&Cg%3fV|dQ
zqrw4-kn%+!t)RwWE{N6n{>9VXus}M!1sq7AAxjyEMV1hYjCw(d|NV=o-5@s}@#wtz
zTHmAB_A@Ip!wXMt(CFGx&<Kpc3rVP%6L*8G28|$kbY6XN8RUU(Q0D_YkRt*L+RoP?
z9TqR1F9gT2NAqvS5^j&?-%KT;o}GVQ+r7BA8SEI3ZifE>0v?^mJi1vogUYCGix-=>
z|NsA@4q7k?7#?_OT?tyra^y7!DBq@nBzi$U?1q^Af_eA<|1bJ5%}a)wmkcsb52OuL
zju{?!`MLsZ-V3Q+|Np<<44O>qybN-##0!gsObjnUn{6ObGZSiP=g}9hK;h6U$}R^A
zUsHx2NYrS6Oof~T(RumBsV)EizXo@dKn-U|uY?VhS-K&OVNgc_yhsw<zj*@+w$Ar2
zTtH?tGc$U0&QZx=Vqkb_G8+<RorhmkfTQgFiv<fn*6vXOSN)Tr9MB0KFWR6S@T%a>
zyD!S1d~mBF6UqTC9exqBfQjK{A*e~&y+;M%z*LAcK>5H5q#WE3HUP0ey(Cc6TX_K!
z!|NT85NY28jy6z4+~5Ky)~_-kr<uO%0;QqnFT_B_ap&QeZXk<#S<Ab?<ER48pi~4K
zqqXW{W_a-yRHAhr2CZRw|6&3tpnLa#{r_U~d`M}?@nYqCCWe=SV3TaWK4xNgv6};A
zCv@1b^XQ8XkOE$i0?>}c%b>9&2auB;els$FLK_rbpk<00pj@l*A`)bB?;e!`keZm^
zj0`^ADJmX5mMJO<{H<$1eWd0Z6%Pi;E-sH3UZBu#{>{kW@(3*Vn~A?g4zv%w^Zg6C
zjiAn4iwej(@Z775ipGnXTmJulu?5_nm=OS~*?ZT3?eb{7&EFyo(%D_2qT$i`-lsd6
z<3;ucP*}cq{C@>B#RCeDm%Pld5hk$tki9ecoFGq&_DF*Ry0sIM^wxs1S+8x{BPNCy
zOV~ldd-$~iC;-4+(ays!a^^8Hyaa9Tg;w=Cps0f_RP+Z)ZU;4zyIDXd;4$!XgF5)2
zWC04d0+4^fsniV=Go9~W%-aqtMq0qm29F<K1xJVICn>PYUUxu}fH25q;P`mW2VOaJ
z)T8tAi?yHt>juw5ym@h9E=UJ-xB#T|y-(-U7rUUM@K}543hxN;A#9C@*jfXzwG?XW
z+-)!iK3)$BSFi(3AW8!vO1+>;i$Hm@^C<Y#J&(?#FNMHuRq$eG_KpAlzhpx2zi;^e
z|K$r%IggTQ3_xMo`ThmRTqcH>wIJzU+dB`K7+y%Rf#M1}77p^*<rh!pK>UjERX!-(
zLA`QNGCT^F-lMVu#MuGmOaO7Je=vg24ypj9q}KoZEq<WQP+LJRbOCML@2*h^01Y5>
zfi`pVw*-Rs#n-5SchN(|+`(d?Z4|8sAaiJC8$lz_pxOew*e)H!Z9bCm@;k^Ao$p_`
zt^5B!jsN`tkL~~kkM05qkK+!Y6Bijgx+?_u1sw!lu&(?6|HXqX|NpxhK6!be6*L5Q
z^u+~GP66%zffOb$7(j|<gOkqD7n`Ay(I81s@dB!-{%!sLADmx6Y2Ohn!@8;)R9KiE
zW(2KRuz0Z=nqo9u4WGO?2U4H8<^TVeF|FXz8>DaNR!}|k+^2U5c;M+p=UOoTg&<fb
zG<iX@oX2qpA2hHGIvNRF2HaQ!N-FPP6hI7mkpZ%W8RXt>>6dPQ{{Md=w*LSBmrFrg
z<at1>^&nP|9|MC&^KTaZ)^5-QcIW#S0&D;Oe{p*A|Nk$gYMB^b82T|VcsBoGDGdd=
z^7ESi|6i;FNp9-|m28kP6VUb%&`SBIpw!yEM+G#z0ulp_Jzj*0fwH5I<#+y;T|fW-
zf3X|n0MJQxKAn$WI)QBNwN1ar#PDJ%sATE2jRvu2g4vLf4M@%QB6$`h0YVCfqc8hF
zQQd1B0#cp@QVve1;4=n6<p-oD0q0pws7^%E-2!USgC-n61w?O)iU5cP7ZkEkH-r7r
z+oBQxmtls=fP8~mxV&5k8n}RlM{kP?_?!{2Y3D&Qo$p_$gVGRmXc+39DKk;MvmX=^
z-8L$a8IfsFjqf%=lEO5w0nYzDntyPV3w!j6UIniRd+(9V(&WK-;r|0r3<a(Rxr6mq
z2RQxlf>d-{ywF|`I{yZg-PX^5B=eV`bk+I(#l%hj|G$s{Y3e+V+=5xy4oSHm*Zu$h
z`pAo4t3as>Ma6um3XuO^FM4qUQ^j7WinSm!8eVL}RACKO(Y@~ffA9*r7ZX<z$g}~g
z{{IIbLi-{O)4bPh5La7+%;N@)H9I0Hk^s*<z0gAvg0<J6`j|obE`u@#C#Iq{sAKP~
z{r~^vI&in`=!=Em!u<UUPjGl1eK8Trw}kQ=p?pm!zYxlogz^)id`>7o5X%1vrjNdG
z1k>+dfX@8|6*h)Y{!K7_^o1gre*fYmhz2zZeZZ4HQJ~TQc3f31v@BV=0qtOkmX)BC
z1v^+`8#r-`rh~)6R08B%P<gNc+LC_%V(Ti9^5-vN(ao_zF=yTiP!bfChnRB#M0LJ@
zabi8(oLs0mq8q@o8MeKQ%nUD9gPK0Qww@sN{QnTO;I?u8G;ka8#dEOp_CWTULHFhq
zgA#5xWXK)j@kFQyXv`WiTjmcHF#y#)&>0bHs2Hf^gv^#{f<z#bpr9Jd#}c$eL<A%V
z8Z-xK1#NEw(cnxC&JW#tRKQIm(1b(@>x*ZgBm<p@02P0r9d(zWVxVR#NDOp(-9E4w
zsK)CKQAzOVE>VeiQMDYDzuv!Kf_V~T6N-%;AYGt#ENEF$^i(E>*ULf8oDCQX<H4c(
z{e?M5P4fiDaK|vmP{$C^Mgx!LHwGw+Of(D+cy>Mot)CVE4Ume=00lK@^U8}#u-9!=
zAYsT2ww$%5k(t5cxGT68_36zO;153lTC3pGTdUyHTPoqx`JP|URluk7mrv)n7t7cF
z|Nq(rbnaI-%$Or9A-<GZ2aaD*k8<J^kd@zGbb{&kFB+$S%BS})EWy5b{^H|WP-1dX
z(Li3wVgqtc^AUqs#~8<0$2iCM!ydi1^KURQyhsJLM>>zT+%8cBb%Q)!7=p~}1+7w1
zpTflO8g{OS)D$L$?iv-I7Y{*3b-oAJw~&58{xXmwkAwP_;Ioc;MehoLifPkpb)ZJ!
z`xpN}d8_j%$gKCEEIDsEC|i7gacnZkE6-o-o6N-UdXY!3EicGLmmyVDBm*<Ui{s$o
zjPD>#GeL?jdUPIztqT9K6mG32sBGyKO@mk)54E-(YORAuukGgRObjn7AtoRH&&2Q|
z7h$qJ)EVZJnHXMzR+oY-0Ue<Qvi8$5h+CyV*58D9xDICXkr(Gd!PhJLh9B(Vr?nst
zKYzgsvbon*4P+4ud;rQFrtRp984zt-A==h~wY`6F4U~kC!l?{u_q<7vaGExWiQ#2A
z*sr#aK&OPP09Ajzwr&5I7+%Z)&y0eDDsK`K!|QV(U!3&lwf*pyiQz>ZMCFusObjoI
zK<v(=FLfaU`5<4~fJ_EWlX>*og3c9r;RiMi+${b8ayEF<RBRH+m!PD<19s8-7c3xs
zPZ3S#FB6#<UO$6`Qp6Hy{2Y0)5*+ZN$M`_{P50M8Lg_g;B^?FFd^gCEH-CY``u&S_
z6G7@gE8><+WMX*P3JNU9cz%J0wT(*2;}>g|{r~^^4tNOxXkN&p(+9LqA9eA7GknnM
z++w&(<RLDxfw;sJ>XKNHOL}elt}-#a2m!TnI*)>~ni|L*o%dhJfn4z)oM6Bq!Uy8N
zNAS-r`Trm3=!1BKb)d7SJ$gmY@`5~MdaN4a@ps_TADk5qPk==2?g>l`ue(7}2Fq}j
zpy2BT%}mXoz{K$K4Jg{XA@hLXKwy2b927C&jzF)AN`i;wasHNdpk{0T(*OToE&+Sg
z*7*t(!;41H_!`J4P*ev_0JTFwlWFcCbEm+2St}O7L+K|d40=VyAkOB8I@=uVY;XwN
zS^WS1%bOr4_1YGIQlcDqNEa-303_!RmIG}Td)N=L&jHk3VSVul<gL#4FT6k{TQ5k#
zfquv~8C&-!pz&Yu;G^yCKTHfSPJ-E>wN#x)U(D<Wh1B~O6G7&6zJI~F^8f$+prs-&
z-Y*1|c%lpHKusCbpCAg<G-EvuVu6p1Vt-M+0+O_Xp}J46fYhXyK_d%^P<udUF1|1X
zsQ?c~s)Jaa?_bOZRnNV)6(A>>fs}$}Iia$R5ZNw}K@uQYP#p{!BYDvWDVQJhfgJw)
zMFd3QL69-;K_>xrzJGB9DrW<h0}X6#g6h%&i`YH}sXhoD2%QF%<AcbFgRBG}x!Ai0
zQptB7eNhB9@%@V|sM<%Mda@TfdK3y0?1c=Wyzqc>z@tUhP!6cteW3^9biRMF45YW4
zMHRFxnV;Ji)H(uHdivn>{r*M!^8f$&<v}yZ451#qwllh!8D21h>Vj@v5m3<gik3Dr
zgN~1?1NH4X-@n)fN@2aW1t5jDK#8|kG#H{H7OG+jM1?;{#SV~)&iAn%y`s7hRTkaM
z3@-~8L1NAjJi5fH1)?l}l!$tCvxe0|u9D#V{{ZT)!%!NuKO3a5*Yp=?2u1UsN9PBR
zgYWD;4*p>FU_9n=@n4CEM>nf0)BukE57PMMT^JZ(`a$<qG}s>PWM*I}H4gP?wq>dT
zcb=Y>@OpIH_BAmx{1^RD4LVHg|NsBTSm$&yGcd*;PSfL;2OT-hz;HMX!3N!D0W$Ap
z`hR%%HUDBN5iVzMy;P#=(P?gY0A}weegQVa1E2T>*+20MxN&^q7j)-1%rDR2(aRcH
z1{w=u2dicH#4q5_@rhr6{V>Gc&A%8+gqwdcm$0;6DiH#!0ml=>@U#gYy{w$b`qTK|
zpG@P|ICyvhM88LOJ18Z1Shs^xM+v(}Czx><=AZ6%&`i|f2{67RsJ#>ny3xa@dp&5)
zi4WvNL0`+KB^n-`e|<V%gToVa$Xx6H5``D97l3w!90r~0SNh7Qb1i6jH0b&d=r&8x
zp>m#<cS_H{emnsbUXCH5!5-c265uV(oku+`zV%={>ahcKQ^x=Q|K&X_zk2XHz4Nd<
zS{?*CnYq^neA(HHr660ng9SV~4|*JY#8krP(+O(3zu*NILI*uMy*WVV@p*J+{{Zch
z7L4}kd=A?B?7ILIGcF7aAm<!@ac|E5|0og2;IR{GH9Neu2=cv#Pj@|sPq(^H=MNvv
z2jIhHEl=>b*npaxonJjW|M_S>^JqQ5-@*eLn*r^)2N_fE(QCutVfll<?J5IkBH_J9
zX9#F_WQmHvi^uapWm}1gfJZl2?66laiw0;^lf$PsTi_GF0MjRaK^Egr`~ps()Zt>x
z;bZx<#M-0tmQUvcM4J1=F91p&4jiB(K|God34G!g^!o6LU(o4?hvm`I2Oga-d^8{U
z^yV-N_*nie5%JV~?*p3Yd*{>n%a`%*3!i!a|NFK+DFLq@*9W`FMTG-&KJ(!;PyW2C
zY5X~dJUiV49Qg&=Jisfa;SEhlytn=@Rr5IRq5>+g865Y5N)*G}FKxg%zy-9(4<rJ<
z`ozQXya&JAdC$(Xo(G?@ynG9;NNi7^WMX(>28su;d5{*mXXl^LU=PcGC21braU34q
zdY+wMJ-Y2ZyInvBD&O<eeCMJ0!>98jI3f=IWbv>(Sndmw<?!e{<e~Y?qw|`_!GA0s
zmLK`sLAU1l^|F|ISl%rW^6C8K(fRJhvxWcv`!buT_;!Bq?Q~J$i1z7x0Bu1-^O>vR
zTaVV0B}(w5$nIfzkiQ*tB^~H+GSzvY0XG{J(3(xqp{%b!rpxooGx&6~d35`6cr+gq
z0L6w+r_%?IPOl#xmY++XK<dd;bN~PM?{zU{@a@!50og79A~;@xj($s<;L&=iL>}Zs
z=Y=2}TvRwbyKPiFyJI;#yK@<!zGHj^@z5>)7F%#YJ1}^38+mklae(Xur-aUe4<4N!
zKRhgNl|F%(4{HCucsuj|{|QJbeggLV2hDY@Z!7#kxvum53zNB^<O<1ft(QtQ&~q3+
zEQh_G1Il5L`~?aRNWLru<=4)GuTQ+lo{5s>9K+K*`0EaO>;mPN|Nr?J9K$>gzBGXp
zJDsN+AO8o9f;YbLU}0eR%wH#}lE)09d1dlIg(PIzl}G0ma4m_{pKDREU}0b|JOCP*
z0<A_m-U43I1Q{lDQPBX2gU7NuT~sVU90qWy-=YHAeFx%iU}j+87xMv)>qAyJgPeJQ
zUo1q$!b9-_zh;jLXkAkpe?G6&WhMrG%_-nvE|3eGa+w*9x2RkIU0K8cGGq$aP>>c-
zcN(M=G*Jpt8V*s~0N%~OzyMML8fXL2ADAFoK}9Y|%LHZykf{csi;h6ot9G`4r;R{L
z7l7)n@b3rzu`@7~_=6@T)VUcLdYjMw{{R0t<gfvdTRI^-T0B5L1YO(;K9(L_IzvSS
zz#^bg!PkCiu<{>d9LR2%HUS0?Mu^p*Gnhb%dv}8@>V&jCp!R{**m^J?0FB6kY;ftG
z13n7Dwe>cCM>Z&=d#8ZI4`c>Nf#F+F$ru5u|C*07cDk&R@i_QGq4X2X0FUOs3T3>Y
z=^oGyoEOJ`{{P>-1#Bc#Y>f&iY>{I5MRFEsoV^9S%nGz28WiRp&3jaSfWqQ9Xw;OU
zRA?XAp`GtvfF`QJ<qyo*&iA09Wl$`Dlz_YijieV`S&R(Ld%&Ba8TngGKsz3~TU5a3
z{P(U=0f$xd9+ed!<xp#c;nwi|1P$qd+8@1}&w)E@U~51z2(<<l!7mnPg7*C7sBnP7
z2)snIdy0w&69YpxL+9~M=y{;sEh?Z(0YK9Tmq7`p@3$-iL+8)kAj2T_J>zZ5o3+1=
zGk`9{@@T!p-})Imc>)=gg}UoFsM>LOQ3z_|9&Z7US%VBX_?rnS9d|;akiR7fw0sh}
zC={}SyVFG_0G3`ndRa5Gm>JUe-#_u`UIKP7C=$U7K%uVX*IWWwgm3MlV!_{%1v0O*
z1+q-M+eO8~r*jGTs11-lkncbd0rEIF^B#9m0gt(ObiVeqd{e9n8rudN-udnY=splo
zXn_=abk6~M1mraZmtGrbkIpq<TOB*^xpda382Et3&B~-e>BqsR^WTeNP{X~u1?plK
z6$PJ8$nd@40mDnKt>5_jN<eE6y4Qdm>e6YVV))JQfKO+Qihxh|8gMkY^d|o|yyVgO
zo?o89v-5{X=S!bne-=nQxONM;bW6G#{`ciyf6KG;ln>(#-_CnJg1<bP53+bRzhLpP
zyk2_CvD0NMgGa9)qX++*3kn_wUnzK6e&KI<&I@WiocHKF_j)<3-P;Yxg`kwlzyMCp
z#~~RUoURag4-_Ea<kPzcoaGE}dvw;QM07KBwy1z^&1gNq-|-(bs^8rL-pc0D`3ux8
z^JqTI*y%D0mJgeMEAY3?V1caQiSX#W_re);5`H)IoVLz6==sm1dkQ#Aps5vP6UZf?
zr~#$c526eV{QadY3=GGaAW8E8f9q;#1_p4_ec8jpzyJw1NEY&Fy;Ld-ifYhY0yx#a
zI1D-u8<wKvL1iPX#O)RUr5I2_3QEPD*BCE#3LJbVzYD}`{Z``S(ObmmVZ8+$)BJ4*
z!Ry%ffQ#=Jc}RwOboW3~P;VfkN9PnU`#1||dY%EigAHD&v>x!_cYWc}3C*jZG7;1u
z0=0V>JicFOegM8CLILD`(CMTe-3}a}R2cv+Z$L%~fN~0`{Oaxj*HWD>DiSW8k2_sd
z9J*V;6^T=?jiO60i+~GgC}1HMDC|Pm85oYUfbKnG*bBOo0-i3WsDMhX?ky^yYK8Hd
z<v;$G?_3NFj{I|uyYg@Q@7`Nu{~y%m<nZW@QBiQ|o&=g2a_No|aMZlt`OCHQZ|6N%
z#><We-^x2${&wW|z3kHK#pr5zkiW-)n}NZ_@(_Q2zW@V+qva{b&NGg^0sme3{T?}5
z9&zFKf8b*Ih`;AMIGM}=N54xa<QPoDZw?)6zy-EX_ZAgUAbNDhs2KQk=csVJPUV+p
za5X&XVtJ`X!o~7dt#IdM&+c3f7tPBa$+x>><}!FP-gL1%R4Z<Is7AQ+vPXB0ih<@~
zsGJAmJx@?G?=wFGgOBDpkLG`j{OxUA3=GY$7(EU?Qvf^3jfH{1@>lIF%TqPe96K*M
zYM%5>KIz`g)Azay8gAcjbh@Y%bRGgt*fQ|TGcX>oJXHG&l%*IMz=h|*A55TR1&St6
zLIPd;!QTS9Uj!6`8jgEFr4pn#gl05wHUp(uQ04@20zmmHjsN{Ok6v5XR7mp$RCMuc
zZUL7}9@Z`@8vHF@VxVb%M0u!zTpof$?s$vJ43HZ@?SSJhDiYv=vGcW$<<l~h@^ArY
z6DFu`0`*e5Az2iZ@+7d7hYFzbPy$jOMu5u0WMs{t6bUL1LB2PHm4|nDK*a%OdB_1O
z4?zy4S$XIWUY3PY9=dc-0T*YWlx?vC6d9nEHz4;SH40o?FY&j$6=PuN?g1+X7dDV`
z22xLgq6<{SKntZ#(DJ9&1Eo@+79mI+T=YN}hB&-%0G;KAyTXi7N#JjZ0WU~|Oj1LV
z2dK70^xr&sSuK;n_2pYoDF7-TLG>OeU4RM<Q2ocR38}e2>BEA*r3z#sRqD$I&`xDo
zm4{qk_OigM%T5^;P*Mjc8;}DOAW6i*qx0Ac2W0)7p!Eo#eYP&$JSreBfC^yO)|32w
zFF`F1SiK3VB0=>gw9155mk!jeFY7rl>r2=~G^kX4Df%7O4g=+BPzw~4hoE&SxPgeM
zOJDB#0agqd?=d{!(fX~sL`8vr8>BqrpL)Qh8&b$=9_x+)oh9j_5&&ve2s9sNbm-8r
zX#K|Dzd?wB0klc2bvbA~boUf+bqVV0<$<ahP-X$u%O^Z~Z6-p}W4A%)ZI9*yEFQfk
z+dO(@iaR6zcpQ8Ux<sh-N$c$rb66z?DhSHtK-NXP*Z?|(8fJEP52Tm{Rd$_Q!1i^@
zOaxWSpy~nC6l`f=1!dqKa1$ABJ+wT;Y5xz9{roL1AiW^7d)I*1eS#`fP}90h1~m1q
z26YM8s&0r4U>A380oP7om$;~Kcv!wD$@l2?5CHYH(>%HhI6&_B;L&T-2Xlu2EF458
zdGyKzqlJT!4`|5Nr`M6u*V<j8Ox&mQ7-)Qd*;`QO*<Zl3yPN|g2`ZyGd^#NjI%WDi
znq5=`7(oF6N}(^Se}Ma|u9nyNd)EB;|G)DrXf6>HteQt#-}3i?hIm|hb7UDjE&oEh
zAU>V%Ubwvd|G(GyzfUKm=K<0KipAa#Rt8Xu3N(o3k$l1@`Ic+v1IOk!j6S_0y`a9E
zUoQ{nZZrnZ-l7k_y@f13mft*kJ-;~e&pqa2dC`%7?jcu>Yy2&tJPZtu&3~Br+q`)g
z7+gCKc`*L-VEpN7c+&CUD<;qHw>%F%Vgc1BpPl&gW%!)<1!Xurn_mj}TAnI><I;Js
z`QabU6Pl+SEl-p<cqE_bHtF|BKGpn+vD2i#*W-Wdff6l`<dYuBmwb9zKv&f<bo2Ck
z^qPQfjbrHKncn<^v4qp9+lBp4r;GWYUf2JI-+VjYc+BwV6=?-|;>EVE|No(l6=(|u
z7M`Gh00-X7PDo=0+D3u(4>V7JQhl0F_Z)EY?9~x)>^xw2(x<xz++LXA(s|6aTd?z_
zWAgz<&t93$p3MhYx{ZApFM4R6^XUB8Y3y<ErM;u&i_&Y17g|r2$a?njG<P#1%G1tc
zpi8-$-!WEv?PPT9%~AR9()qacZJjPGpLrx7_2^}3d@T&gXCBQjSeoB5^0$DN`FC@)
zo-BFW8_Vd}dB@Z8Pg%BS=U-TR#q;7@PsYE#mT!Fdo!@xD#vx^UK*J)??2H(T{N~Yl
z{6%9wXxinVM<*mFf|3d-WPGekR5U>2ZQoz)?}q3GB}CNV1l9SV%Bz`0g|XX2rPoFh
z+Wadqt5@v&)SG4SQs~?N|7jDzRoF|P|KK7DG~Q<Us=gQ&2`~Hp!Nogo?*o-_F1<nj
z9W^hz@O#{Iw0vEE!6*4_Z|Q#*&AV`aHos&7Rp6kS$0PZhr{>GoLj3X!onJkg-!VEi
zzhd;X{8%#6wezxjcg<V|SIe4hEG3W1d-=DCsDNBm^A(hx92i_WpMvdk?Tu0SuX)wA
z^FGLCevfyKmaqAHK#P@plg~KzmZ<!5)O?L(H#3smzM3~*OGC>6$IkCa4&ZO``Sbrj
zsw3|5w}URIefj*$|Nn^e;MjSmx9Go1ulIjP%`3aWA;9nP$kp;8e~%#(14D1{Kab?w
zu9^>F3DTqaHM39m6mXdc${(7iUyFnCnPcZgkLFj5&F>gJEHCr7d}U-{aP0iz+U+x$
z#l2f)k*npyk~^-JXIv%!J2pROa%_Ij_;UJ}|NkezstH&f0XqG-x8VQFOQ0*m<Q*7b
zy@;1@et`mx!KbrCCBdcJL<Q8d%m9^c0xs4iDhB+$H$lz4?mgga(s>V*oFOL`LWUx~
zU-Rg+Q30*Q^y$rH@$G!+3tEqwqf+70t77NbTcg4RYJv*%R{!@%{_fMOvT-M<1?kh7
zq9OrWE?dA4ozHOWJmqM4uFk6SpAV=q*F5LJc+R(1X1h=4IdFfaThFmu0yH?vzy7rc
z;|tHuH$H-|JerSz`>>vtpG)s~bjzqX^_qx-a;``7LB>v&&G6o=hoz5-K<R9dwFN%V
z%T0Vbb5tt2LsSevUIL{$P{Td>Q0t|7q1VzAJbDBEw_f7!GXd2%ofo=I8e6}WymINS
zVDz!9QBf!c4+?=h@S8xVLHDx0js#7`Lb~ptd;kh0P;&&-qPn;Q+?xWeJ^@|T=+N>1
zKlHSMR>;~q{?<1v3=9_`V_Ezy<seJD*MPfzFO}Yd@|&ySe@DxY{4KjcH`DOXM|7!P
zuJ{C!2epnt>80C8#lVtBg}?V10|P_nJ;%;dF5v2-M5W;SHIPri?t(@qD6T8qdR4?g
z838me<JnuH!UT#)(4B)Ep2;7e5!$P=5tKhbGdS@06Y%W(gPh(^S@NjVS-OB0-`A)J
zphlnrL$_YHysP0i4_NfQ^%498iaw9#_bj03yYJj<!UT&t$4-_lC~?P8Iv-Swf$Rq*
z%?h8+E#PAZe7Z|i3b4kZ+)FKP1_p%tVDVW38U=*MXRiaek1XL~=>m^aPz&=O=)`AG
zI)ud}ECxFv!&Dx<tiQuSJ*gJ(1s1S~O>g`EA9Ngj>mG13pT8B<|GQWNYLA}*cTS;E
zTK@%<=fLx4pnT^5%Xc0i&vAhAodSRFZD_s&RqvhmAhB4Zl7JM8kc_7QiZ5_(gGCoO
z+kx^LD9%7F0&tvx@*xK(2Y|c%piS4H^a9Oy1mf*2Jl<g04jykF-8L%Dy(R*%xa(xu
zjuv%uK$Qx}K9KJcK=BB2Q+J4p0w_I#ya&&D60en^<t{9~wm{;`rCX-awe@z%3s?@6
zfaE}Mm(c)pW_2%XW*8&~g6c0=ydmX4(AHvDMD1$<M^r&;jfw$(E2y7+5yWa~182Mz
za1+6!8`8uAb&o*x=gXZRz?B-LJq{~hJ(5AUI(EmX1UPi)F!x3<f{OLl|NI@^p!tJt
z7nOhp7m5Fjpgt9N5XLe>qL>?eb=UD1KftG(w}9`C0q=O}j1T}R1Pz;MT6pxbP7ehw
zK-dEr<OPkrf&v3^nd^^c(5?a2LZ~Xx#$K?0L8EGj%Umx(RCz;Hfl4}%Dp0o)6da)C
zaO)vTG@wdAQ36r|nrQ$j0bS<W15yGS_F`dRfUg7NZ=DJ1V>KS}V1dkRLYIQ^%QHB3
z9)EcWT(v;LtMdT3EBA8JA5hW<%^Ph27jGV|-}qaYK||8eG6~cW|KZWgvmMe->PBvd
zGhT)_!w;4|1x*p01TFCCbz}6ghK!(=DT2Br4nCd7UPysX((i`a0yW&H*NqWc%KAXF
za;MC8{?`6q;HY(BVCdcg-o_0!<;C<M&{#fX2oBtHsRrF}0ty9C5O?>02QCf2f$~we
zO^0LWht7YFy*3q{HXWb}=-@kf56e^KPhb8A-ObSrT5Z_*3X}mAKvTz{Oz{Jh#XBMQ
z`SQ0c1YcWGqGItvzY(;yBt=ExW$#N+aJhi`OHiMH!fPej;gt_sg@rx5UV+Y%#ui>R
zDhVioW%~R7{|Vh&z(pJ+obm%18D3swKrU}V@gD+?Ye@Wi_4@Gt@#<ya_dNK7$tU@=
zkLE*P&6|kw*{M6E;}57&+!+9xRV{u0^6zKl_7upX01v$32R=o;8x(%;>tW$n3p(Vh
z6+9gWO7O>-K&=l@N^~gYg$=5__y9UT8EHHPY4!nRtpjLGlYxOj8#43rqA>uJDq0{-
zHME%>30S)dYWVvXlkbCK5I%DQ>i2_sryzHL`u(8k8U_Z2QhCr&4|uMq8=Brg^TRKd
zUx9Rk;~(c-4`|$=lpk&(=sfPU3D99-s9B)#L}vJCJ#4P$<xz0z0@p(xpo9+^uLGs8
z_n_5UpsO+%85l^*k6V%QBdE}X<i`k5e(VAr)D5!*YB)GQf+j^kg&QLS12{8Q{{p42
z5|si_;77a=@(1m#S^^$P@UdP3o=D?wivbmd&@lk;8jSZZz~`02hZ}E!G8ibNL7A;Y
z7UVy0xdysE8??zhx(U<=f(%Y}LuP4VvumKsK|s^6E#UbH%Q@glHU4HW4>r{Xx_t5d
zi*2AYq+uf;2Olwk#{NK)YM{kK(BbB8Nb&vRb>sj4P<voe)!Cu~ii#Hoe()(bh<kjX
zb0RLC$2<?dPylcEIt_{(Xt05%Er0p+^2|r%pKd0P&X10ruRIRERq$v&#Nxrf{)8w0
z`U9XIEaMB0&a<6ff538#M?EbsmVz!)F13GI#t575fQ0ok&{5FcE#R;QRiWSz1667u
zQ=yYBE}bgvkQFG7oo_sPi@|dmptvsI?a_I|qx19Yi=g>br1DMz6a}E@KrQbMLd!di
z7xp!f{3`KsEl4c+wrlHu{?2_r{{IKfe;okbklVclJVoKs-2-+UXu&xX1A|L9q&?=y
z_|cK^hhwiJqod^k{{Frn|Nnz#4*EfZESCQqJAXO$I{bIx_q*m|d7-8VRHK7^1|JMe
zn_zg-@<WZVi{*)0zRrW1A3c&!I(GB)crc!{{81z3VtJre(6RHdqvmhl<lAnbsR19x
zTOO7d`P(Hylb4#OJeq$o^0$lq`2Qa?3~=y~f{W#a+SQ;sqm}W;|Nq}uR2cbNzJCX8
z|N0Kf(F~w^9$XbS?*UH;F+eArkcSK5^Tfwr_}&KT0+$0dDzE|xRF;6c@Sw5;S~wvU
zT`z8WgUTsL3GnjZQ;-1;44@ez@RFIAGLKNpR~HqDmtR1ASa5#}v@2*kXvHUNiOoyU
zWt$$Iw?G9PXtEh{0chvNmmyF8|A)`>mRdpv282MBFVru`A=`IAt^}97FDHPCm);ie
zv>-?%;w2x*Ca7{`Um<x1q|o7IEGW2%Q5XZ-<21b*G!k<3<-rCBeFsYCHA4848bPa4
z!2X4=y7K7!3Ox+c!lyf3z@ys^X?cf>iiY6<(6S{lkM3d)pUy`wMCw3B9rs~;?$KGx
z;L#nd;M1!j4vzSr;2i60;FDae<I|bSV0f~-SOav0U$2XbfN$q_kdHY0dRYvb|0VOc
zaWgV7_;kzqgfKI_t^}n={%y_{zP%p*JUXvCb~yZV>3rea>j*j&lZDx_!|}fh|2A>g
zmP>UG%?BA>`S-o*JTcSp``^|}rTUHyzv@dgeY%|uJbJ?!J-Zz^Jee6hED!OwJZE5F
zFgyt{*b!o|<G)556@GOF2L85AP>=D0W9O$%6BXZHkN+N-2jp8{2YMWQp_+XmrSq7h
z<|X%D9U;eFS4KzvZ6H^G@)Xz={C%<iK?ip3I|S-@AL=~O8KS~6^Lvd73ux*ebR8+k
zQT#3Dpu-}&y`c_s<nUx>1Uamg547{7^Vdrb_;^zDKhARR=3@qq9R>eEr9o>y0|SFE
z;}=jsf<{#ln-Tb1=Yg70%||RiYwMsb&<P%$zg`N1*C;{SA3oi(AA^_~7{7sh*6W7w
z0sl68hnD|!ioK4EF8uqh&vg9$tMyW;kVC`&`Vt;UP<i|VMF7ap#-NY~Ij04(^|?fa
z!>98T=xoE9a?oZ%u!Z3Ilz&^X#0&Pa|Nme91nslrtpuesL~%U<w%+VZXfXdacUjPC
zr*6BJ10~`f-J%6S%nbb7SeQW3=g}$F!S2y**X_*F9n8~EEyL*2t0TbQ@`eF4C;Fm3
z-6Q!$>jD1OH=q_N<9m<fOCG&Cko0$uiGkspvz!8d%XLNu2L5f%3Ld?+j2*5F-N6zr
zny)~k8)_h3$(QzlCUQagUWAtZ{~ztysiOj0l?EH1aRrS@&u3&{@J;^e(QWM0`RRou
zICmZQVf+rZrL_~ZNF<oU(ei4onnyRcNAjW9qVV-Ry#fC{nqM$FS{|+CY^Y)UZ_s(D
z<h7&a)e>&7!<vsXcDVodNPgv``IW!b9#pwA{(Z>{ayMi>utzsD|2BpWc8_Fd4wvp?
z2}jLi%|96V`<8%|fW79=)Zxwuk_Or1(Rq}=6|?}0f19(MN3V^hYwNc<jui_0t-*{8
z44|p;UVo-t+6)W~HjI)7nja`MA8_qpcj<i5{DQHP7d#oeOBWQxnlC!S8JmA3*QI$R
ze{k$P;M42R?2&m5lrbC+{*d=L_)FDA^N>$B>*N4t2F6REp*zMyw$DM$hrSbFw{dm&
zGkNs-v+!>VVsz{fglg_QcJLoqx8|qpODUQcUh_iwJ3ig4o*<JBc=Tp6dCc%(JixzA
zphJ*<n*(EqBO_YWfch)W60HX+pMy^%1NB3Wu^YH_7jw9DzWRO(w0Z>W-)@ki3RcTQ
z{Qeifan+IocAB$-Pp?0dPx2w}ULD2`cScZVoz2L=;A;5Rhw&|nWewFbO#Cg=7#SFj
zxiT7fG#_PpnGeaVko@JDd<~I`_=`a&89U2)biRKHx{4gs9_aOFgjgL5IzSDyzXn|H
zdUP{;be{L<eC5$w!1&@=1*kMV_|gqNehfDB#l9lYj>Es;P8!5Mk8Wd+&Q~v{R{a0(
z()mg|n8Ty<_)E}ziqP=`aH{I{X9T5~Y!2{h)UW)lY>W(`)bGJ~*76X4A7}%i<{^*H
z_h3uFStmx6;YDB($Pss6_Wwh&&!_XeXXi<e&Yv$$K*AHierdhLz`y_s<-U`kBB-0&
zGx?ZDuM6Y<*Ib}P=-B*@v4pk3!l2}%OXmlV-h4*R3;Zphd+$N6Ll62=72o7{Aj4W}
zK`T^2dF&NvPHPjWWXb&ps=i%7(~F0|uJ!3W|6)bq|NpN~LDG#!=iit2{(=-ChmQ~A
zw--g_AnzQ1x%v-keQyj2caRc)u#$t_&KxiAfh^jFo-kZn-<G!eCck@`3NGP5<Nc8J
z*`2>ZOSD0Y&BMxNK(pK|;7X6pqmv!9_}cIQq)a|Mq4^hc>06I(eUH|+B~KAI<d_zN
z9QPiyo`K;-28h#qgafV%w2re|Z$D_E!3*tTP;9(E;M<+b;j5j>0LtNl3?9cF!0TOn
zI>C#h`CGsXexQpw|Fe5oUf>6>GY1vXFN^;F2Q4r@;K_I-jX&prPiLwCzo09FXLl)w
zXLl_FXx*=#N9Qk(&Vy+aKJg21f!9DoR<<4lt#9@Ot#5Yx;bD2L^nr)wKM%$a9-Xcn
zphKdyL7s(r6&fGCtdj1a5kk~(fR~4c2VNF{HpgDc1MkCodAt&3c`9f<{ZBV$@ZCfn
zo$N2xg45*teIU=qzO*kwtxdrBi}j=%*uIyIAX$%Y@oqDZZYGcJAPx`BLmmfzv3OWs
zD;D%P_>9Ga@xv#60T0mnZHB|3>&V^bF)<h(c+pXUNI#B9@tfh%-47a*LTLy^7#{HG
zZU-+q(md#K@Fy#1(Q}(<B`D{6DKz~2UsBrelZn4|GAL&pe8&2jKc6X$KOZ#S&Ug$|
zgL`;%R|$9=cLI5dfnU=FG!XA4!7nJ}(di`dnLl5SUo!?I<|Y7I0uGu!_vj9j@aU`)
z0Ik{d@aXiD0NvBc587mC0KN{>qx0YY3m~H-kVdGcf)Zr&kql_;!0NM>lchD__yt9@
z$H8Z;9=)<B&i()I!FcQwzo3tb!6$w}7Zr=o{P}8W{P`{_2K<^S*jy7Q;L$649;C4|
zM8(6SGY;e^{+2ROgQmAe1<7GAlaR~HhM$c5t)NRXe7ci3Ji4`fIv;vyzVtZwlciz*
z5zurIe+#HgvFry8obtDZSN#9))14&%K1>1RT3EOVGJ&&)N3V<lsA=y2()!|mJ|v|d
z1udn218Qd)c=XzOf(iisoTEOS83O!*pdBCAK_#jOf8KFWw)l|7pK}Zp4-OCyf9B7(
z=GUwNdD>ZkUyvEJ!o>k(mV-yPw}eM$Fn9-n2WY39heu~H#NTzGq6^L6S)lv3I>8<}
z)(-L;<4Z$O(*KzcN&5U1pd04GJv;wH8bzTVdsnZ50MHhQ3ZL#W4v%g*l+>32PJN(6
z>7flygrEiX2Y;}7Xx;)Rb^i5N!3|4GP`Fus=5MJ3HGSXu^romdfa@LbeO~dPa@gbe
zLC_j-pWYnM7KwWvy`lk5pn>G~prJYmoBti4t#JG<2mgy4^67l!0a|tc|HWO<(AGAP
z3{-dLGoQ})Hvc{NT@HHm^42*sGyE4h2)Yl<qxmSKr{%rUK2XBUfG5mSevjrO6_7*;
z-ah-{RUW7)Jo-|*0yLk4xgW$6yf>lqvq$GSP?_t|9nRs=?JnTadDTN(-$V0)XXjgw
zgFje25B_EG(R}A&dAQu#@BlcybRP6*KEUX4@F5GoAPbj=<&Dxe9tR(=crae@1PwAF
z$}X@&pyik4J^rROpxq;uuYEh;`S3e`_GNtMX?f0v-~FTK!DlR>-3ZfjK~BC0wxm}?
z15~znb{_X&yp}eBUyuo0a$0^W{Q}uZ-~wtZ{{)q<mOn}qK-mtQ|G=u6QOnm0r4Jx`
z7Q}M@|My{h?aTPjx6?+&<KSZ!-_8;h0nc6$dC$%e6%I6~d-U4M&tPJB5ub%wKEn3b
z@WXq0pu`2<|Krom?$i0eNAm!9^A>1-jUZ?@P3Luw&QBhle?2?D`e+^k@3MKvz`)=M
z8kYd2n0k+169x~<5BzP@LE!}I(1n2f$fEM1E(erdSyVuIhQp)tuqWd&&u(^K%{M;1
zHNqSooh-uMy)5b;oh&LIt(WSJeOsT@=lQlCD0K#9#KS(Fr2_n7EGnSN$)g!|QyeUE
zAoaUX=P{4Y`#zxfdodv&yq5+vamrDz=F@rn#l7tR|6gwgwFf;~zm*2L8h$gp{jv(V
z{PF301in4^Kg5W=Ss(|ysBrkU9)OfyueXEqiQ_)dXu(T4aCv4sZ5k893&za<|2-_v
zdGNcP^Xxq5dGHzY%m1J@5u$ek8vhUR?7R|+=u8Wwpk4In(R!(b6FmA4>Mwa}zVYc)
zQSog4!(Z;=(QWP7{D-mBn17oqLkGK0w~C5Kx3y1aGKbSK7InxfSVTq&@Mu0F0Ln;*
zLH-4G&ab|fnc&fR-=p)H;iVVB`Jgn)3|c(b&7$Jb=_~-r#V<}}g1ihi`t@RuUfUp0
z%5ly7|NlioHtc@Dbb(NCDnWO=Pp3NA>7XSwpspJz?!UgsNC#QP0^Xd{{DZ&T+oSmh
zW2q_sworx+&<+-74##6GEa>hJM?^8w{ytFEcJ{RjyuASS4CsQsW^ggV3_899?w{vA
zov%Q9cfMzU#xz+}e7coiPk1pi3p71sTQwcDIXwfVd670D)T8q$sE+sS{NvI12DID5
zr?WKy)IIO)&G`TSf6IXqWq!?8P#c9`)3<?NGjsyKX6yof&D0J2nz;w~HA^q>Yt}vh
z9cSRt+Y7$ot5<Z-6efm!pf!+4;nfPd@yYN2sCeb~=yer1-U?C-QsmkE^n*udE9j;r
zkKR_$tyth4Vyy=M|NlSU3c9@-)Gd8+3DiRB4N(yQr`PA6ogyk8$rpSWUqSY~cY`fJ
zBnMuP-qa61oevyi9Aje-znGE<YSTD?8d6m9uL8oq7bY_?fSY90^zWnG|NlL)`ga9r
zl#GCXmt;Wvi(1NgbhCqJ^gX&|K7dD)_kvnw-Aq2++Mb<%JUg#>bXRbAcDr(bmcn^h
zelL-8+|QoLe;kpe8|<}8lwTan{Qn=cF4eR1E-2OdbiM#(Jm{DUxV-S}c4Yvi-FVP)
zbI<M=&_0q34#NWtwG3MPQx1SOS$4jEVV43L@cjioOYGQ-1xf!w`xm}{_OJ|5;V4z{
z>=pwV<J0-tqq~a3qdS1Zqq~R$<g6~w&ZFQ{=O(xszI_S0)eqL5a}4+F{O%a$*?A3;
zs?UJuyh9;FdB+u?HRcbG?(!F)Yd&A}WPs8*e~S#LdDwXsJbv2}4&uP}fbxSH5bY75
zVYyx#&^}5A&<ejLX<(Ndf>v6A&ZkfT`J^}4z@xiZz~i_xxH0R|`mH406_n<^1zw9o
z>(g!qk4{E#JaB;I-90)#8eZ}Mwb30pJidSR?5(-V0FrJ!P<q*;+gSjly3<?0r<32K
z*^+_3Wi<l>gLkLTQ3lV>3!p-MKg?WfPs?8=tS?@tf*ke%w6HZBWS~!{wrA&c?_Qt3
z3?AK#9<2vTT|mZyE+6sfOcwA26&|ezO87zXWO&KrdohP^XUbIuk6y6VuT`M^XrFFv
zBr{6(cyu#>jPU4Y^yyUaXm*xh1l7SloexkF0%%?Bg_k1W&LXtF>diLrIPMI}(G0$w
zuU?)3o$zx#5maCvf7uCYuOiYKs2qpH;-66dZLB|im>F6Ql$3&<+>M!-J|_PEzYCOF
zp~)#Q0i2wAZ99CJ89ct5c7mwRYoO8EXP_Jes^K8%ACyx0TQ-98f`b6Kh6nW@!DC<0
z{g@uTwv|523@>cJDWAWk99$8y#)8c3wT%N&$61wqm_du}89X{!MIa)QK9Gq$kK?Rj
zQ08&490Nmxy~lA@L8zd|aaKMk^F?M7sJs@P<iZTv;(pp2MA@qNGcmk4pZx#-%fFyH
zRu7imU(AjM9R_d|6evF6Kyid-F;B*$pgr}s6QH32E>w@bu#N|ZO6Plz@1-0bkl?uf
z`~QEiuem_J>V^czzkmP#$9i--2!KjZ`2K8Ic>-yLHovieY)m%y*biz7{r~@;8N5aL
zg9oS)Zux`1B?FX~KrN?lU>iWoSv__?fGDo_>E&VYu{^=w#tK#iZpUbVdJ+ntzMTZ9
ztP*%(nGCAUN}xNHK|5Z1StLBVeN+^Dx<OkhL2Vz;-dF{XZXqAWcaHqq7(9Ay9l$3I
z*m-n@3Gi<VlVCi+#prR|4b+BVXnw%l{OAwog$_3fAIq;LW<H?V<PXqv{+T}?w3Qh&
zcc#EE==I<;e}2FRe!-v*pxw-mz~e_BJbPnU6=1uW!3_-1Ze}0G-!JMCK`pRvkkyrm
zpm+q`H3jN@9R;=MZm03*90s+u1swSWSyVhw$Ev~Qrf=)XQdLk74(!z3p!yM1#DVHc
zusm4g<;8#h|9e{g^yvKU$?ta4<KSb~m;1myF55pnObjp5<3a6SuzE*G|GoJQ$BV*9
zP)a%M(cJ)=rSs@s4PGE)`GUVCItLWO6+b+hUvPMIHiM;G|Cg|VjsPqP_2}LV8bS5w
z{0QoqcAfyYjvIfrGcYieX?k>bgOyvpERpr>JY#qX+=6@VaqvI0$M^3Z%|DpRSUoJy
zm8ye^2T0ifZlApnP5{{ncEjtrh&=CsRO}uv4+M?ZSVBq%pUy{qy*dh@_Ki4L?{1L$
zL1BB=r*k#Pg`gllkj9^LkYBJFBnRp{bRg_~c>$!Y*Y;!|6T=IaI7pF`la10K0-w<Y
ztvnn%|9EtM5A`_sUIEnj!*VCs2k=@dkAp8vn;$SbH2i1eZ!=+HU^wQYBB<JOfWLJ=
zs6^>?Q4w-&eZt@Q6EvC)S}uN!!N;NDKQn&|XyN~^G|*<)hW|_@th-V{-HPrwfsO!1
zkKP;=!D9|g44&O?5+1$PjG*O}AY(d|n2^_3_;%-U{4Y_-@X);B()kd~>O2POe09F^
zWV{R7Ao%`;Me_guaq*o8K?}n{rLafx2T#lIkO48U@ysSF9+t<-HiP<d*@r+&*WDyu
zF9oNch8h(PX8xA@pb3KB5QtAY%0a77cj<wzq;+CSbLkWUO&fE-`~_*s9eiid{EX3|
z;UA;qrRGNp&4(OcLQ*lPozLJ28pAn$08|cu7v@`j;%^2u_`uuH`Q;fv_A>Fe*fKFN
z`1bmkg89roohSHPm{9!h*?9;w#M)qyTKdI>e_I5jXKxUr;ahlnnSUQwZ^>E)kLE*+
zy*Y&!Ky%)2I$wGA)-ry-<=F6Bm*3?T=zxTlA|?g~$A+qZ2A;i6|4N16`XPoJlzjKm
zeBs$!%H+~p@gH<_LFb<rib?<fd-cXxGkRLbNtA&WbAiH78+`bFoIvLb7tIGApbZ%*
z9>y}@tL^z)^+3Uheu@D&Jit-A9yF{DN<5CuZx~w+@VD#-9Z&=d_Rh|K;H&pIn2x!q
z2>Ez)Uf^#%`S<_-ouCxt*&QbUip#W49~EKnIAD&7Aiq2VQu^@dd<9P*M+^^mGTsH%
z57LSM|2sxFMuL(@g{DXH2OrC4MV26=JbFuv89gjN6z>N4D;RWSez%*%>$Tu?ff0Y#
z%BH-&o;CpzZ>=7n6QCI1d31h<maCqfKl!)0|MzHq&)EFJz=pHzormVXP9Bxsu>U@t
z=RgNOUrPA@zne#;H}XG9c;4Rs|9|HT&(1i3?>E2~OF`Q^jGs}IZP^bRM2Z6)?A#8j
zAYt_*C|p~MK!?~_mr0Zf_<(w7CMqvlK_}LCo2YnpmVvZ{{QLhO6sXD`y&)>XAU&Nj
zprGg9^~~Uyi;A#MaRT^SR75C;sEE9r0WNYwRD>MCc>$d59ru8?lY+BEuM^Wt&|%)-
z@bc(91W^T-Itf}qZU{c`6m)acjznnYPwRA15dnq&OVA9#i`y|M1r(_M#a=#Hd;*PB
zav*g<z_Zk#^JqFj7ic4wQgV<|N)cR2?F5%nAu38>e?NwnQWB6N3e+Rq0ZL#F;38@V
zyoh1~l~9VuoEVWxs2UXkkQp89puOOb`8rVg^U%EUiC@4)g~O%up$DvV0?(~M)8O>D
z|NlYhkH4c9<Q8c0G!YyiZW12Mpt>JcKAql+UOq`M^S4|CWvpHoh#xxA85tP%LyD&W
zrnF8AQ0WBm54cn5fmAd>=KLIAf_k5z_9jNU{>0x5>bbsb05@Vm<&Xpue~T$nxg-H8
zmwquaFr-bOR(S+EE1AUdXksk3@@V!RNXCGdN1z#VSb3xa3O4js2u69Ns0u5Ou7WZJ
zESNiILdqivCXdcT{H+hM6-7$mR01uB;OPJ~%?C;cN01Z2q!>sdsL+8HLN1_805630
zfeN8>ptIybh0q3A{>F$eP&sr3(Vl3iQITNcZw(->Jn~WDKom%hG5`N}gGA6uB+uPQ
zCDJO;JQ-*o1zLHe0&;05q4G!wTppFEaJ={eI<LLEM1=!dA_YN8Bqe2!UKbT*P_F9K
z0tG&(L@G|iD2$X}P6j)K0i;|Boc52os3@vJi=$2pkKO>LmtR1m)sTGY(Rl%^3Y0rQ
zQa2H$(T>0W|AR{-kM1Y|P-&#>(d{Jh(g@U3^Nm0$jnXDKhJ#Lcf(+P$M*2Gc277dV
z25%K?e&c~s7+HXZq4iIAbjqmkH%|dI`1yA|GvRLzVq{=A?xJD>nz8_`nEnWwng1`y
z-){+018ooTGk^|2Iq0Ey0(3k}<3rG~Ec`9=K&$D&yJ{F11Q;4$8iV+Z7n)yk?>Y>+
zH3QVV@abmdH)LkeJmqol0k<zGLP0aUnU|b=1$;die|a4IrO<dNnvsFw;4fxSD?tX_
z$M;CS)Vq7hzyJR`YgA-Bx@}Vom>Kx@+k|_5SGmA=ekZ8m;&JeWy=UiT&7Yo(hkZJ4
zcwBzr*m<b=2Pc1<Itv3s^N(cywtc(|43I?tZHGZj$O4;YZUzS1`E860{B3(cqV`Vw
z4E${eK+O7SGZ^^Wj)0i|AADuyZ#w~EGMt)aEqST=5T`Ae^}qQz*UM9&r3LZ~K9KW<
zz{}1mSQ$Wf((<?RvVtavA9cQeaTatyUw4d(1yUoVj~8^%^brq8YaBA14DU~ZqPq2e
zokhcMrcz^{<oBMIN6WZ<I^TJ8UVjk)zK|qGMZgo(iuLJy1)hO^p&1Oy58rRRo(4L1
zqB}%I0Mep6Rwf8)zDw-@71&TwPf&lz6Et>zj77k}@W9J>aIxyZ0BiR{;`xw=;suX`
zuS_~GLSov3f7df({$|kHpVpK7Ez>y}7(C&p#`JCk9RSn#&;LKD{1aht;GcWk$MO*W
zl!J=r8~^!%Ea;gJ+A9vK=mbCs#SzT%U_8<J(^K()N9T3V%P%`W`e>f_1W7P}lz_*-
zZ8;ejpzRk>;%R=#?b&&}^MmGz&VwG8pTDjEwX;BrZk{tTFnm7*I{${h<u)S&L+eTY
zR&Q<w2E$8^J3wyRdFJ>3|NFoPWAxfg1t-d05h2gci=O<u9+`UfIx!YWdqR`30t2MI
zz<9v1`30j->xGgpj?FK)JPtnKa?v~pYS~|Y4(cRIB2L5s)mt8nmzv)(dbA!Y`P%%B
zdnYLMgL95gH|t7WW(LiVp537HA(BseWS)eie9&aALgPVj%KypSD{~ffYiF+`qenOI
zeO+b-j~SgYpp?&Z(3O8bkAp|&1yB%pe1GV|cn&o51WNp%Q$Bupe1GWKc@dl$7!P`M
zo&e_!&+pGQKYDf^_dNLC-nX|#oN*T;Xx$d*INBe+nui?01;5AT7e1YbJug3S>^$rV
zYFBHX_F?=D>gaeX{%`)lS(da5w5GZFM{-#Ncw!fvmCAf}f%bsfg7Q+C!!A&B3!ItC
zOm?v`FfiDHa#NYcE_M(bl%2|Cc7giRwxIk}CSZ8U_W#LQ*8I~CH6P*xuPe|!sl&|R
z2p%T%={2=!VPXJ<XY(&E{`PcE28PZHp2;k2K8zp!KLCk?qSk{Qv^3@<ByPdc>eDL%
zIvdNS^Pp#M)&G~O;IbH8k9t6(Re)h9DE=pSFdk@r$>`B~q2%k!(BGh;nEjxT@kqYZ
zV57p+S)*d&2--NOYof!<;M?tTm4Uw%)DG(Wp?SllcMod}XjM+@fBya&&|>i<k6mZa
zK!8u@4bRIDJib5j={(?Z@D;O%<^>PS3q`yjy7`ANe|sM&&ouu|=5KrS`~QDW%?lpA
zUf(=>9k@W}iZy}Uw!@Htfx)qZ5wdc#1hg_pp26^Tw~LC2wu_34XJ?Fxz{~Z&A>+#6
z2n0u}N3X1LGZTZy<p-ciVGU4+3B*wFR6Ohh(&Ew^kF+1M*Xcj#47yGi6`tn*T>R}R
zpcY6n%We<G8=wGYaP7S2c<>#kZ|1jVZx#m6gYVQGGmn8vJ!n33)I8+ae9XY5^Sa07
z=N`;8DgrK@F)AjV7hF3^1phl)Ugz%z)gPXhA9!m1@U;BF-+T+S%Cz}Cqi6F0Mjy-L
z{7sL3{r}$`qQV1O$kpIt_@A-$Qi+*Qa*YZPsJG_b>tp%9xB8!VuZX3G=1<tTZG+Q)
zM$iV#V@`|)9+nqNSR1S?>t8uGSX%P;-(X^30L31E%Mm6922W5G(_Nxs;*os8qc=qG
zKjX32vhe<7=SPq!ng=_5R7^kvkaIv)%)#atj15)>C67FkZ+cqBs7UZPfzES!*@#F-
zuASF>Grx6OKMVCd_|6g(CJ(=|zI+Gi>bQWmXoKXlPsL|@9(-r!n0c&W+6;!5=g{Pv
z?@2p*9(-ryn0d^>iJt*{bULIz1qpXn-^_1EqiVRI;l7}ak>O<*$P9S>up?4@`$gBz
zYd-wzKX@K|r|Xz`OhBE1;bjWgsScp{^UeHr**8hR^WZx*$IN3dm>C$5)^S1n0a`Za
zdGMX8WA?F>mzp38VC}gbpahLDU)i~rWgFvxm#kppLH_J5G5|H_1zZg;y#!s@1x**-
zH7X`Py+w?m)YkgHPQx?#uutbF-)@(q3@<zWf)<BecLY~guw?V{2x!s61W*rM05p!M
z;FEj_oRmCzZD#jIF?ulm?~GC5@l^cbaru4oaRcWL8$n0Q`~3Z&%MBcNbAj>-_&^Ov
z_&N6a{|A|+p?T58@&`E6^ZTCa72)W1QQ=`c;bVE5zbzBAXu0#IkLFEJ%hUYLQK0*>
zG!J`p-t@G*Q7+=$TeFtIv-6h6!RJiAnumNWua{-{S{~+aH~R7azpv&EPsY=}mN)pD
zltHE>|8Q(@u>>XEI%ALIPcFSq|2=zo3_W{G4FCIR9(yeb3(p2eP`Z7|c+3%$ZqJpl
zHdsQ_Z5@x}F-F5)Cnm>ZES3hK^jpHwdVs&*=I{UiorhnRfEST5fHpsZ)HxnwF*ImC
z!1z)aBJR?8@8CO54@frkIQUK-l1nEzY90n>&l?_>ANVl-Xnw`$(s{l!1e6;td3J|f
zWpL^!;r;Jnd6>U#BPg@<7XA0Q{0KDq<mu6Q(?jzhXsc9}Z}LG8&5M4$F08O~U_Cnz
zdN5w_usp`!9tqOd`N5;}ps(f$56zFBmM8d|!21J}&o|`o{%7=TKE&u_d7;=CVWNfy
z;~`JWOZ@GiL3W?ci$0o{z;<2aZ?|Gb9!~>J)$+HgfjYs>uUSCuY?5SVVCekqX${Jk
zZSO#(N#{LK!^RPGbH+XJ-ZlpYm(F`0ko@U!@SSDmF$Pffd=E~w;CcWe56Yh&2j7`N
zv*&qqc~JiJIQY&8nms}Hf<V(ZIJ{XsAlVZV-r(HX12)2e0h}*Emhi6!oj<D!&6e=>
zf*>hKzVtZwP7RtZL1!r=%=gIr2FjNn2j8iJvL&d!pEd!UA3>TS<|;$7qZlO1g4X}_
z7903<{%|$C{Zat5z6UhF-g(H?@FciiL^RSmKSJ^er2g}1Jy7!X<%)0r|07ylkY=1q
zZzHI&<imL4<#Nz|57*xEe;&y(Dm?zZA%aYfdqMfmrSrSybsxslzP%<^-n}*r;Oy()
z8v+{UI}FOW%{eM2jJ}MQAeq;<^K$cX1BZ_4|DKlj_*;VhfG$eA`uZriNwFW)mUvkU
zIby{HbPd``#|8~XPtA)SmZ$jJ--1sdKl!p2oa#aAY(rE`Jev<PwqD}zzX3k7jYY-3
zmuJ66ugPp*#*;3+QU81689f-k`6!<7y!;YeqWC1=cWgdr;MU<I%K%y@(hQnk?7R<d
z=YiWDnioBiFM4*zTxIa=4f^lFzy7j^<)N|w@QC|CPs<bKl^&fReUi`nXdd+I_2K>R
zp?MINzdbt-`!F5=Pf^YUjh%E}^z1wiDq%FQ`&j<uZ`uPAOupWbBMQwI{Od1+@`gHS
zO^fCsPs<DCGM<bFd@T=^oA`8I^3}ZH0V;bAm8(JHt5-xC)Q}MOIQW>!L-QWU{cZ0M
z{YY(4_o%l-#iZB$zfb3LMi&*67c18M{|{<4ylnamYAk@$zh~!Z#|BMCU(LfH|E%=s
zy!jHe9bke_=ZTk~vlLu9Z$OJ@P_gmy2)LO6Ugvt_rOW^S|4~v$<4aReM-N=ef*R{D
zm%{g}G#_UI9RT2yd>`U|pI)AZZcy>lc>{EmjW6R#c--_>{Rc%0sLkclc^?!z|2>-z
zGlI*QRM1WGp!1NyO`QFpX6Va^Z~y;K0Jli@gC_M}dVKr;AKVn(4{C$Hv;=WMto@*7
z=u0gS7sT2RYKgv-25~_w@X6vYdA|MszXLQ0`m*~Q=sp;a|NnP_dMc2fiRMSo%MZPJ
zS-4(Ce+JFuAciw0kUGD;#*@7H?IZ4>Y2;t<`E3{1|Nngkc7EH(@_GsD3vRH(hSvP{
zcPGeX6MrDe=n1Gl0Y3k>`Hg@_w;sx131~TS>s$U7@j%ctnJWiqeNJ}+XqoLwQ2&&_
zr5Tj5JKq~#^5`{<C}d)Ik>m-o1hlm2xCf|Zxd?PS$ys-hb{iGY`TPrAK_h{n#b}^&
zgL70kUaVil$N+A`fHv=gX3HQme#s6kZ~0rQK^B0z>xeZqaiAqu&^dnSyg0};9Q-W>
z0U*oYzla6d*LfK1fEcKlCfME>(9jl(%Ih_deECAy<^TWJ(<Z#|cK!d~@GW>z+KczD
zAXARMED8YKtsVec|L7P3nrZfEek0-0Z3l8<=!-~K&<b!p*2)?thHCjw;Hgxf&Icfd
z4|pk{M66>B?40w```~4~pd+kVR9^Ub{Qv)nUw}pB6TbjRZR>%O{Vz_s{Qtinv|!`K
ze@D>FyXk`>&_pTts<*qI|Np=I><@7kPr(2Gp&q@u2PBypAPY*~NMJ--=W~xv9hDa@
zpuNPM*&H67%<$zPsDTMu5H1lNd-%mq7m$Bo=bwPiBgdH@O6tMsz;vG+=s<v4@LHIh
z7dITht8tP&I^Vz0fkr^{kN+jwo}Dr(pyj3<@F?VOoezrE<|6{IXoS}PFO1#)|9_ze
z(%pKX1axtx71$1o7gbJR)74%qbcTh~bq8=b?I;9?6DVzM_4xn)<sZNQ|6f!)g97XQ
zi^*VZCFeknS`G@=P8O9HaUjWV6BWZtpaxWdC?iAXVUNz|FU0gf*DUk5f`)Kj&wlY7
zq^$Gk%QJqU6no_56+ciZ2(B+fcY>~<2Cp>jd<rTI|2u|x^zKanO^A1X1I=~^do;cQ
z@2KqDdIB_J+Bx;W-~a!S;>q;{XsQ0*AAkS<|Ln2aqZhmojbF1BWQIp)>k6=@)(_yx
zoz@7@iiplu(3mKEjhgEO(26)v!%MTZ0YZUyw`jI5fbcdzDA1iXpZNt?PgH`!sdWRy
zV9??^k6zYQxl9Zm$6J5=`~M$20B{^UH34OUR^EY_pZNt_1^)m4528IFv}=P$CwMp;
zv{nw}M$mPRTS4<}9>-fF{{8<C8b<Z#Y`p;5Zq~Pkk-?{TtpZrxF`v%&KAmeHfF!1Z
z+|tWxlnc5+;=NDjRt=Dn?zs?^tp*_8@mA0T6v((2Zfih0laG1ywn~6xKvuTi0GZ<p
zGN&6N+PxQ~-s5=d3%D!hJ^(9ky#b<H|CexqRuu5Jr1OCeGS~}pEhtMvMZtIMcDI7G
zfaCW#*cl-E`88WX4)g3h1}<1Q_(9vzA>{~YLD&DSAU~z?zrO@J$g3CRb5~Fl-{RMt
z>HxC28<G;b!Ex?!92|Tgb6?DJWn_r==-vxb<rv`sIvI8~2Lr>4WuOG!d>Fi7d#*<}
z*mjTZxu8G-Il}S=e@iWRjtdlppt%K*X&^`QYqo;SdhG#gpBY~AI1XwBFnBZ{lSu0f
z`*F<em!L=I){KAu|APnUj=BBfPwRC1;nVrSqxpb`PiNW-uoZ{-TR;sb-)=Vv&u%~P
z!ZqK{j}WhVKzw3&$+Nr6;>AlF(EeW68NS_V4v}$?@fX(_{2lAP|Nr-}2FFGjyGJLO
z;n5AY*~5Bk0Vs{Og0^cyO?zQ@0Te4>`Im{HQB%-4(LUXfwADQq<S&n%mVJ*cKnUbq
z%^RTe;5%DiKoS8ciaZYfVg}#43ywPv{`D6<G(l^Dm_0kMdhoA52yUo$fUX|xZUu#=
z$1a$G9-XZWpt#cf;MsY^^WYz5AO7`^d@Y~yw|jz4P-)%^vW20}8CqU>bUQnEc7F5h
zt&{NRbaU|NcDC^7bhGg2EtYsuVFN0H?tvzZbQk>p@7a9J!=w4Ihfn7>&*ry`rAI&$
z6qZ{-wv`xzwyJkmOL#ON(C`3XC$`!SRAX9$(?U8M1H+41Ac5w?9v+r+L0U@Bq6JAe
z#Q)5YMA8ZNmXGD<5({v7<pDCh*BNTKAIPk3h~Ziw!)-wV&4)ceI|HuxbZ-R(vTrMN
z0g(bo5;O4~=5K8Shxk@-iPb$7l$JcY_kxNWpYGNZpis2DR-)t6dC;TtgHPvY56z#T
zjX7ZVq%~Iv{4Zrm>+}%tXg(m}VR@+Zjc4b*G!Oo~V<6%YXhF>jkM34b`bgu?IpW#r
zF5uDK3cASNkzbG<q~^G1r@MqlH@NIe<Ig$j$S>%g080Iyo$d-A-K`y<qy;HYJv-es
zJi1$<#Usc}&rWv(kM35`+&Mp_`1I^_xA5qOm7O4^o}KOv9^I`gAm)Jl<=N@(;nCd+
zEm%RttY@ctfJb-h4u~3%glDIFghzMl1(5%bgDFt1^z3vm_{^Wb6<h>$gEN66zhHTV
zXJ<R;ARc&NZw4ir?zy0a&K|9|OT=O6tn<D{xAcptAlcU2r5`-HTS0}hNB3S(Id1sP
zqgUi8$eI_*R-kkP7WFvZ3c5@IB<yh<ymT7OwB8G<0ZLe3cz_J+o(q~*23aKnY6pUr
zk#$SI&;?0B?Ex)^@#x+QnwdtjXSXHT9+0TVaqwzsu;ItS%b&qa>%E}bs)Y5$18b1d
zxeTBxto3#YvOPyZQc!z9Rgg#bUQmUHWKS@}9+0TV@mA1=Y_Q?STS3NwnbvzjRb>h5
ziwclo-L0T_^5~v>0u=t8$2}|$msogo9)yKsx1~p~qkw1UIq-E-v7ig;9jw8bQ^BY6
zqmSk1(mNhdGdhohY6aF83Se{hf|3D5fFB|NN+J+}f8am|Cr*#<xuCijH2z?DxWw7B
z^BDNtKu|f=d_V$Hq?RaoLK=}TLG@7S;}?CFpk5BB;DxFH9UliV4(5p2U@O2442Ydw
zAc0<1Wzanmpet>AMPJPL|KIa?JLnv1P{4q)$PbV1R#5B1kzcSKbXplm>=3k|P2<lw
z4oV`>TGF?7J4l5`XDc`#_p;7S1veK!nT21|b;FC3OF-rOUQo3LI+N@c_>6FHH3Pe~
z;y*KZgQGDA=oF9l2Ru3tdme9x&W|yGoB--KcpQAp3a&nHg38m*`!60^LUxB8@L)Xb
z)0?`$v-2ouJETXq>jsZba9QWsIUi(-Pv>ixArs(@Sx^@vo{fP4+#v>^ymJ5lg*5*B
z*bN{9_ywZ{Jem(HzzWS19^HFEMTlqTeDG#1L|Y)64OHv6ZU8M7=kw^TT>u`I0dL{+
z>@E-R)Gqh%*a6!I<_Ot1#^7=AA2X=H@#*~TcpQ9V5Gde1kGF$P*#j{>_}6~`xf!&4
z<%I?pXpxG0fM<8S2Wa`I<&9GP*I|(M!zX?L?oa#z&d?iE4oiIE7xV+|?{xd&*|{Bj
z7M|tZ5>3x;2-|u)D3(i4dUW0bRWE)sV3!TuExiLSUqNa3@BjY|6%q{mt@A+>vfZvH
zkec6JAn*33-iQXRss+ux#vX>~>%0M~{yjPmdsu=iLjKmopa1{A?EeWGLUCXKRbZgu
ztJc*ZQPAm)5ch-5$p?#n{`UX>%Rt1r!ks5Pnhz*|?kBQ5%-;&SP5R{=$g1bM4A8tK
zp8C_m6kdP61to3d`tuE_{)E=u-BUqTK3a7Mt;RdAd1zkn>D6KOfYgsZ-Ah5Wrw8K)
zU(2ujEmy#&-h#&4KsU>1$AT_wIN*8QMMVG{d!0AHy*ki7HvSe*&@uqjt-P|JfCb&3
zXO2k1ptK8~qXKL7><)!)=KWQo>(Tksqw^RzoPD}EeYzbvJem&*fbPig>Gb>H)9LoZ
z!}3(=6VSyyj2A$s=4pTy>2i2>$0~S&)=qhLyGnpUva|IAsN!Y33EHuAfWKu8XcVe*
zF1StH{F}c#$fNl;BWQg+SRMa12FDH;6%CN16g-=cdU!S;@i@jJ&*0hZ`T=CY2hVQT
zA0WmLP?)rS1Z{|)4?Y&gfdN!89DA)X!J~UCsG$vVl!W1>7rj=X9+3-ZhvIP$NV^+k
zfQCo+R<P4LZ@u_s0xtDIjsnfoOT4T>-tT32;N@w^;B5;iq!~abl(cLIO~UOsUMK@X
z;FCDo?}A3ayTOgF7dyb|0qiFq&>l+A{ofwlU_P|fh8Upo=mw`=&{g!{463aR+nUWU
z$N=A+Ee5g>HA?-NL2DMCzwkB%ZO57lN-Us4^8j>{wr^(=Xwfv2M|Us>=&mozUnQoH
zX!Y&944%iu9j`u+(hL&49^GKGeY%qsJbJ4%JUX2?JUXi+e7dtGd^%tFFg_^Z^aTyP
zfTr?%I+ucjvH1@_e>)dwFJSW@M*h|hpt&E=o;0Xg9Znh^-Mt_egL0`)XQF~f^Fa^j
z9yR9=9-WRKJi48Kcyv1c@aP1q1Ls)KB5u^a1+?;V@B}4RNc{M8e(>zBLu#LLn}C*6
zfQLeYU;Hx$*PtGt>hmhhELhF;&=`~uz|n+}M?o3agBj9t?F6^gUpjsTjkiGROAknW
z$=_Q0|NsBj%RuY5TA%Q@h=F+K;Cux0FeG_`MxiPtUc5I4*$DO_$Sa+WpjIL%1U)((
zH6S|;Uql;$)IbvnICwp}D<od-2DRhl9T*G`y!;26n1l77z?FzKxHjT%*$!IG0^MBm
zaxUmDn+YDr!5##q<(KiG9_enw|NmcZ{RkdXabaM1u^PnhNAPEZ_}w7A5Px(YOykd2
z0PS-CrB{#ct)OuMkK>Nug2<=yKfflUM<=*7%&!S9!uU0pg4*3Lf)0Z{0%H4gF9p}#
zoyR>bkCcS?bgu<h*1fWI?92?FoyS4@ARFp67<@YamB>2sZ*y1hIDY6q=%k!u?jTXf
zhT%j1MGpIP{_to%U;tV<VR@wVlt(voR07l@;%@<6)Bb|X=>Pwh%fQtFXg<{N+sjYj
zVRlG*F}(e9;*bCTU$p4`|No+14>V3=+Yryh@S@lN%q{`3(+&Rre~|=IQ45NVUfXRT
zQA2%D*>ddVW?NA4fBfZjFn##tJ}9jU>W*|Cei;I$kH0hrkLnzL$qDK#cOHIeVE6z3
z%bWHPLztn0r=j#`2UtD!hNHP&K!Cqp)cOB^(7xqfQH5kC2KdeC@b)5Te2n9;M{_*~
zXg?Hx$4$^6YV#4$Erp=-uaen8%h``01R?(KhG>J&w?np4@psIIDMY$_4BYN+hPmgm
z6U;qVl8AB7beM^dbOdov6G9Nbdm>>9k#9o-r4!g4(cl5b#y6n$mq&L#==>@0ZWyF-
zEXV~spbG)smPmMZeg_>z1v(3*6O`{k+pphycG`nZqVniv5eF^F-~bi&txce^7j%&w
zXbTO8Pj87z0B9E!gHLy|flqg}1?VJN506d`k8WoVpKcA0WM>CY#$%l>Dk>l|Bz7c&
zHaS~906C1oNAd@Mvkz!%TsQA5PEcCE@e<UlLevL_Zyou!IRtq2`u+3lyz1ED_78M^
zlB7>>;r|ZD|E{1tv5?cNj)G3Fy4Cq&rsMbDh|{Zly8}EtdqWvLyPY^ZnVCSt2Q7}E
z(+DBP`t%lpjO}pzw*#~s$iwmn*jXNuANZR$fp+?z^yz%=)A?^#3dqr&J}M5NZO#@i
zt{H;b{U8~`lTf)76@y+G2GB{!8ZX$jL3NOiiUa6Ia1GC1zyF?{M|zzZK?@HIK(mb&
zAWtxQf==XegL{I%Px1f%|IMf#;cw*u<@1JL_53YNpk?UY9$*i7fEpptQ?Ec>Q=iUP
zFE4=>sdgUT!3lCKB7}>gyIoXN9Gj0AxOSxd2dy_-2pYrf_5tmPa#7*%U<S7bz-P;X
z8u}?7#w^hN2B2MR9*svpfr7N!50vgf_U#1O*UkHooteRv@d?PAj=e4_;3KgZ9Xs4W
zXN;9HIJA7LQ|NVNbl~6jZ|3*^kTbFVLC(YiM=K~!o%y%1D0Vo4X8lya9RpC86MU~^
zcZrGzDA+h&B<cMB|I!UMt^__8>%G?h|1S$brS?}{&{^g34h*36?VwRyq%GqS*v?<`
zKs$eJ3aEJN#CrakBsjr4Tlge{rm8{buX!L2U{in|z$O7YfXxGZ0-Gi{J<FbA1D(JI
zJ|@k<m!k96EI<c%A)mj-4obnG^Vb}Fd*SD=c{J9jaDY-Vf7^0U{C0lw1RXn2qQU_>
zs?1}@;jbDo{fEA4cpQAi<njFxXhB}{qdy)8Uod$v9s-TI^@>aa9kA$$?|3#lP-5gq
zKAuekbUd3#>m~kHC6F9Ap-O=Ee|LLB-HkY&4YZyCbfDTxaAge|o@DT7{>NGF)r@pN
zTOVklAL4*E52WM>-X`CCBmyZdf{gnNHV#r=`gF?%vNDr#J{vfWFwbWLZT$e{VhQN^
zY<D#O|9=S@^@P?l;B=U-0jjw`=`dFtG}C}6z9xV+BYpriM33?BJJjheaNHeq3K0Xp
zn2X8>eogk4OBK5O+Z;JpB$UWBKPcD*+OK!qT>><AZ=<jSbgme`>!A*J5%~Ve?>COQ
zi|9g?bh-<m-`@*bN$uJB7c}klCDfzyYB2w{C>Bt+qC^(7U6|FQ^>(SXZ|A#cpUw~9
z{i%*|;Qe$yy(Z=$1<(1n8ToWRdND=)|9@09knr{B{OM}=4dFrX;ZL_bI^TIVA7gys
zrwgk34|*`(^tJp_`q+nm{bOIor?2}F>K(&<dc#FPu5=6u-3#(=ut)QojP7`WZhzFt
zun5BgKHdDCH=0i{^6x#+{6Svxs7E*J5@u$G%(oX=7#I%z<?%?qYArLtquZUM`7Xm}
z{(Oe!ql`YuPx(QI0P$}NQL*ITR-$6%)ytyT{D|M7qeO+j;TH>k3uvz&Xn~!p;eX4o
z{5_S73=A!oO8LP$njd{=KE>1#qGIXWZRi5JsmrrFOaRn`_UYvj@UeWs-&_T1$ZH<u
z-{zuX=gGhRs1M@_&=#=vkD&b~oo)gk2}{rJI*#TC{2q+gZJ795)L0l8Y?%35%0NX4
zXbEU8GXsNPuZg{H>wo^%4p3jIw?xIktJg-Y`FC=eyGJ)`Hxo1H9<R=uj-9t1L7n^e
zOdgphAq#9?s%BqI={ya(2cz>A<E36NM*eL)93B3Q{M$qXI>a3te}Kw?^25!)Ir-Zz
zfjXJptkz7-42-vXgCT0d|MPESk?3&$*ZP*fbstDYZ-@$LF^n4Ma+vL)UTU|CN(55g
zn*kblfS-Q^8hHSx8{cj|&{kUw575Om-+ekkr?GeXfclp%DguuG1wkj5X!t-5X$J{|
z8V)b7fio;P|95`Se0R)6h2Ow~@q|zEzn8^eDF+7dVf>aC_?w%-tF^BCb{l$X9{1?H
z;M?sd;M=Ri=xd!PQKsqH&F0ey+Q|z#P6uqg1SrP|{1@<nZ14r$O$@5(d^__5e3|_?
zJV2rE588bL3i(`6e1JmUlkp2E;C(&1S%nyx84&5U^JeFL&*nF1VXt|;^H=Bn&eQO)
zckJ*{0f($(hlon!e{k?00SEtLP~>*A?qNU*e#edw6>tQA`uCtHXaQYx;@`_++5DG-
zzo`MN#YM%zv)6;eqxs<v&rXKU7arXqY(G3ZLl}N|YMyXmJnEx)toi8=um;c!QuEUv
zh6g$iH6P&c=(Z8_=(G{Ed{OlNr71K#L4DKS5)~^@=ty{6d;u=bz>#$f)GQNtaTv6R
zyBicmp#I;<5@|@Jb)NF+y!N6@6Vz9MN;01J>g9o?Tse?SLE-1u%K}ch{vO?|7ymPX
zE<c2n7oGRP>Gzgr^9v@A%>R(|`(8EsdP?VSc>1kk<lkmv;n-0D4MG9O#$VtdJO~cL
z6`)w^X080sgh;`T9Rbh~bN~fl>lP+Z_y3(&uZ^OIb_wW^k54Z?{QCd@r3rZD6@v%Z
zBOu=kyjY<D@r?kelgW4<mJeGhK+BT0m8kIhbpCoVS?T}(mucXmu0ZoxzTJkdhX0Wh
zAAj45zyJTgtU@yXyieyfh!w6dD?B?7dNQ5_W%HKFAe9i~&x33*R04H%4!*2L>92zF
zA$Y%p56BZCDiSX=K}!ZfX&AJIvGrt$94KZaJUUN#bRGvq&P{cwcMx{9P6Y)SC}N-q
z+r^`s)$$(`!vu=cvo^@&Zq_${Q6d99J@5Msx+EH!p1~uw-6W*vhTs4H<4Dh`;Ducd
z49$lPI^zF>23njzivM!(H-pMwhi^w&_*;*F_E5a#Z&3#+-p1zG!RGMoC=-8+`0xM!
zJKyqechUQo=Gf_?_wOYuNChZ<n-3c}cEqUsf0+kL1o8|JgVLY|y$7w*1Q`SpXX0<U
z{|m(+jejrCf>g+Z-R0O3@&9E8D6-`p7(g`;C_RCag~SUx1xQp$ygUZB#(|+3<Z{qf
zc!-7aPzwz~+PATFFhU%z^cP`Yr;Fylmx3U9kh?+4GaNj7{h;Lp8={<G15XKSo?txc
zfhZ|Nf8h+-U!XCK31IU)dMi0RnxFsh=wyVN=g}F$_`{>~goox26!SX&Ae-mY%_8R0
z$s!Iec|ZY~HUS>4&%iE*g$FnT7|261K=9xH|GU{b-#T_Obi3&NaqM)_`17*nCrpqH
zDyaA8Wf)YjlMy7=>7x1PCHo)H`Zq<`cnxa%zY*O3#nR_>X!+0IvJ|vY?7fpi!+$gW
z_9jrTw^uYKn2EuGf7^eLWR_hXj2Het=#CRGywrIEHlEaci1FYH=F%S?-L4!i-MJDC
z6`Tx}Le>E+HN362`CEIzJAPb1cYWsz_$2@G=&oh(>2($H?+vj9-?9y=^!T^6sB|$f
zFm$-6u!Gp31CyH{@Y}HPx74zOFLwl$ovw!8EKk)6`y^jH=Ay!Gpn1_J`J*r6D__R%
zEeA?P5&AwfpJ3`}Q2`m^(arACy##!<vqyJ;fJe87glDgbkgw$<{$?k3(Am9fRKU$^
z%`2Y#>)&`Ve)X_C3p#^=15}4gfQmy<J?f$&0ICx>AhovysKY7%N*5fU(|tTZr~Yk&
z+Q)bu<ZdSZmcQJP2F_eg1_s~Ow<Ut$LotrMuvG>%2#@<PzV~hY#^2foy4aBMKlqMb
zkRKTsKrNeBjLi?&n-3Tqe9hd!RQlGVcM3Rod^(@K(Ea-V|7&j08X(Ypx!`#R$gl-c
z%VaxfKN?0S)uWpYbV{FrPv>*+VML(&2+G+R7+z?}g8S|-gk(TYJLb{N;L$q=5@wzE
z{|6|5Ru-8lg63r)x3e?ww}^wL3%Xqykj+{QTIX?324dDRX^>gRJ-QkG2S_+}9tD~4
zN#Xy0(3OcTH(5Xj%!dkqZ}kM-(*;Tcpqr9FBONZCmzqy8`uFk}^Y6XX{7GK(f=9RL
z{vS*XnFqj)+#ft1$tPT_MY@`AF!UBM`dXgmZ`sGgz~IQg&${zh^DD-NU$y-0OL!O<
zTr_X^bl&U@V6yyI&--!`4`}O|1B2!FT6vdV7A}wGgN&O0d@N7$w^VX7F!1lQ?EKOE
zg3+e7>@FxNcl%1XbRP2Q^%Vi7*w6g=5+01FKnG_QfLgPaF8teKRH{I6&BEW}$-%(T
zU7}KA_}0<#1AmVf8v{ej0Z{YVMWwR&0XR9js8qUi#DLDR%mLjcsqfN}qmlt?O&5R?
znt?~Rs|2XoW&tV{9b7s?R3cnDT~uN~cj_kiSia(K*5m-C))<vKPtB`7-K7Ga{Oj-f
zFn;o2yzBwm!>|t&A)T=T9^JJZU<djzeh0O-J8M)lK<({yT#)3r4b*7uEm6?`MM&Zz
zP~lsnq5;~ZUj=ICp8xd!|4S!O8>ZWj!=*b<qM?$Lp;8`nGPz6VE63)eOr35L$6Ulj
z4EVPNa=3KnNpys;iFCUP7+yjt4_HcneCE$*^hy2%3O%3RR8W35W#HF@++GjLt2pwz
zE(=nA|Bs&Ee}eP-Km7T<2a<MC^7|?N=1-vgo!jO>^ZP|l{`EIK7(aVho<_^>_dpSW
zmfztcL){e|9-R>aAP<1c7kGXz<$wh6UN%U6mj>teXCSjUUU<kuhQByK4HQt$|IgpL
z1k}gq4(0G+{O-|fn(NNQ(CsSFP{mQ<!S7<4{}nW2{R=d%1Uh5#6=U;5{(~=A__y)!
zb#RrwK@<q*UdVj>|NrH8a9b4=Wo7Uvb7OSr{N&ht3@ysaAW;?zEyNj`4>4YRQTp>U
ze?BL)c=l*MD&pTOV#luu2}zJ=am1EA=-B5T6;R3LYWNmCwqE)&e)45}PgZP!jyrbY
z-?ju6UB3M5A9^x=@w7aH5?wx>;2_2oUCaR-KAj1O=<0+O&t~k9=mO;%(25ml&@rc=
zqTWY^<Hbx+fe6}k29B=ppxLWdQP6A}w4eqRSMYM0vH5_(#n&B7rSD#X*0@gq70nvp
zdvy0e(qV54<l-aC<NPiDzyAM!F-!9Q|Cg@d<`HQB10+j$S{~wW4gh!Uj{0g|1)X}(
z&F;(i-lsc3z?bonk9B}VnY>500H{ML0B%(uhg3;IpvEtvHuC8V5b$Aq4)T*A#7{3y
zfy;H!aq?iFfclR<jQ?Tz6;$86XKa1|^#^<DyO%3}f*TK@SY=@7Msgo$oWQg5n6KtF
znESqi+~?h^BjRD50dpX@wmj|u+T!e@!tq}Sv$_O35K$*;!W;;x6HkGL3qcNqhcn21
zu=<d_^zBOy@MI09`#|%Eo}I^iHLt_m_s^p{Lco*p7IERn9Kit!KabA)h${Qpi!N|o
zb{|}2|L1Q7?eFz~WnA7Z&d3>;ciTsBSI>ok0d$Pcd&cHRkbEm5*dbo}=B57+(4-C6
zUoV_x|Nnp40^cX&0XpBW^PWfN`~Lzj4Z*1ctgiEui{>%M-Jq=v9*n0vlHa{t0E!;?
z{y~p!c2~py&?DhM^Ee>>H|X|382|0dE#THBcz=;EW2di#(=iua5d+80voDjsf!qXc
zhq8liA6P8{uDV~Qf+x;l;=dpzS)T}^BztKKx~~e<o@WOacA%`2hb({Q4`>W}TZszT
z++e7=ir@}7%-mNmtfAtN4gyU4*9&E+IB0PaXg<30HE3$3%H!f|aJs(tLJ4$d7_=?}
z<pqrw6J~>2AMZfJ;~F4En)hD(eGM8B2lp)?>E*>~>Hq&<M!?r~_;fz?fw!+fN%!Jg
zpUz95Y{mgP8Efxr&;ev`L75CxdV@v*TtNNMSD>4h3M4_H0Xi-hG*Avny=UMB1!O%5
zD1V`~=fH*5B@fMaFXBP2vjW}w3Xjij7nK6TZyuJ1ia9}J(3;o4OF~0b3_uY8X&->*
ztpd;*36KT_xQWrN@6(+t;MFUm<zXEwQO1LuvOGFt1$>xuIXs}@2D+<L<3+@*|Nmcl
zgL{4qKAoo#;Q^}mK;aDwk9#lHzCwftXhaD#WKg0Cj{j$%KobBtljB901SDj@qfVfJ
zgXJF3Dqnc+F)edI&ON3T@1WHlDE}Pv0A0_DQt$b6p7ZIv<e_=*h1#qC|6ekG{r`W0
zZ|4~l_j+D@1B*XUd-?B6kbA#@;}6-rpTOr$gAYFirQ2oV8199X`*R_M5x9X4$&WX{
z?t+z<Or`H2uJX}*_F}@z|NmcRgYTeZK-AICKvQHKFN#4oFm)aWl`LYQB9Q|eXvbb?
zi-YqUIDo$Kx2}d*2%m2Sr5}v)4{QY_JtOQn_d)<+g&^4UXD`l*Ax!_z-<kwk`U5Y#
zzS|)OKkv^spz)AH9-t$oP|L09;0bZC|B>xm@B(Z&a%B?>vkww{potl9Wdp7+LH<Ch
zXB<I$v3lM9JM-`JG5$aE`%g#4125~resf>|4f*tjs8qeM23Z14u8?fLa{B-OFXw=Z
zQpk7$r2K(L=1YFG$b4x9E_1-{hn82rkP_=o4E0gq(h^zyCy;uM7kyBrpd|fL6jZFh
zinkJea9F$qEjWhR@gg272s&sCD){P!7gX@czyJRoJ3qYa{S2YMg3g1n6#^M^^yMXR
zKk?|xH&A+)GN>#C&*$v|O=m(U3_yD`K$DRk-SGlG-RTnG^Yc<Xx_Q9!m7trdK@*sU
zCp|20`A9zGZ+^zkz+iY_7ih}a!}69#=RvUO6LtoMU7)K~Kx?v~D#2o)F-Nf02mH;?
z!K)l^fldJ43!08`HT?G4E^Wd-(D4vHo!@;d|9MEh=Wl+)%)qb@bW8-2*awgp=(q?Z
zu`kS^y`k3)PkMA7+XdS3?$h}nwDIK*&;S4XKxetQbiQ<KKFZ?Jc^zbQ=OK^IAE3j1
zB;ObHcqShOr36T;$ECYK#iQH8r?&#M=!63_>jCPU3xFm)96(bTp8VT<RJ?o`KQuq$
z@9<IK08e?m1+`p#R9rxPwzIVY$6Qo63_4G^XukAe{NR!N5;pze37`J(^y${`E>Ust
z><$(1?Dm!L=(Q05?cHqN1IkjG$3VR<KTyf6;K9HCm<Qtz56cr}3ZC7*44@t!WIEtI
z$kh^%Q3MT;BPBdLUBS~Mo}SF1;OUW0@bt)a==4ZAGpIN5jlcCCXppg&MIU5<h6iYl
z;yq}5x4Q;(HjIl(07zWIlkqrsF@cBW4N#h3@R58_T<+6t8u*fl!MF1Rq&@-#_<f(w
zXV6)C7tk)Ud!EhjnS48+zTg-7{~tv`uMWctFK$qF0?mte9`1Ez^z6I>nyhDV>~LoU
zF*F=I*ujehd@Mget$k566FldR<PiR5VNe&foAt;GlyOqXyo+Op`#;c?!vf$P|FG#r
z(5c+DyrBGWA0(sz>ZW@6Fn)ib0lJsA8)Muf5@Z9$xCeAzvO7e@0ko*M8GPSg=T)C>
zeGko}9-S9J5eho7-`Z6I5nl@6=^NzuQh>x4b0`NW&OAD=gU4^?fg&FoFACsz0UbFA
zx{p`DqnA*;?0imayp#)IiI+{BREd{vaCe_o=Q)me0Zmv5fWlt_)UHx^@tXVp|CgZa
zC?M&{r8kommLFecgGxlmc~~yJnQU<JU=(q7xVSY!96bN>?}e-YD850R6%S~zf|Gj-
zczkzTi3$g3K@JDk|Nk%lgY`1_bn6?wMT$fIHqb7pm&V`{AH3iBlTYWr7e^t5F1WW1
z$wuJlY6%3XgPFU5^Z);s_8<{?29S>xKyl~=Zh*O{Sa@7~2g=_XFIGMTyAf9Hfs9YX
zFx~*18r;CS6x57DN(~1wa%rtkx9RGqpww{IxAOyd{S!(y1h*hOJMVcmzh(06eEuSx
z4@-Jj#Ev69K(3Y3aO`kpK+C8<ie~tBzQoL{&7fr6%_{K}B~1iECzu=&dDQ?EOcJ2B
zcISN`#?LR#ae{`FLR2h3;tHTW7}_N&8ZXKp{Qv*b3p95$0V2^GqT=-;@c~9S%JG4P
z(4(nU2GlC*&Ot5hj$(vkl~1>6@)J-vet`9F@rI*3FP3nOVk0LU(F3tK!K0h?`eT#;
z421@u>%W)Fz^T`T0W@#p*b)E#<zH}@4?15G|NmtxXd(eL2NU`KWiKd6!V)Pr`~Uwh
zK{IXOnS|K?FQY+5!DQdE{r?YM_v8Uu`wgn69l^Er%L|}WPC#Oyt@n<5LFCIlFfq{f
zd&j*X^5qJc80Z`a$Gsr(<rL5Y$i<wXl^hd5>lNZ9pv{lHplfkJ>lG?M4Ules8Kjv7
z7nKa~f(6iqu;vqt9{hU`cr<^o2QOOSf6RokXu-o;<^sv977l@`@Dddh=&FU;B(7SR
zgJac#Fi0Hxs)Yt<wY&pV8-wP}&m*r|cm*m*K~s#NRSO=V+4FRdZr&>onHW6bYmL$-
zfNuJ1e$ND6bkupl^ZNtPSzpbM{&*gI$>hU$%A=QM5=hCx2TY*br8+NwH%6RhJmAvn
z!RW@njfc|(ysUu*bO9T5Qh1FAcvjd5RQ+|cCO<?<a~+WS6}qlL4x|D!pX%Lf176o~
zAABvXiwffU9R5}&P&=;~<q93pI3)VIh8PtE&|tL$sO5pQt^p(ro-_xqYuExxxRCk)
zeO&{%;FU*O*Kim-_(klxh8WO_3Lh23x(1K{XigYqT|+-?UBg;XjDh0Dlkp2UYVtk0
zc`Y9>F?j5UEdztL6FfR^ftNRc7KL?Q@c91Rv-6S%IDTF+`7mC>9zT~s@e=@w9}z*<
zju6nw2Np)h4i*&;XcVo4MA3av66t0=a33j(FxNhS?sbB%eb@umLc(0J&OhWCNR+h?
zf}r(@oi9M+D5&cmK(Pk8_r^s<;Kk`%pduW)w4oKe?g1=)%BS<*i#iS@Nzh6G=(>kE
zkSjsq3s3tQ9^Je*?xCc8aJ>c!-_HA<owq$uasm44yTcyv)pyr@I)5=<>UCn|-^K#E
zOp$*Zi(m)4XX9^B@1%S^BxKKmBDkA1?H*Fdq9*>^psKj@oj3A=i2FDH{|8@gh*;kO
zUKeo>l(Yq2Okjuj7BtA=0rD+meNu}Uw8Z5Hty-vN{Qv(Y3#e`b`w!c?2++{hODk}n
z60+{%yboxk&qqbzg)Ynr#9D<G(DW~;x5)3)37!^~WQ0r$TmSw4e*&lxYz68Zclv<F
zp<+}dUP#`AIuo%T0+bt|>mlyFILU^P_k^syXgvxFFHnTRGDMz7H?PKB<O~66-+|%_
zwA_a#`9UA#if+~ocaUNYGe1Njublv0ods%&6TKEl2DBUk`&uAIkQ98~1n3w$@ahA^
zx`{K;)d$Bxl{09$19aWQcGTq#djDQ71*rh7KLFRtpmh^QphN;&H<1T5s2`*ZWDs=S
zL_MlO8vkDAf>c1(O@NvOPT*AI0-F4Ttiu6~uSvXM`~UAhXgEvaWgFNU=(-8ed7cj7
z6(8zQ3%Nl0K^8(6PW<|VSUBMbUODjsYykN3BnRTxO>F&%vy_>IHa-n5yF8)mF<|Q_
zJVEOxd_e0bP}gHbfto$oW6K_t#}Ml$9)Wx&4<0XuWt0zp|NZyuJor)>+xiI+=u!#C
zPNek{?|#4*Re%>zfI{TY%WJ>?|9`QC0W>U*w0_#~Z7^t`d-EF$ltzvQ=wO5oi1MTJ
zW%E%+kAp8*O27Jat2ZBH_60Rt!5hc?dRa6<I|jh(EkV~df`%x--G9jy{QND4K-c1S
zgKlB7JjdU52E^mvR-+>4sd>(qfBipS#^aur|I2v57n5}U^XYv4U%<DsMg?MkNAg>c
z9iTA;AIA5fDc{eaJ9wEPSIh1&s9<17>ty%nt<h)l=w{`=2_0y4U;rKI1{rAeIQSYg
z!^qgdRr(54%1HTietWU^3aIRGQ2`xt4O;}i2-G`3J>(kU|K<lDTtJ=xEy8e7k@U1Y
z$KP%OTK;T#yvW&?IY)(KAILGjouIMy<hN;#ouv#O-K@1Ym>4{JLv)$2yXPfn|2MdN
zg?Jx)=iM=I7=Xu8L6<AQ#zR9?z%FOL^8f!%kX31&93H(P8X$j*-(Z5DKihc|Jdpd4
zAKBk8L5G8Y?eVcZUMz;)GO#c9gN#P<1?Y})*6r7!zCeTr4*!7mVEcA{1+B=C@&rve
zfNqU@;eYx6|6L%1(>et_dTYRLPQDI}E2#gly4$Do8)!S2=DQa>mqA@E&`{#1zyJP&
z&Xa~;-UPa|>9a@k8x4<c{cbaqR4f6y_R&eer#n@^quW=)t5-w;bZl1}=mu~X{%zTO
z9-7BIJHPwzuYc#sc-7PLY<a#<XD)QPfitHM<8z<hWG?860|8L-djd^<b3jY)drLrd
z)%O?iEuhp?1L8aab(`Zaf%q;e5=g68&Vn?cU+Lh$0Gh=BS9|aO3%qVd3SY}pWnv&n
z5AeN(p!J6D|ATMP<nZVW74TtB1y6Q>E-C=sJ1OwucJu%Lue;#m>pq>oLHE{OeC^SB
z@5T9xpgmm>$ATNSFV;4Lrj-7HhCaae+iBi=vFal7z6&2vR($kgDu&MD=Kud+%7gCX
z%>483{{&cn6t*4<bhbCB=fu&i=g}R+(fYR3)}veAr#oA~t5-+M!#Z1nzug10MxZlW
zz_S}P#{}9^5DXG&KEi>t;2+v<^#$EK)%h7*zDxnP#+?3pH2>h^Z`%&i(|IwC|NWCR
zSN``0d^!(!G(Y^1#{d3p8vpy-X)gTvyk<tAdCPoTI|yy+X2itc!+4Ni9=wX&qxpb9
znj`=1gK7Nv7t$R0GY+IV@+VvX>AaD~pLsNmKmSx3f9BOR7yiV%Y5Zl^(_Hw=?x*o5
zo=xK~JD<j1c07&${<Sn0{`>dR`0t-f<G+6lr1xSPf7a<V7yhKnX^#9?PJx6jrSWH7
zh6uUvU%8a#$e$0DbOo{Cl8zur7m#cCvkpVl^Iv%YGUiem$SD3R4?QeT@VA1tXQc7x
zAMpVBzxW2I68ew^Qt828_u$(he*Tsi&^;ym`%E|*pB-ReU}*dY8ufSJpL)!Jf7>??
z#t$C7g^V7SpZHshAqq=47;&p)0;}YNsbs>fk{PV>KIq;T{(U7J%(zvufK_gVsbs;e
zk`=778>W&Kw@Nm!%0!q-Hry)N!79yRD%o+X<N&J#-7N12@)4f!<OHjH4Bqs+uY`jW
zx0zgEm7p`k!De#dR>=)k32Og<RdVB2$>U-9sU#DuiU+qUUXUthuqs~Ms`x;vWF7hU
z`Ec+xJ_M(qpP=-^KlLF0wv!%=C(<T(SRUnXQvw|npn24%+a6q)`gWHK`0%fP>($F*
z<jHu{*E(OK+~2n|Ux0s`GpA2)HkW62J)|c84k}77f{W6UTHkKa-X+koLC}6CAI9&H
z+bIzjGJ!TByyQL$YPc|Xg6>{@=hONBzrgDy;B|t`;3XON{|k5^7bz`k!E1-AIXt^f
zRD2lUqnXzG>)(HHedq~V9rMcb;yX~QVEGx)o@vk>grK$Yw@VX1Ml;?A%{gj*dzp>A
zKOSss=cgAgzyAIA=sf<?6}({$G`|PFSu+-F60~@0Q3Rc&-EE=*Qds=||9`^+h9_Uf
z{Q+4961?@|-%qe9ulo_@Dd;>q!~dY|Z63{-$H%>h`3%wlx)1gMf6Hc2_qFr=i{lBP
z6F^Kr^F}XbfB6Twt8EcTvKw@iA4v6o=xtr{pw0&3yth&@$o-5DAV=akFo5;HzV)Kz
z+rR%W=W>9?$PkqizdYoAOz<95@Gc~98?x~YXjTrX0tTI+_9EyTsPziI<&nRo5j>FE
z47$+DqkA&w)D7@f&8eWWyxTj$qq{o8qq7%ux2H$vUhu&;mOuGh%0SY+z6)FppZN5a
zHh6UQ8h|zqYF+@H<pr8OJMIcP8ifILc!OqW1L7PI(D@&rBR*dE9s`{o(hRcDr+fDe
zP+i<z+TmmQqa@9v6MT5vYZGvK_{0yt$Nd=S4tMAoA0C~h9UjeKg`mCapwr$wEsvLI
zdUS)uKr5ISA9+}oPACQ6KN1%LY5<gWygm)9A3eHV8^A|;dT1W==mg*7?b-R=^WcA$
z7mc8p>TCs_+vd}0!M~05#2qFE(5+5iLD$ppGcYjx7d5>DYAr$R0&SdJ!^*$_F|HGQ
z&X7-Xg@VU%@P(|PE$%OLA!dTy=>xjg2CN9QKOGcqtp`e2JenC8`M0sgLanl7W?;x-
z@aWzOI@bt%mZ?v7FXXy$u%#fmUXTktx@|As2A@a=QVFu_zvu#xK<Dv@D38wC1>gg*
zzJMaEc`wKSh7#3%pe^kGMJL{7V({s9T>xHw?7G0W^*{-iXR`()e@iGxdFNixNl6~v
zdqD<+j?jS~_m&Ql?A{ALO$l)vj5|aW<fIo0puEt%7v$L&B49T7yd$sfk^~N~ZkvP`
z{XamN#dQJbRs>M!6|*ofcs8>$dUQ_(+3C~y&$GLh;f2JPf8cGiVQiqB2|5Z5WF+XI
zG|x_U{ua;)<sRK&AHoi(n*?f+K#q7qa&Zw@w6*~x#QLJ?)4%^7-C!4aHXjl2>Samr
zuxtgTZT=R}G7MNg=mzJCmujFrS-rMLZZR>u`2G#-pqB3tF#|a!h8Mvfq51kYD=3Za
z1?PlL@Ig`@ovtf9dRgV=KxxHwgU4}K@Wkbd4Kbi%!NTy{i*27ldGR>tYCq75*-qB0
zH<=jzUugcp#^2__3i37Rf^gRNH$nHwwOfEXM4hZJ!8~^fk51NSU}ihyu13}c5Z(!h
zvP%%2259V~ll2UQ*8t(YgYYImcnuI9c)L$0YZZj|0U{Ry=DB-#bg~A5ne7Fj(cMng
zW(aQsgjWmYaWH@`(JY7X96)KJleG}Sy8w~P2K5QMYj=Pm1Dc|~gB;ww7u5Gc5`7I4
z?X~s3$;9x2@BP33FB?I%8|tY%%pgbhrrrQuWa}6MxyLs4ut%@0C`gybS4ebi25IcI
zZIoeRc(LR?G`hlBa70&u3|e$CM#G|u{S#Vrsoj7_*HUJ9bUA=JnccAHvI6tK(Pa*1
z!lLUVs2A7W4vj8lh#WM!WFb6gblF3A(CE4d(FcvL(-0msx|V`@;OJTeX2PQD3WNuZ
zu5(ZxBuY*|c+luN1mQuWYY(Vfh#Fm>4kGASC~(mQtG}{6dTke6XJUAf{Py4fmyV#J
zjh7%+3uv3jeGn_<52%ZC{KciWp!`?6;N>ikq9Y)w|DY|ryFe^%P>*s0hy}W^;>9u$
ztN%Ah<Np^kK^$(7dHrwy{eRu}q5~uV+9>=Y50pNZgGNXXgNXA?|Np-P6L!r1|G!)e
z5?c%sI|(9gf(Q|igg1!zzyvx!1$-aU0mm@V9(K>pFQK3nFBPB^*jb|j>hcAofmX_g
zboi)*yL9-dgdx?cEh?b=XL!KlxI6gp5q?2->uDz#7#R55l0j$GgX=NaJvsl`L6<65
zfDWi{2OVAuzRg*kpMk;S;A0lhN(AP2pt8|L#lVB{Fz93xXupeJkO9;^^02&7`o*(*
zjS8q{_wC-I0@~vRx(zkb2efC_r+1GEXmzS%cZ&+h1s=_{0t}rkU@`s{F9FbAy?>y!
zpP>@qTjvrynvW`YHXjAmtUf9kY5W=~DhZDKf~g-oE#H-}dRpEs-Qw9@qLSgMU80fz
za*p9`&u-{S<AeWLK`ZSAKv$a>9sn^Fzyao>qQSr2MI{6zVgPE<cOK>6_Qs?67$bix
zD<9~hjSv+N&?r)XPj`=s21rl0kBWwe<*yQBcz>CHyOY2tegQ_0=0g(TL!S;lVDVu*
z@rhrM;S;}r<Bw1Lf({%Wme)(Kf!qVy(E(Z|(_YKVz)&pWaqt0)2jdMN%L64G9-S>J
zpncs9H7a2Yj-BuMTXu3XFn~`=2Hnx**znhZzx@@<|NlEcvzRWOFORvX*u!o`QGncg
z)UBi9(aE9$YGb#6_riCxJ~_q&x>L@c!GqtG_54v#k>R4^fM}96)Cvjkx8DZs2HEB+
z<k2gdEsu0KN!kR^P(m8NK=cQX=GOwC6FoFQj^-DXVFaCO_Tdx1fcFp3e3)y?fBsg`
zVh{f9t^#TNA_qO1k4k`)dN8+u!w!@%EOk^$`#iemsDR=E6ds_?0mx7f&<^;+9?ff1
zKoKDT*4J(6!FU5C{=%cXMFkvX$00PR^#D2-l3$P!6xAM`jsl=K1Q`k{mswx9zy9~X
zp++T~fxpFv0~C>SR6tEPPwP1<pab0aTb6-pv2KXNJem(ncyv00Z2{Tt(dqmFWFw>&
zbN=Dj3`wJmo}Cb5Ji7OQJpi%m_A5{^0m=uU7J@9eq&oiM=&OJKyIoWQ9IYXm`P&zR
z3iobE9z+`6=>~01>UL4_@Mt^&%Eu@p87>T<M3f8)<?J7y_ys~i+*pn@evKn({2FIJ
z@kgFc<Jb7~i9hntC;rH<pZH@Artxc>0f~R&k2sgcuXlpKOOF?HYM;i1G=7nb{DQ$B
zKrz)42A+v@0m;1o25Jqb@#~%A?~?id?>~R5*#Ce3KY8%$8~}%|vWtp>$8qN$piuwh
z!LN1T6ThJIhnJx9!TIGu4sr&$&-=%Vi?9FvPvb{e^b&NUD%9-Y7vPHsK*<H9+WCP;
zZ}A8IS%>&tFScCbZ@s|?T4Jvk{DXhi0e;tmpu264GJ=lMjz8#e-1!CAYJNfI2OgcD
zLC$ZDgLJ9D?$<c=5_ACzwEThD_XDqe!VD1mULfpaU;x<{i(%jEK5)5+NbN5`^##Zp
za5#M87YzOZa#IVafPZ-u7Oo(l{z&5w=ap7qf(4SG_m7uXz|#v3V4(+}_ywYW`1EFj
zf+QG3c)xfN{R|}(ANX{>emNhk36xnt`hvmwUO@FhQ%4%V#-TKR4On^rrHvyv(!{~)
z`JmJTN<}aJKK}Rr^#o`<g3R@P0m|r~_+ywq@yB?Bjx`5GFUaLm;Q0nnI3TNwVE)7(
zfuioy@Bc{mF*Vev*n=GH4NAYxANX4?gQWT2U-IY<Wk}=KJH_91;2$W_?fQqD=%DG%
zL-7Jqk^^1G11gVvdbfc0kbsgWs26we0gERyC<k`Bs6>GF>m6@V0Ue_VN;V$7A`YO!
zQ36y#fI53Vy*d{>yGuDhOT9T><n92q=xaF`_*<Glox5I09pq~G7ChehS{YoFfeuy&
zo#yA+e3X%2(Cvdq=N1*v(TzTq860K4Y5W4!;NtNUzW_5R-Z?zFA@cm1kZR7udJEV=
zr5nMk$3Q1LmbihMbuKC#ATvScl<xqiGml=@y+TY3phD3BR3(7wP0)@bP>a0z!Jp<6
zOyCghXi)))cyzNeA7lcT?VtBEF&O>_`M$G91vK>HaU4?gfJ34A0Ha4I<BPb*ph_FE
zg#~<8=Zk;;{=azf3?d4yoj|2n)}Md>4gbGjcnT7CQ7Hf`HU9%C=psP7JYSf+1j#`{
z3$!pFq)h;<qDH0QMH|STZm8!Gov(V(T8i#H;IQ-1-UE(A4^UTj+7nFE7J!P<?iR3O
zpYAmf#h_^tPs^kHEl-(1ccguLtpv^Y9^K&*paz0hCySA1^Dzz|%N!K}{ua<ehfj|D
z0=^s|(v{(b&O?wdU@kjQ3Oe|#L=1FXD}T!eP_1wr;wMn3y>NR28tnn+yEJ}*SWr54
z1)Y=$s_}g}_ywasykr6Iy@8C!gR3oO7Zr^(egTjYm{Jc8P`Uf^Cg{EyQ2K?agVa8+
zFGJ^*LHk_}K41YIwq)>nAH015YD0lWA3QtndhCK7Q|hVt)~E9Y_?~qB^@lumg+c%;
zXhCO-E+~*er#J<&F)%pp105#=N^rqXz<mNw#$z764icaF^XGu8WsmMDDxjLqm+>zs
zJAo1nhzs(*XJ;trNW@qMenE&^JuF}Iw;Tg!6XzEmoiE`I;_}dZ;c@T<vj@mEy`lO(
zn!h}nf5q{)MSwzd*FSJS{=d9O>jnN6SC9~-XaE1dyieyZ55;4kHkU`|caMwjJ$h~G
zJq|u+@nQTA3760O`JMuw`STS$nhzOxG#@nh%%AW0fnPA`0>7Zw1AalL51_`?O_1*9
z=l?u<Me02cK4SLh^$}(8Vf^J``MreyGk?CON4KYdN2iwnzo3>!FN=d`ugh`Jio_BD
zkIwg?CesTMaEfJ70Ub|$9MtN#;oG?d+*(NE&pGS}3Ib3xOaN8>pr#<aRRA8hc=`SR
z{}&e@{rms&K6smu0|U5q=4$vKwC)UaiVefdNYK8P3E)P7B_wC^H}!q_|NrGP$mSbR
zcLg-qv<2J>_5kfi2A%u>nrbO{Vfp|$+5U%(BgBDvuH7w={0?npgQ5_W|3Oj6zikhs
zoak%;`vugl0k^mLmwdPIIQY!MgMZCG3y*{UEkI=rsGbECZ6J?&cK-J4{N~WH2i$T3
zyT%oC>t}C^iUX)647%qUG%?h>MkN5W7!g$T`gE=VOZs$zmSG&a2bz-y?Lq*Z6yw<|
z!sgR?&8PGD3(qo8(YHm#17uG39<Ua}OD}>RfD$O=1pXq>=qOam$MSs%>x&X-z6F(0
z;MqM$Fukz3j|dpY&ZD3<8ML>~#LU3p*!-7~zhxUJl$!T|Lx6$5B?)Rc$eS-}Kmpt7
zqEZ1X#5O`@K^B2B2dKda3LFNIYmc|6aDbZMpghpIM+MX-dLi`)+<R~Jg=z#TKyrpR
zcu;4L3Rpj)C{%$8gN;WB{{;;cbk~52-2eP7??HBUyK{VNSk1t|z{1~h4<vBhMWp}~
zxjxXnh@c1ub*4aK9-WYFmcEEVGSL1(a3Vr-R2$eD&>HscDJl@3Zh>si?6!C@^Y%Z;
z2(SgzjbH_xEh?Y@Lo&n=YzV|YBw;QlaI2M7NSKMir*{oR7qq|U)A{ZbC@X=S`-xwG
z^_vi=aU|FR3CV(4peC3=510qKOrp0~;1j<9q(BB$#QcKHFT77NGI;dv0Vnwvb|6kS
zv?6K!U&8vr=l(y?4J?p)*r)UJ%jC~sLqV+=0q-9#L%>^i92h(_KY*GM;64NRXrdRN
z3P8yc(l>co_6am=0NO9uy9ZoO!W6$aT>x4R3+b!Dx-veU$3RzC9sI}g^7u!PMh6B^
zz6WhmWO$hZIvW(epA94qE)PH(B*HpeRP0|md;&E_q4%@A`27gEDg<A((<%fyx%b6a
z(EK$h16kZfq<L`hBMUkby;+};zf~ACE+KLE-~X4K;Fc)E3vLhxbTKoeJbm%|&cFXJ
z%i;ShU%bBa?>}-1ddY^eUggDUkop<mMjL27kLSK0kkY)~qnC#PG^yA=4|HlOX!+-2
z1_p*5p!&wu@Ed3o=JcQc|G(%4>3;(`!Ul9+YBh*|6v591@j++wLERS(;{OD-HNown
z7v3QLB?R9Z#9s{_qxtF4`RX%&z7(|YEx|7s`NE^S=!ZvV;SUeX%cYNB3V=2kzr6YH
zzelgF5jPXVi?z4@{r9lE=)v!H(I@+p#LGvZ<-NVOY8*@qFDBml_y5J2yWr;cS#az4
z{*8bCUmo}bT7!M~Wjbg)w)61IjZk{?r+@!nJ_ix+pdvv~Is_!>{`uekm$@LKA2hVw
zdH7`yi1YvBzyB{izWn?DauIl_{qV~Ms4i_NZ2+Zbe*O3V<?gSb)NuHv22?N>WVGQo
zP_qP5Uw{sB`x6SC>al@tbE;9{F#O-J?+B<w;BNsb?>xc3?Ns+PP`%*FzwLxi=X1x-
z125LU1tobG6{PtbZlw8~7yIx0`;UHpXb9Lcmu~RL5z^?AiwcL~0hi7T-!E8R;BVsn
z_V2$7<0bxWCtdlso%HPd^TL^cUBO_xCOC$GoeH~@32qIF*P4I*=WqG-^&jYH%oELr
z7#%wgfDUkY0NMcyYOBNh*QF@l`EdK+f5>_RSHrj9i?JHtfQDQ;L{yMG0x9A_%a}mh
zD_XymBzScG_2~TU*m<SpQmL#*cO8dEx9Od&Obnpb1@DVp*TLm~OE<Vuxc@@xHYf$@
zv04c+F;oZeZ*x_!`On`1+TR80*8X7zm5ze043Kr`pZEoRIY6~CsMdfxo4+*^G%V0~
z1mrrG&KF370;TJ~_f0{D#ROj5y$dexTvR{>C1{aq>w%J<7vZ2(4yz`>&AQI}pv6@Q
zFL-Z39Qzeqv^#V7bZ-ES&^b0fV_;yA;BN&V%iYY(2%6<f03EmC;9>2el2O76>JDXq
zsu2fR6$2{rSv;EA8DDgOijdA@pxq$};7J-66^$3dt3iz!MD4&0YGaqOzNo$dY8KRh
zPD=g%!VjzyG{6ArKlm_$!bU*!1`nuK5Re7Y;JW_5PbcK86`xK>&ks~!%>bot29OTH
z5S4&W{DLtm5iicd>MjmY#_5K3H9A|sy$Fztp^byJ><kQ`P6fyiP*2bUbQVC%ZqS<R
zW>*Hr1{)QIQd!ULT2NGf+zgBA^H(9ER}Wr0`~HRgO-NMx3xFIf2#y6o9~BAy?x}1b
zhY6&B<0VH0yjRHM6Te^z*rhotpu2!zjktrL7BOh>(!;t$rGUR>CPc4`O2jA7En)$n
zo+skg0MMSB3{Wc+<a8t-1+#&Avd0*GEK5`r_*+3s%^}f+Xj~+4fubZvCBvsXMJ0iM
zTd9I)=UrdTr;xq`i$lXdM*fy=P`3-I69h^=puRJtp>m)^6MiWKJE*(SeuN7&So{9P
z=j)(K3E6N^EBb&Z<55ui8gzI*sCfvg_+h4bTHYx!11&b{Jct;NM4CrEBmf#v{lqWm
z`Qa14pd+|Qf8e9}*n{x~s6hs5tsZLux2qVzPH$yk1D&f>$D#tV`2+Z<mCjrNpI+#R
zN4>KCYnT{7NeAQ#Q0htJ&pF1g=?cCa0Ol%CkgC04z5ee%|F$h)(~%6|Tf@ZQ(D3g+
zf6Eni2GBWBpfz_My^xLqBu9e|*#-sgOGQ=&hO`MD#}9z&OL%|IqgV9gYH(@+-K6&p
z)RF=9FTt6b17^Y@q&wt}xhgPx;umxU5xyKRFMzkDgZi5_Djp!WLKCzT=+2{FNP2&v
zeh@ShRHNbmQosw&c<e8ju7cVR9@es)8z7+o8d?B_0)LA*s5I!j{~{h*I@p67%%D=h
znZv`HwPHPJ*f>VTfWM^`BxB9mwt<O(zoi1g`MDm%`3&M5cToX1dO*bo2dKz!01+0T
zyEniy#~^VFkdOyl2r?Uul;B>hyb4N5A)wQN1Uy<Vf##f<7(p=(PJ-Q2z&)BY{(MB2
z2IP}8{`@`QK^BkBDc}aAN3W>81S9y69nfG9C{29&%wNa)XdTEmutp^)0YG{NpacLi
z2;?$RP{S2u-7e53ARo|LkN5vCz!HK_Z;na;sKWVg4GL!$6%U`z_n?NI2Pil}-V1oK
zWIrS5IH(tEKuUURR6Jfxf{L61iFCWDSU@#dAT;Gem6U^&^wy|YyoiO0Oa+N_gJSf!
ziwbC$5d$b{p>f{;>X>ytf8hXEgvj$Hpn1>k8WjU@Ls1XJYu0D<=<Wf}$ndx5u!7c7
zyDA`O3(z8)EuccF^(23b3L^u!84n5#P)Y}dCG<{~_x~?~Lmd=qpn49P8<{}eCa@TE
z_{)Zgzx6ExXsj6?XFZT^B~r9|^vZ5n0bX?nY1@Ow&_MmGH2!?hir88Sa7Oju&pQO#
z#toA3==K!=jj(}S28!K(;EQiMdmufIPDsy{Uvmq%tH7`6DgZj$v*i(}nuhitz_IJm
zD{H<2lqCNBzX%#>19jA1ZUIe;f!e#SEl>Dc@<DgigDP?+{uWhG5F)u7mMCDJhov0;
zZ5M3*Lvuf9IS{|=A&*|!v&%sj;ywQ_a@eCgR08a`W3CEJpcVkAP(q|?BpX0p0Qu3Q
z(^UYZ5bSqYBJXsSfH@izK%k~ZE(@qceg|3&46>#L9Mh1Z<#jQCYbvN!z7&+lKy_|7
zh^KxDl;a=;3V+Mi-=GTspykYq(-;2zf4LacCjhs{L3IlFfUJNQ8$mZ66hX(oUMvQw
zGeuGdu@^Lw+IpZw2vpF4lMX0Dfp6adS3<s^Yajl615KPhe=*_WzyB}aL(X3T%eorA
zeSH_&FK`B#?+Nd>cyvb#fafGT!0WY~IbIfl`Y01XrLzP7wqwu>5WpetatIbl9=)>O
z%MdXDD+Jyj0H<S6ARlv8VC07u{NMmbiHKToaRO5J@+;Wm3?ALi0^b}26!=?=z<qPb
z*eWPX8~%U6e+?9_&^A!#u^0KEaE9Jq8vW+q|8EYFEc`7uK`FA^!NH^3)^0Uu=(m8w
z!}4DV?~4PMz|D<T$VjiV1t?#EBfs@Pi5Q|l6g{yDq>J_CN)QFf*r414(gsgZU=M;K
z0F-+`NewyY`~sDIAW2X*IsnN=Tfl`VNCK3VJz7teU@a6c!h#l59<JZT$ndfc6c330
zZZE|9FDCDTl$8dc@{!}^MR4$e>al7Gq!uNA%W-gDmYwnCKF~EX6F{}NM|Y?I=yH{V
zzgR%4zM4RbDm}V=IY398YX0)*yykK69}8%Gb`xlT->X+dAJnvv1uehpeD>lNDA2n@
z8NeyZhw&98J$ZD7LaW=C6_Cy-q(24Cu`gAAK>P8~lJezs@J1Ad7rW1b;uI3fFAx0!
zciln#+Qn!8{eM}8;7<nen?Ogiwq7bx0G+)O2zCglxer<#4{IqwJmJ~PA_8)_2k7cY
z(Apx{`may?0vw<C1spiQv+B(UK{Md+_Rx*e2QQ8P|Nrl5_zhHRDWNsZKm)lxo$p^n
zoC7(zmcbJ=(D4BjHoEZk2xwTGM+HQJ=OT`PZtVlv;Q?xMIsEXkd|Y}5RMoJ)_;mK)
zfA3xqJ)h1}NLYf_lfT>oiY`bS=Vklv|NmdiKJ)MY%W2>{#31#sAt-Y}>S}O#2P(Eb
zx=STs#TqEheFBwTAO<M$9fKuN&{!lWy~E3Hb5LIIg;dv&vb*!&|BIk95tK$>N`RzW
zPnNX8%3#d;3Y3LF`2wy76xJ`UpZ)j$#io=0{=c|;`rrSTTfY7O|6=h;NYDH6a|kW`
z0zxN3X$vUb2&FGU)m?$on_m3;|MCKec<=($OMs5=fVQqf&U*)KbOjwc>@NV?_tWVw
z0Y3BnxVs9d@Zi^E_h>y?p$WR&0`2g3P=(BZeE7Qp=pJzo(82Etx*pA!7>>Jxm3Vx=
z<pH`|u`^uaFrs}8+Q|p8-=i~J;JCXC*f!{C^B%32D)caqn+NSSN3l`jFg*Que7|+f
zT|)P`J6I9O%)`hd1``nWfvp3L4#5w%Z@pBZfoU74&x>Lk=x}=mkTr;N?ZX8QPk`iO
z$8baNY8cSvAE2v^J3%`-B)Wxsy478}%~~&cLbe-~s7UZnJ>b!NfZ3y$N5j+d7=PO&
z$d00FK2ObKpbbTyjORTqzn7;$HxW5=f|h=8!1i%4f;SQAF+$GC+Xh;!-R;T%nr2}F
zZIJFR<p3wh7dhwt{ReG5>HG%j2{#{S292j6`tL7m7C_1s$W|K2wx!oSNbzI&u}lgi
z2?{t456}ru&;JWJc87we1UbNN@&xU5^k977dZ|RnqnmZ*5+(+Z=HsCKpiCX^|3Q<R
zAWOmSL9+SMSy21mr}HbQ%XRTB=rphQ^Fc#f#~r~w0huKli!e(7Y8Kd>7gNrH`~})o
z1M-*VJCEk$%r6zdi<d$D7Y2`RQAJd}FQ5PW|9=7`EMBxC+r-}jULV;l`hGFo<sjQ$
zI{yEUKHlWh?atxR%c?pXtWv?F)BS;`<&P2$pU&ei6Hfm7kCNIz>x=ofo%85?3K`~s
zE-`L=16hN%6*SD)dCsGADyYc6oh#sQ;2k^C$PZ}Qam%F=mF8ED4Zn2x+aH4Z%e}TM
z8JQUPw_Wl`W|{86_~ZWra68DQySL=;|NpM7C;8_e;5>G$HUIDb{|ttgTn+#8Z#(45
zzwJB!wz(iNPw+Klpi3=53x+`pGCME$c7AMr!037Kp@K)}+yIc+!3PGOod-NRZ#eL8
zyVv{-bO52p!Dpr(opTdFM?0VPIQYQuz-t!J35=a5njf?Ka31jB{Ncg*!AJ3e59bLF
z{#_poKw|v6J{W=|_;-CU_2B&A*?HjR)B6v;9bw{c0j)W``CvC_`r_t+n-6d6K4fEJ
zxc!p9X(2NM!`&NqZ@gybmj^RCPc%Q^=Wp?3W?%rFIot@EQ0xU?`0UZy>H%_YFYA<<
zObp-x+oQA90kri{3@pR1*$TRZG>t!>brKsB1HWb~=yGhwhX2g`Es1QPb8eSHg6#=^
z$3)NsO~Zf2Qb9-1lF9$|{4M7m|NHOQe1wsI+v%I2mGzL-XrRFJQ9R&r@R<T=J92kx
z1jr2sA8B}SegLiM2JtvAcpiLU;L$x59GtM=IQYmA6f}k&oEJR0r-FhK#5HYx#OQJG
zk*Npgh5H{pI$JG3?r*LFbztF<<<t4iqxp@1OXqVB#S37Yd#8eYcH2h9gY(!6)3pEp
z8}@?Ym!Y#2w4XU5iof*$GXn!8A?W$^?rr${|G!J;BM<JWAoD%IQ=TB7c!Ip4_{pPt
zs{zR2-Myd?^5OjC(mfYskSAE-e+JOVEaY17gU>X46hC$Lf>yb7p7-DcX$6NsXDi4K
z5B^=B3|u<r_JB+~_{;#J02&OR3_T7$GlU31z5mIy`57ZPadCd)-?kOx2T#zs3R7qN
z{r`U#Xl0;7$JPaZ|Nr+q_(H+4*M!@(^@$_D{}q>BzyGeFA<ToIcx(Rohrh=kG{bCp
zk-ygs6t(=@dguN9|KIVzOIF9`hm4jV`TO};7#MbeYM9oO-QZy2_c-N|e6jUF9ar-U
zMvoaDy&+7DuB}fhSY2CAmMA-Fe(~sa0txW<6@$!fe#7XS{KTs_M1c`H&u@6L<+evJ
zI4ApbzUQBM5OfM;=hO**L0yPnFJw=E!wr-oJ-Wg7)OvJ+Q>2IWUQo*AZ~4i<!0<xt
zD5$3ay1?mD_g+wfghU&I<9^UVAg%xTryk%u_R{#z|Nn-UT)JCPR4_6yFu1lJfG838
z^Z!3oui+)f{h-dx%Rj&W{|7IHf4vw&?d6weXny#i`6N?EZ{^?r|6i^{tmnCTpy4+o
zs71nX^C7>>joZ53%-~$vT>R(%|GT$db3*-n_tyQFcW>~wfsW~Dx#ZEy`usO&9!&HJ
zh~jrS#J}yfNAFZndH@Y8bhd&L3pAWM=YoV^TmnsXpe{>(2kOhBUKZN07gRPf@V5qo
zRzx=ZXXI}IpJKG_Hz-4XL}W;hgAWxznX>bjN9SH}N(N`h6OgP1PM@G$=yC9o0YnIz
zB0m^<fN~|_4B3<q3V|EYT;_2cT#|qS{}{L^GB^%SP@u%c-vZk8{n`Z*5sctM7~B+x
z2rz(S0U9~+zu*xD76#2zd4rqwkoG^Q_Jn3$pU(f_dGDE^yM#p!g6hBjFaGQYH3K0h
zc?<Y-{_g-6{4Z2N35xH}|Nr2)asLI58y^tG?{es6Ja{e+Tu-_hK5=aL&*;cM<%nbR
z5w@2?(0=ya8?LQS`1|<4cO?C1;%{a7|Np;l@*l^>KVKLb82I~`L1T2idqHIoXsf7-
zDk!0YQ@Bs(uYI6VH=oYEprYi(&;9@YyL3MI4huR+0ma{v2<q3%fU9f=2FHdUjQp)0
z@Od?l<b#fyXFQq@FgE{W<nL2u1|{+*b)w%|L3vuCgvSw<7hMz>_k*Irqc?y_^Sf*7
zNf&;P^N!6wlj{TxFF7{;1Rb2mKmU+NZ-@Z1NAn@3m!1$yAmQ8kjlb^&XyQ2enrG()
z*Ors~EuLWRR#4&R(R_%}qw_=Sw@ML@)^8r)FYE)wuLr;9F>p!YV)>B2_t)?L{~a~Y
zfUXkz4=q7nJ_GeR!S!;>?Gky9Zqcc;L3Q?Fq*TMdjfJVB6?AVR|F+wZOphp&J-S;#
z$<s&in8(4#8lK?%2+GT#D!_;Hm=CPVd0+@G|L=J~Dg$tp!@ujBfe+^~5B^=>3_UoH
zd33iz3)*j{%?}to4n8miRTwM@p!fn8=#hww8VAjy9?+t^8=S~JAldiDgCqa{ztjUK
z5Qdi9{4JnvyKi?Y18D!N0H~n!v~*FCD7NwJ=25v_E8qd@-aYq$)Mp-@Q^AEGq{99$
zcsp0XryE?;d2~Z$y1^B;XD4Xmc{gjyEKq>m=HJF6;R%{T>);XSZUwcMKuz5LpwX~x
zt)Q|CdVo8a?Ez^N7~V!S3u-44Y8F)g1C7ao{RwUsw7&fQ|Nl$S^_JlHJJveq@Bjad
zFLOY3GU(g~q;m6hA80)?xEz1U4wZkw4a#{*kR%40uTMS+Hm9M6<G(@Y`BLuQ%KskC
zFBvV*)x5F%&fl^JG+CYe-?KM>(MJ=s_=~>}biT6(<FA(se}c{vX+Ff{*zkkNgWu%>
z^m1fyzHNTN*a;4gm!R9k5bgCHpsWDRB>XLp|NQ?CIt_{8<$iDx@4)c=9;kX_X+2qz
z>)LX%G@$ilos>uNNsnF^j{mQ@(<Xp+2{pfGEMaZ1Fev%d`2k!gasJ?M5&rrAf9tmr
z_vUwu9?91{nh!C1Bp>%+ywLjJgWvzc%P-LJiOv(?!C1}@{4EcE{Qv*@479#*v3%yp
z@Bam4=N-fUua|*Uz25WU&AxyCU#<ep4|X1Yx%t+=|95Y^TmYeF-um}{f@8Qx=S9#K
z`G24t2H@=lkj8U~3U~)_XNZbN=cfa&klW2IDl?cs=V-Q^EKz8F>Dcg7m%sfU$ckQD
z)$fc9psk<DEdAiN^8}Y}7Zn#!^*R3l=OI_aw}vMTZ}V?E=)%A4w+sKaTcDO%Cum(t
z=Lz4=pP)t>w4vPj)u&TN#pB=u1BU}|SrCnC&&~sm{M(K;KV=7vD}k=qg=9KINK+Zq
zCI+>WFW_w_Ur6H*xX}EFk-z0ABWRd9oHg|eBg0-$)PCX@;QjHNkpZ%>IYjgfn5}n;
zzX^2SR_CYYNBsOP%NZFMz{hBw16Qc9c?j@nl(t!YkSuW?bQq}uznG7T0PHCFH2!?v
z?BAgL&;wrH*zlW~zhxKrI*1fdC_Ult0G)T#@Ef^}Y<CmVM)ueZnpgt0D1ADAI`D7%
z>!El9R4IFaYGlxWKj#ULgO4;oE!fV(potd_56;V=<7z?a85EEn{JTCIcyJyDg&(MY
z0pc5aa31ymZJp=e_1Xj!lKi_qn?lO4!=MuZa#Q~Q?{rbo0AE}InzQ!oF5`gChr9>Z
zmajpz<+Gij+VcI2b30IK%lDx5E-!xW1<kF2R=$9C@*185rHI|&b{D8o<!bnr^U%we
ze?ceFb=Ro4fIBSU78yk5JgC<NN;kWi85kH|f@(bQQt#J0Ak=BdxPU{$Uq*1tli%gl
zOLIj1+x+Z9^EoDmjuI8mmqDNrMt;4E{O$jk7#Lbkdi1jPegfCrlRy-|%OMB;ZErzm
ze*}P*8H1L%fewmx=*&?Gc+vd+|Nobu75fnTcIbgF)dWopxpY4BJosDzbPk6^2Wasu
z=RMG<6KH4>5oIpjF)A7!iuXJZJ}?AL#(<Ytfg=>u^7rBV2Rbv;0Ce$1=XDQ7@cByt
zo(G?6xOB#-#6YDvKvj-`=fUR&KAitRY(sEW#iHWDzw4ceBP8~|nR*_4VCutp%(a(A
z*t7E^c=~uBsFm;7>+s+6;7bKa^Bz=E@V8!LU|?we@u!9ZbaBUJ1_sbF#vDeE<Wr8C
zS3oy}H2-4c?>h-?8wh`MQOQGY8Tcr|S_XwoE}F+%5Ab^&Z~l>7Ct&!^7St+m;GciY
zqql^Q*`xUwli?+YmbX5g-}$E=@?g9M-nw0)k^m0h7vXzAl_h9dKsRLGA2iqvPPW!H
zDgq^}FVc2`Ml>Pi4$`WL7El+i@d&8ELJWKy2G<9U4L=$ATa5ny|L?-TEkq^H@xUuq
z$L2?jE|!P*`$7B1!7Yu}OWmMdK_1sUl0PAJQcBoBeUb`J*Op8CEzY0;SIr|Hy>1{u
z{=P%t?hv%2Qlh~45_Hcce0;2-M#Y1HzZG-?uHmJI-;DfI4mmPjc?mka2QnoCDga;p
z`UM)qeG5*(kaYb5NyPB>%bVaPD(F7u)&u-~>7aEA$v-?g|AAc83TaPW0{gR}M)1Eu
z=Y>+9UeI|LuNWOIFVwttv^?O^TMp`P@w<HY(EQ=idcdPsgw2EB|I^D7aNdBV{>ksb
zseb~90<~NJf-5mlz%#fSK56)kXtvgaTO}?G3@^I({`>zD)D42<1BaHkB}yLMydsmp
z_at2f%`1YEKBz3^-zFm1F$FS73-0BD3NKI|hnGr<9~}6%ef2o_Ov9t|s|PqrK)D>;
ztOC^vobR9o*Ea*Gm;^ZCgNrXv+Y6ldQ5s&_(V(={0$JtQ8=?{bPGZpf8~_>z200H@
zc|^R(-~Ipp%VyAY0DS%eya5X||L5DS<_S7b&!abx(bF<SMWWaoa>fXF<H0r1)jyp+
zDhi-Ic%bof7ZnXh(77uvDh8kU1zc1#Kr8wcz{~$VJ3~M>>xzDy01l$J{M$^lKutOh
zhYl02?hq9R(8(q-pho|;5EW0viOaAlG|=7zNY%pMfwyWA_=;M!v@ZSm|NqNIP^ky^
zA2`W@Gctb*C{gYN6~r%P;q58M@1TxJ1xM>8{uWSq4^D8;85kH^FV!h}BwzCAbrJmk
zS_q!r(b_XV_JJbah4TP^3us3qsN!$A0vbGRe!=LO{K2F77^GSA0o<(l0B*>G(=l>6
z%?$3dK>80J$)GKG&Bqu$I#0Bo1a%WmdVIeCIue7ygWvO@M{fxmql@Ju{@yv@Zo(CK
zH=%@$@g-=k5ZXR!e#O`sqT=v!1~~aUFo23A$A+JvcHf7W3E<QXPWPP`_JKkK>;q3w
z2g(xc7zS6%2d@17M_gMjmEJM@|5Et>|NmfxFLgmj+_Y^4)q6)@N?iK)|K+)hDCgbq
zZ#$R9Uv~htjRk5zfr@4WQ2GI#s3ikk$~Q-)1Jt&<-Ff=JYxa&96}^^ACCab?N>0#>
zQm<*nJ5VF*l1H-0G!Mp4{~v+&<8{}ln6&=qpMQuWL`Bc=t*hY^!`q#wK+UWJuUMKN
zv9})J?<{2m7x21_rVI=W4WIc1c*Q=0S~__L_(NDfe_~|d*E_-A1Zt6Xo&vXXro-Af
z)4=T<NTbE0(?^BFqnEd-6_OYaf&{>m862QBX9b|Kz&4O!(A$o{jhv<6Mox~3iEHay
z{*L9$3=Ggl&fow4K?8v=FMt|3M;To@pY?|5GJuXO*Y)ZA-F!~M<KSb3H2yr$5e^4H
z16U<0dLRoGJPtn8@Zdb{()s=~f7GFa&saG>H9xY33_n~3)!_x8_RHF6Nc#nxtwHPf
zLG2gN!Zq+h6#>xLHfZ7fH&7!+aU-absZkMl!M*_$ozPA{Xa-!M!$n2^g~3)xLq`84
zXmx|D;gjwV6%%kv1{BV%m-wfGL%;Ks;ahm1cXa>z|G(iEBe-nicl`uviRiv;`1k)m
zNPmfn38cOAjeqJP!?&Qgd+GM?|9@}<LMjGOTgDM|$U4L82~he3VtmO*#qwn`D1*c1
z5Bc>D^0$KyM|W*`;?c{x_9eK4-vpw-qedYrx}XBl09qh|lAi-8v>aY6diMYS%R*2w
z1X>5-(d(n)0B+=fLR-M4^Sxv9841R>kcJHBZ=cTpE}TzY__w8~=y@D`t^g|TDjau$
z8XBJaVGUJJ#ruv2pRjhgs3bs|LZHTuC+B}qkSe%vJ_WUtK)KFS@qY7DYmh|_P<8(q
z{(BsJuHkX;sR5`V1L}o%a{dRkhI~4&fm<?)_kB43f_HO(R@WVTui)DH)|KD?tYhad
z2hiSBP-_O%wBdBIJi*^{9@4gnfwXO|!rL~z;I_@%I#Amt4&1hR%jlc@)~nY?lM!5$
zdGuB?xo92(wQY_;+BW}TZJXmBy)~B19?i#@3@<g*sOU0)0~XxAxehM)K^*{4OY%ke
zW>B33x>dcq2DI}4)Jn9jQQ;_IebEC-YTYg1T#wYUae}mLK*a<~%Z9-LJVa*(Y1jCu
z#KA^i!R?y)3=9nWK_e)zcFlE<<X=ebni_US*Veb7cFjrt7I$#F=BP)nJ4lefuL<0)
zfqK72gYl&rXm+NdM#Tc7J#+PC$e;iJ!Tlw0LGyCbZ%~?rBu_}P1zp)`_!c5!c>84`
zxP*nZXUxIvnGYVF-$4UHt)L#XM>3)IOdX^>^Up)`1Ef8}?!oW>3!Ihs<ryH!{m?UT
za^DZ4Kn)rmP~8r$UtA5}LfSJ&9h;A`y_^Db&x_q#{{4T+3a|e_7u)H!+%8e{=;n3k
z1dWkg1~q9wsT5SRL7Oz7CPZ(EE(564P2<nI0a`Ta!ubr69YF0(-Ov0{he2r{+$H0D
z=D7zHEugkd^D}Et&MTlSSKx8*nSl@IvlkUXkmOMT5_JHlB53w>0JT>@c7xh09xwK9
z`v3psW{{uY^*K1<@wdb>GBEgd>v?wj3P2hxp%TTKzTK`2ouE|Lc?~>B3_6D$bV{7#
ze}Qh0Ft~XGI$I62^UI^#G@t|I-w+jD{%s~=p539a28scwfdU#I2Kmeq-axVR=!Mh>
z$6P>(A6hMB*W<1h^51|OD3B#HplYG@C8&Y28M*v|wNK&{_*<&~{QnPWpG3mr2i!h+
z3u&K#R&Ie4(0u~!lXr;m7VuCexOR8{1Deh|z~2HoYSIzhKKTKf<@87fU0>1q&4b_n
z$4k)3Rp9gk9nS}qx2%xO$SCcT<2c(VHSCNomaq7GZ-Cn;R~>s@!K0Wp?2Ipu{{H_T
z(k?N0xe(qiInLzR@C(!~`SEfIIF*9ppP};tc&Y;I@?KE81T=RFO81s8T>1TvLdJc*
zy_Ej{|36saOH)w0<lP!jMRxQh*QtO1UmiON9`Et&JP&P)falOX!G}sTzwz+s&Xe$H
zeOpr7?WW+-E8_q@_<`{?Xhs4w&enX?z{Bz`e+%eL37_s%4qwaXKAn#|`Q5IA)@*`~
zLImAe^Wx45&>E)F3%-`mOHZfq=f^6f@#ll~6>7!_ICi@UIPz<Xf!3iZf>uv8AMx<%
z{D4%zfyVpXI6&J^J3to!?RQ{eV0f`|*}wn0xIv4iI*)qviUfIdzVJBsh{dBfMATq{
z$8k``0-Zr&;BnjmwCkVYxC3ax7Q=A|(D*5XhvlKtTaMi>DhklKbkOQ-koP)4W4|mO
zjITi}B|DdZlF)ztK8gRJ<5GN71e)J7dK`St>d_mh;K6wPH8->!>Ct=$IdqyU1sF@+
zJ-Qh`^XGej_ANRn_;fRPbbE00x-s%=dP4?jnLRqaIruf5!8$=J6eJuwLA~9Bk6HLN
zc~m?YUxQjs0v??gL7N-rfWo;I)KK;4wdH%n$nfIiZqNo0NILk{{79a^r4ZbJIIxoy
zG*Szxui-J){EM+P7&NFW;ML8-;L&Y?aGOVW0LWn;oz|f3Z=Jy$ASa?Y3>-*Et^;*(
zAkH)J==|l`d_chC@~h^9tj&+)OS@mb0+mJJ{Ly*Xqt_-Hw3YM4&n2M!H^KisK-=?f
z^S63{b~9DM(swVbWHl4$Sg^kyo$Man^&B3(t_mKO$4gjWG^_-r*7y5BE7M|MZdwUi
zzu<vKeE?Lw1QP>8?8_#wddNZm#}LqgXrQxFK&!@)ru<vL>rf33fSL#`w~+7q{d^4M
zYSAl?8A0p35%>N2bf*dUbmvJJp7iN_;M4gEmJayWTwwM%_=>stAfrd;We?87rEkC&
zr^c#)uK*Ue_F$<I0<DJNe8t}y#tj-~1jW;5e$YL@2SLl+e0oC_yn0!f`8B72mu&KH
zo1y|5!s-Z7;Q+Bgot)-J{NRB`RZa$m?ky^yWvZa_{y)|Vdn6w_2D-IJ^PEreKM%$m
zzKlOwE`ja=o}vQL_@Vg}QwN0O(Jk%*+b!DdCE(FrCE?S{!{KB3fxr0`_-55LDxe0c
zr{*zF{`K#C7|(iG{w*{1=w<@7$uvAVuX})&M7yXcfUbd(05uu~K%HG56%Ej^mjdW|
zF$rjsCkuStB*+OK%w8PeBT>(T78qCaL6*{J^Dr=YwB9a}2A}MI%?C6e@j`7iXp;zN
zW}@@B2jhLv_2{ilpp6EM$2~g1_kg-|KJaLM#puhw<_&Z619s1YZ<(797<4d!?y={5
zQ2GEgqyP#$pU!VDIBNg@f6WKFiSpc3*m^xsMG7h%klI)e1sE7S8jpZd2vQLQy(icK
z)WPpA-~f+ts&g_hykJ@i8smKa;?-hMDm~`W3t8|As+l=J{fKTh=w-p2pk&z$*@z1|
zX8^Ra8tt;+JT3-?7aNyA44erz5YpR_=sfJx`Md*k5dEPQ|Net!ft<klL3i8wN*Eph
z-+tu*y1VKSXuFPthvX?x94YWOKjUX$K-_F~$V2iJfAd|C7-%RCsski;1tbPKJ02t^
zd4j+B9O#sv&RZUxCmg}GBj{!;7g&D+a=(=&cyWg0J^p4JKG^+M2r&zg82o;#cOH`W
z`I}8Z2kLZQHAK4K>b*zj;TL}v{)63b_0zHWIExR&7*Gm3<RN*_qw_~m59s(E&;man
z=-PkpUK2r2%a8mml8}pzIXh2)uPWwmf5peZ;L`cu1#~yoDHqN2&BqxXEzj5Uy}ZZ=
zy6)J8fx+@%t+Gomi#TYeQS$`&l+2sp`;NIBJ5M_{zh-o7_+49e6P$H@ReXAV6+l_@
zGk?B>OXmR(#uNOSbHD>wpbWVZRM>9YqOuA!Y6{JmTR1?AT;`~N>JL}LORknT_<JPS
z85m%B5u^v&Vw$1?;()Grk^uDrBV4-IfQ<&FAO}!n7J%dwd^&wVTOndpDnMKgQ0xYH
zbj|?}Xn|U%;5$$gI_7|95Inl&T{<BRDv$192_MTB{LNj^9KDW#fx#1W>Si(My5zS$
zj2}E0k9t_X;%`a^C8^GA0gvu#4$x|Hkh>5!CR>2AYYPt~yVigg1C@YwFFb#-z8KU{
ztx>T6<u*_#fG$m*Rr&w_%cY>%>h3ZQm+n%PhC0Zl$%q?xT~&^`h$<NHZwupa=`2<0
z2w_$5=msrr50x-H2^mN9;9qlr#pB>B7Nqj@Gk-ptPx4Dpg!uHPDtPy@=)u+}gQ5de
z#_(^O11>W`cbmmP?>5^Ax<eUvS?R<0!I$wbEPi%^;}X5BgcQgg;Igs^bk`Y&kL3ma
zX3+VPAR8fN<snc0^|w42e|uPd23^VvE-MwlW#v8eViKi<jKWbuMnW&C-pLNW^{fPR
zDKGf0%n%iU7c9#_B_wDd5p>t)cW?<Q!3x^n<;&s2_}-_NRr4HZ!8IgQ8!9;}eE3~h
z)oMT+9e#q&KkYmQ3F79LjLpyZK_TtPzs<w|Qg=CY7?$1zMJl8Sz4qd0`TzefPk>f4
zcb9Q=$3o&%y4RVp^H%d=rcR^??TiJ-C+O&GpYB|wY7*K$=3jGx(c|JPaI{|c;5=UX
z_A`GzpHDJc6$n{i4T@Hf6R=f*S)luFVA1-`60HjS2Cf1>;EYzEZu{;v;A+;hJ6yoC
z+aDCG0v@3JVgPE2Y90k;1W?3!@UK4#y}!=bvzs4O*+H(a`wyzCU^SqNiokzCP?d*L
z1G=aPcy_wO<JXfp98v><Z?*dgy>xjcDEFb)fGVKM0CZ^#s44-~fZzCA6To+=f@(m-
z{4-KL2wF7gdGRfBHTVz~hoIG-jAfvkIbiGVJKw)J&<D!Cd%&Rps=h$GgFP&d^S9gw
zU2w#-;NSn3SHaWFpnI92SpbymK_il$o!5N2?L9$<l3ws-{NUN0FW|xW!qeJaqD<4X
zTO1rT-~|c)p=lo!K;XNNVQC)}Hr@3cpz!fve2>utP+km5;7Cn?Z~U$ILHjNlkAucH
z!Tx>^uK$tz%?_>pAHI|UJKTYx8_C@VKr3}SuX}192VJkyE$++s!=pP(z^B(l!^gTv
z0-R}~4!;iGcNzk^RVPG6;J<(msKbENtm&@e@aZfPz~=C*MQ9HH&)@owk%7Sn<ZuQg
zcO$o3U=DxqG8ue;2#UKwYv4Um-2K<1J4yhw57OERe9bf$sLqf8x8bjY5-2z=g1hvf
z5`sC3!=uwl0DO=0w-V4j*r4qQhZcg`E%$vGzk>@8XHcr|1{WS4y{2zYq81*YTi9Qg
zGcim6U5N=UnnAasJ_MH=pljG6#YP8z>HU|BK<Avm$0J^3FaG!c<rR<^xL@GW4L^7J
zW#>=O3dtL;nuo#bmpm9x_$FU|30kLyNZ%ga;-Dp3Jm67xP`?wxcL8@FK=;{o+q)Wm
zdszcs4&uVV&>PIy8LD#3MOML}^YY7iUtsM$&;>FaKAn(zPG4M`1&Sk3*mNF$c@nZ|
z15!Rg)qMh`1A!Oo!0I505PYuZ1gQKkh<qQid_3s>U6}lf;#r{JJ^pe9*rnimIUx3f
z+HzsY`W{0%P1x+$LsrKGy6?sZbni2y$$_}~S-l8yPQL}Hk=p5^V(~&W2ecj%eD$*h
z=sG&hdoP%Z{{Mf;3!c#f&D&jG`0xMA-mkFm>4wb9xf)*bu)I*r>DhV7Q}Ylwn}F}m
zaRKeu_JOoRAk7kJI|SA&0p;=plx7L69RhCKAetv0-Pr;@y*e5`*4Ywe+#cP`KA@Y?
z@BbI@0X0CFv%%LBKs=J8V)4Q!`~Ux!;fQe$(E9b>9&jBGiUJ7_&}9*)Ky4%eaGxYZ
zMd5`+;s5_0t+zoJ!hkcbgh%J`5-m{fRRDJ~d{iVrdIfwsuf5na50nx>BFKg9fBx3P
z@WK|HZo&B$Pk#ekUYzpKeD`8j!T<j+=YIYVIVaqw^Rf@zy`b{s;%gt!t`G3o+r1aL
z1<?DLeN+TM4g@<@6@2;QGmxhwK;bIzLJZ+bNTP-1+FEcs3!H0xdRfhmq2^jpm2X@E
zt@0u13sgolzhng0{mAvcLx&+~BNgYd(!1bedQO3^l|G;U|NqNNpyNs4`PsAcJ;FaO
zDiWR--^2U^zWM<a{xkB44}Y7v*uwuCe`_(MtOs}ZTtKaQcz+M6yoYu79)jckl#k}W
z7t$a%%YFL)-?j6HOXrW~7mT3$lm%h;DJw(oQ-)QH;CKUHVIHC)@#0<{)a8&Y54zqQ
z6la~cKuKld9FS8XGO$jm8pM@|@(P?zAoUXV^1T^+Kn(akY*5Pv>~OgKaro>PM7RGN
ze=BIck`Lo?to9>?6Rdi9_>u)|y#w5SkjGx+g13PnF7SNzV(Dyf=><<_D3!zc!>Gv&
zR5_d}1YIQqx<BV2IBkJ%&Bj_kG<`rmAJC<@lJ%wZCs1wyk7v2`R<gb1M&Yx+{0(+A
zSRPbb^iBbHxn3B6+}#W5i-0OXix+a~|Np<#L_SXoRvtq$6R7aLIRzAtNLl`+2)I-P
zn-5k02}%7*4D~7C+6GzuFQ|G@)4UR)9+FvKf^Knw8Vs#CLcwYvY3b!|ka3_JE5Z35
z<U})MX&F!r0+IgpLS_m$VqWI`1E=tp!5{zshji0lUi|=Kf@Z5<o&qyL(+e;6gPGua
zE4O_3|Nq77X&?iRzLeMkp*5g1h|e$2fIeOZIxP%kybQE97CK(G40*ha31m*MXv0Oc
z@iLF@I03^0o}G6f{krA@jGhPIFqeJ@-FolRT`SX2#mP`9Xzj#O!vosS+nUV@>Zvn;
z&-Ll9W$@_@mGDS@;oHli59)e@CR#w9f|<~+_bhOCjUQCUu!9H2=CFeY#-=bZFj#)5
z74`v-im@AL9`i|l=F9lQhw&+-OVFYMG6K4q6~gi8W_Rg^%wTwQ2MBm{7f5*a+6ees
zp5SjzU}s=(;or7K1#|<DujWDDPS7P(FFhImdRl%h(*lk0c7jWa<KV*r!13;)!U0|a
z5~3mjD%v5}b9*ocaQJj)fV%`B7kG4DZ+^fJ>S2S1v~8IATe`SF-M#;ycG@pc?v$DV
zim2m0jQ>HKrCXCh=W{T=hn0(+H$cN+%@5d{4;XkHe9hd!RQd)~wt)f$H1@@l_5c5C
zF3{LlP&erOXwbM9C<>9ry~-hH&46MWbKJ`S)TDrod-bz3FudTJ1R19KGy&wUW1tf!
zd!d65o%f+bUSgm`)(km~f`PxqoE6kDbp;)W-~ltMn1g}g#lDFUvzCF)f)05(b{++7
zCcZTF-+%Bj!=Ee+3_jhV0y{wG9{6-a?DBygvFX!!$)oucqkk`tu?PR&OCHUi>@_cV
zbc^oEWn#!YaFK<9;ouJ*kK_|R)*`2xZ!q*0F#1}a=5MKnj2u~a{%U^3*zl{CzdezM
zfx$)dhEM0s-T)@cfAw51{dpJ|CRl#2m3Qf7;R4MNYyR`GJjve@2_7%91lKJ#wPkm~
zV@0JhE}e&bdSfMgx_v>3SHXkv6Tc?p<PlI$vJ;$O*Qj)X66^zh(7q}`4hDwqJu0Aj
z+3=*J<q!Uza5e^pmII(c+ZGj&26*xWaX`DR4uXy+eC5!Qqv8QN0NJG@N2LHXYy>Kb
zKvM<*p52<D_P+t>2tEssZdVD9&Jq;|(2?Na(|j^~EMM_AzhDQQ`7lSN4?G}r)u+1@
zG$3@>hw+mK<7Lne<fd()2<rrmG1h_ygh2Kq281*~$u%1~I*|<Oz4n%<Xn^8uUJ9s3
zS)-x>N`fG-f(C>-L4~pnxS<lp;nH0P$@21!z3z-IouENKrcO7RV=jCW2K?K+I9xjG
zWIBA<BtQcQh6g4<$_tj#@1ObexqOl#r@Hj|O8ED(n1hzlq812qR6yw-GWY{24^%*d
zKRqho^56uhJUDpFMTOl!^Po@iLtn-pzKqZCmj_dz!)l=Nz(c~b*F?Y<)CC6J=>Qt}
zffNUad^@i~27f+#Se^#;BRN2^0BX#6blwA14FaJ0i32i1AmIa<Xay~3V-Dc(=#0Qp
z8i;T}#@qg|A(sZ{UhqK5e^_Y%I_m*cl7erDHZ|J=shAt8I4VGuvUwJ$?FSw&2ld-v
z_u9Px-D}4Oxz}zAIK)8F^eFZJ|Ce_`Td2E9h$fHjSV-{>od*HM*TpxbKR)y43qc0z
zkjigJVB#&mZ6KpM;P|4v{Pya#VFH)mps8U*`Q3TW7rf{9ohRd8AIo>epz<5k&;~^q
zsDS}qpa)up?g;AngUa=8P>BxO7lFI{e#8ceu~p2-F?Q`m)Fe<j2`|4dgLb=Mmfwt^
z^84cJ4yMw#FKxh!JwfFH=$4B2FJ`oYauxKH!(PbQ#^7-p{a^q8zliGl_y46TSPN*J
z26E`Vr{#fS9?#ArzM4loI}i9UKK1Bk_vy|M@b4{QW$>{s0FN4gM~*>jo<N%&LEil@
zgj7*=S8(`r76|w-zV~fK)J8oMQGDYI@eQK=3966YgIb<Y|FD<7ec1sXbAtG%n~?iJ
zV=?4A?=7Svfn|?rpmr<cdwzKan7iQhBzx(bm+!%YM4-Zx0js-w8J~G{vwL($2>A8t
zF#A|%z=93jdjnPVkZdi4oTDSa^*ea51r}`QUW9_(bsy#~&}nP%Y|C4}10~z?Hl%^t
z(va}-=sW~&N<ZQUU7`tIZX#a#>ZK{z<)D5%_oRRSU*;g4i{i@Q0lH21{eOX%mf%zY
z_Fv~O7tP~)LEFSU7(aO=pMN<894QQrz5a}yzA{e7Tx=x_96QgyY=)e_0&1?Z`*c2f
zvAPo+;V(NN<5F<($x!h+aNis}z5!NW4HcIFHEJREk%GmOq2jFIksO42Z>V@EsFjPP
z-WVzl+J43_&j20w0M#joaS#1O$hZfn?g7Pw#tYdv__&7#blih0@&Esqd%-PyP<Y**
z@b5p^Gm!Qu_|nN1XdxJ)A^^U8@{kWGH-HMovk9R7`G3&xA81k!(jgQ8k0V`s(a;C#
zNPvoQ&=@?Vc{T@B&w;Zy#C%Y?d&SuN04aZiyPSu7G~d0*Px$};Wfo{`4Bo%)?g5{}
zYIwlI@>DUW2k1uF3m%=PK$ZUiQ04y#RIwO<4laXK@u<~1xIqAJ9>7`yKHa$jp1m=m
z3?A085@kH#<ENp?!=p1+z=t^(Jm3NfLC`sP8ZU0g{QnO*!v#F<K_GnA#^VW}gkCJ+
z11T^(I)9;t4?JHomA-j-3!E0f=@uOCu=oLGJJ9$EBz{2aIdw7Z2aTkF#`(^@c+i7s
z{~b_?&>hMFsW4f$qU1bNwq$69$$-7S1UK#vfrdu5#Qp#Oay@u30qjmtg9p_107q_!
z3df7danMfn{}M4!sR|kVyY|An2b`Z^B>`wziwEO-`1)y3dI6Q6@bCbYQ|{R8c?W7&
zaJ<k)vByURV$Zo3kGoOqi9q%@FYgu<fAjJsfll56tw+F7-W-LEXJPnrbu4y&CZpO9
zS|RJf_<jP+f3W-jsvk1IhC|A`Ubp|C@fu^;c+GsU*FpE=y#rYd%KtAcKvqJVoRDm<
z7WMx><a~8l`2^0vFW$8vQou`A(0LT7^5>A{UH|<54<6rT_vw5D(Z3Ew9#o=jD^USS
zznIbj4&Ijzpri^DtcMCtMi$J13jX`||G#7BhnHtRLugUZf~?qfkTFMJo&>Ft=|s?v
zmw;CIxG*64<G~)Czdah?fO=^u9^E|9<>5Wx!|)7GHrELV@VA53<#&e(c=YmKJ;cc1
z(fPq6S!ALI<Ej6T;OWbwJ72(sf1900>s$U7ULjCNz?GxrKnaIUGJmVMAehhDc?h=7
zglFl$|0@dkTUnO=``>bazvB;hT1vUwl>vH>vyX~|XKyHD^AAS;wh4luqv8tw^KWzI
z^W<ND%!BcQhvkVfG0$!h6;M1u7C$}zF9h0+CIH@f%D>GOcFsyF=)PR&WzE$>khauI
zK?Vkw4tvmvCC$efLH${qXwXm*=-en~*cn$T9>yl%;NWkS69F&b00k0KR~9s11iBx<
zqq|(equb(t0Eb7nvxG-C!|Od0Ji7e_y2U&|C*5g+&IIiRtxX2qVSD_A<Iey8`S(?F
z_;en7aWwh=|JU81dDCup0hewy(2}$k$R$-ZDhVLZWw>;vs1zJ`QK<keK;z#Q!1?V^
zLWz9yqk^5F^PWKxpar81zZ7<9gZhH57dt{!O8ECxfXm;67s<*0|AUv<Ldr#uyF8!{
z6W{@bE5czGI}i@@dH4VS%lDx4CJ!lxy4?kQpzg~6onO)kb06rsUy%E1aJjDr(|r{P
z_dS05|NqN2$kI&kJd7WQPq(`O$c>=mXnaA7`1XTCFa#7J|9m>Hzu@2g|Gy*12+%l2
z(XIdgU%G-_3f2#Dr=Cx@A9#6ROADx8Kyqu2N&%>Rt2o{Q?jR$(Srs0p5IJ;bPXX7U
zAZtNOXA@rhy!rqC%QK+NEAPMnax?!nF|czrco`TR8!9*$_*>6{cQ!D3^zt46ol_=x
zz~lP`kLClcpzZvkn?OSRE~h+`16W!wRe;Vt_2730?QmBy03H3^c^@<x0zTNx;)Qnm
z|Nk%JAX7R}e}3i{U;`(Z|J<MhO7l7RHGNbZJi1Fj1o)iG`!AlH1-0>+U#dgh>Cx>D
zI?@-SZ#qPu0KX<^|5A5}N&sl4IRbPIm(LN1zW3k;4k%x^3*6QN+r|h!4mDqbUo%D}
z0ko6dqw_w<(gKj?irY3SFV64y|3Av3n>q632C#PUd|JAIN4FkmsHr7^m4U&Lf18U6
z2k2JGB5no-n_~W!ED&A5-#T%@KhQ}>pqb_8ji7c6Xie?}pYAjc56~UX<pSWPQZ=B#
zl5K7v6Iwxib&q5>mevCm?4FiKeE8iTfL1sgfZWxY0}9I&6^j?ITL1qCZ$JXKKRmj_
z1w6XVKx;}l__sN6v>YfE0r|V65#sOf;O3_TgH1uni<kfAgGx<sKJe-FfhNO)KAq=Z
zlx~Hm#B(ox#6$G%{{8<y$VVCf|Nnn^2&|U@vYx8*n2+TvAIWq4&C@`uqmsdkP2pk{
zATjVNDulWykQitc6<Fg5{$_jdDk|{Z-miQ*Pe2#PfAj4;|Jt5ko?*Ye6F-Ab=SL6A
z`#zEn`I}X^85s80Pn*F2>WhKIp7A$3@G>y$2d$$5DeC;}Bl(!WIS@2h*Lm6S<Sqeq
zQ19@VN9TRd&Lho7Szc_c0o5hfK{a^ikNxx87#YC&zWYc%FPZ>aJ0t+wQk{I%qg&et
zRLuEwvZ#169smurfC?}Pzg`msAInk+{-)!grFP7z96p_;0-$0;0JIuO!J}JOEQ*Q2
zxAPdkJcDoNd7sX6phb}Hccp-~zIML$Y<|b|;!e}Q|Hz{MTzXX)UWnCz?shl|+Kk2M
z*?EzFn+q$0V}~1~6aO|BRR+fnwjH3L^RT=D8k%JAk^E6KALL*K-_8#^I6<aczJSV{
zaO`z8D3<o<7VU~;VsK@A>)7kc2s+!riGQ1jmSac2KTztH@aQ&CaqMsa?<^5`;a>Oe
z|I1T9LF1n;oev!Mf(m4hZvEyHjQo2K_;l9_G=GqH)I93Z&6)}_H1jQJ+|cphUmnlo
zt1i|m6C9iGGB`FLW%Nuw>(^^y>0@0g0lQ=!+}ivGx~dL*JDLD!FHr(0+&sEVIY1{L
zdoUh!Z2ps6=Ht<=dp!cwu>+@1m(E9^o!QMVnLIKt$+x}^^f>rRHTzJC=5f%p)pN(r
zD~tzv0~o;}#lI~?l%XS#v4gSkKPa5a4}k*Gz_IxcXBj9Y8X`a;@dP9Y4+^D@z<(W%
z|3TZUS}y$f|KEr4pJVf14*urH+zbqk-;T2Iw`%c%&iHuC-?HHcC_k{M@NZ-2U~~L-
zl!?D(E>y_1^Q{yAb{CC*X-=IkdjDRw!up+#omW~f@plArGB9*rfP^R{IN?Dl1#%T~
zP@c6G=>UbK;agBx`g9xnCja&9b`$VmJnF;v*V8&rqD<Pen-3glpyj3CLBlYhAu|>g
z(C~{Vvm1wJXC7$0qV-ZG`!NPx(4lAG@CIq|>gBNj2eh|Gw{BiItUU`3=Vu<6;e4#~
zgG=W#T;co=TR2OE;}7SI@BjZhHvi|~Z$8Hf3gqJ~{4Fa$BdOgyDz2UXyBRy#ow{8t
z|2TEJ*#CKH1)8Rs0B(n+f@j;_zv!<7HCMHLyK4pfdQB{R!RgEsboLu)RV=t`@gCZG
z^6e}Y0GINgzy1FYKB&C&5NIxu@&AjL_5c3AyaVpWJ1}^F^9^VNmf^Q!E-HD9psb#7
z+(jjWfkA;Gt+PZW=j8+NPynR;?b&(7v-7M+>&Z$k&+m6Uo3Ao>e!mM{X6j@42(+X}
z@*RKkDlXXKQcw~2$Ok0W4HAPFix9CKkQgW|eJmgONWS224geJ`ojIUx$_t;)=Z0^6
zI#pC0!CR|5JMX@>*$FBaL8rD_-t>|D$KNc(0bO4Tx^Kwxo{!{D{$^ng28NxGa`C1|
z=W8Fy-~7!g91IM|h2n3|&f|{F$5>v>F8}v`C!{dE2{NM-wD`wI@@LUhP}j0sMFn&r
zC5KP9wFmg5z~p0~0Fv<SE*J1P_}1Qs@v8^pQBUi9i85}_ZgEfucmDq`<k{`c;n|rl
z09r%YT%#hu0MevT$pcQ52f$&h0NTMX0Z*QujK_C?su3T{2jCd-k$h2H<<YHsBm~ss
z1RVy@`5M$t1(lu8eLCMk3)K`A0ng_5Og^1&Uo_Q1N>;e6ORovTi#=talJ$sVuN$Lh
z=T-h~EX<A_?x1p&#n`cf9a5}XyQm0&E%lImQ8W)!uxfxyRma{C6$4}kNqKbh8iz13
zIQO!sfD0cMM$m|pV~6`cP=V^vU8ADl*b)98T*SWkSn==w%My71?1AH6&;*S~x4uX7
z2}TcS$?DPk!5&hyYK1T{xFVMaSADEiE`SOIP;o$7(OL^DT0KEUYoSNCZcQ)~gU7zZ
zUo~R-4}H}@j7NgI4lkKJ4!&Xnt!DZD%(L@?NAsgUo(Eqr`7j>x=w+D%QgZMClLvUc
zi%;hx-_9e92V8m`Ace0RxCnOXaAfRY^l1DAO3US|Kt-*AC#?Ks2*zJ71bhaSzyBfS
z?{3h!X5jL-j2&A38hl2SzwD6mR~9OSQvT}yd&vs!D!VW+cy?a#02RPJpz$V92@DQ<
zXuu-^eQOX}pr7@y7C8Y5bUdZ7EJ`U18gK%yCu30o#k&AfIqZR}AO=TEmPfbl(?H~C
z0gvN70vE=#jE{mq{PA%BG-nPjr|Vdt<#a1E8z?gV^S3Pih!PpcnfO~KK!sd8|AQ(+
z3vgv<|L<i5NF1E8z~$@zV=gLj;JhDj+(jh<Qoh!x#JuzZ=MhNxiYSj=4G$c1QSk$7
za5(Ow;sMqGnyT}8`QS5bT^6{0cnY5MdH*86_}_oe<Pa4sy^v?HMl`4-vUsty>i_?j
zH$H%_D$)m4C;q)AHsI=n#}mBu;G0k9`~L!<N(9`}U-to0iGZ>~=Q|(9|1XwQ{`>!O
z`Ug;F8{A%L_{HecZSK>nyI?J7OC{?(5GDE6w>wS1<NH;Q=A*1FmwfnLUikLf==fUK
zfs0Ev@QR@C{{=j|-8g(Z>jXMq`7k~Jw?YnrmJU2+;csPO0Uag4-=YIrrog|=m!X5>
z+aV_Y78x*qyN~F<v`!y^e=m8!P673AVpKrw*yf{*9t4`QpxRRbbj_qsrw?eS3aFI^
z8rBg2O>=-mKr6l=g)*$I3u|U}rl<(`NS@$tV*dL7|I5m+|Nr~+rhxksj{N(sdvv}8
zO?EnZfx6+f9H7ONOM^j&SiS%M-}Cz&@H{oRz3<cc(4+Yzs4P6`(frX~^Mpq?ud+YN
z#PkOrOO=oO(+=`)JL%G^!}t<(*q-C}JCGI?*btY_2WTy;1Age4+QnK0+_VCfq>u%e
zu>BeymZv}iFrdpOKvP(touAJ^TXjG~-Jtm_@L?2g9X1*-SG@xze0|V>v2SlGqmOke
zbiCN7^BJ^#>&oHNnJNHQUGol<VnP`_dJ8x_nxFmf=oILD<=O2c`op8sN8pEt=7-)8
zRt8Vaqs@<gH2>n@Z}NWk|9|HN!%NK%eso@JJ_I_+mY2b!(}vITP|>@Wy6-^a_FqBi
z4{|hZh$lz@bl$8>hlPjcJCEK9#uxUU|Np;a0xNy(1FO0nn~yQRv;j47J5dCgUaEr|
zv9R>Q^pXKo4x=h!e#wNQi23F1PaumQ`E-7JalzyNf0qu6mlL2@7bSS~`g3?RKl}mS
zsb-?$()q)qJB00rM`sB84-d`rj*S03H2*m^KmXy``3>9<Yzln~Y7##GVR)ePQ1bx}
z&u$Yjk4_Uo7t0?-?_OGvZ|>hWc+7q91{9N^@uFTosC(Hwx@}ZkI$wBngPht4a<t|-
zN5-!nn%^CppZ@Udg!B%YmV(WFis{}LMekmAAk0Mz2avhQ;qVt64j^;Cfor`cUwq~o
zfF!$p89F%}yM09ebovPVc`5S-x}p4K`ac-U0?zvP8zu(o|3jLOFLgl!tl*a9%fEmB
z|A&g+MKHxd=X$>`1fA*tYLLH$Hpn$W4RZZIFIT<>1)B-Dsm=y&s@s8N?Ek#%2g}%~
zxOTqnX76Nk>UPlw$>{xgS^E0_|1?BvBW(isTB+tY3O?QHNXw>NR3r=!I5yj;F!J|-
z_Q`;DV{&+OH-PS50&TVtDAfm19Q-X0`az>A&tH@jfjaX?!A<-#P%(!Bkl5kZas2WO
zhL=2gO%Ke5TrzUJ7$gD8;}8wg!Q&OjU+9Aj>9$ev=sfy@8KfD^KKw%bECT~%D?TV$
zfR1-(16>kR66D(Qq@>WJ^M*&~tJhlm@}Tjn&VL@A&pnQ_fR7~yU2?(!8jE|eL=zNP
zkR|~K=&%Qg6c1y_sC228NAnQ{(D>`&v<WY|^ZxyRy&OLN{9<?hzyF4}T@9bSZ215G
z|BIM{fB#>;?gP31=u6{%jQhsmcZ{xb4ENXxx#u*L)iDfuI$iS{37_tI4xes)pUxjX
znut45El=>bScB#~IzM@WyztdW^A$KSxj~x%_WS_V*#H06d-R$xfG%Wj106~OTIvMa
z5C1|vACyKyR5(034}0~pD1iExKE25j9=$BWhL@mQjMF*;1dcff3Hn&REinVHD}KQ*
z4_f*II;vj+bSE9Zpw|nJZjT=xonAjYERU8x_ULte0e0jIW}n`a!v;Q<e@j$6HQ$3R
ze&^Zi4!%Xzr`P5v=$v$)&R@Qae_nLu{`>FS`WAHL_4^mOc_5cTZa6v&nh(5^#-DS@
zvlG0LnhkX9Hz?d4V;$oh;}3)S6CSPKO4VS|=eP%CuHkL)r2&v}W{A*B#{d8Sdsv?H
z;CDOcll@TQ<wwx5{=K$*GZ`6PRA!@`Ujq;O&d-noH2?qq&+gIuM#7^zpTnoy+@te_
zkLCxDgFje60o&pTj)a?@oqv2ZKZ0XG5EKKTWr?6TsQ2i#Veqj0!QTeDm<4p?Dkug#
zI(bxHEX)P@l?UAF<nZh~>dAQAqt`*eqq~U1qg%*_@uf$nphssRhmYmw5`7;~o%{*3
zUz`c7pc!&|lt-uI2iSFhPdqwr_-KCc>~&!k@UVPcqUX_h%cJukBpkq+x~)9m`YNIN
zUX?!a(7ffrcmcFLR=}t8J18-{c$x!p8|1p!qoB#z6X0Xx)A(}^I`Rv$sG!9JqJ;2h
z{a-4#19U8ktKolF!?)n`f<Wso_k+Y<{sx7+<#!K$x9^^v-#rgLXL<PoB-Cr$Je`r@
z#k<UZ$i)pvU$|qKPp^p>G(R-HkzfIhG1swj+krZk;H6k|R0Nn97?6si78MQ_(1DGR
zVLi~D*WgInq5?Y44s?G~1L)WnG0>Lu&K8vkAdY5>$_Mb-i21BLS1~diZ&B$0jk|*j
znjV!Ip#3eKEh-B@<{WQPSpk(h-lDPr$^@O7u>;CJ-l789ivuc1j<={>fQo|l@-cwc
zQ(J!HZvm}Q1DyfZ3w2a)i^>C#;hiSn+r3VBfVMgCi}9#{$I=nu+fd6;?bDme$lr1U
zWK`#;ebu1x!_MbEnvY)G&jyt<pb2}>Y(*l-Jj)yv4*ph9f%$Sd69dBpk8WX)UejY|
zLD4G&+8)}v3Y1(sk9b~u<H>l$*Yc?^zw=Y@*6$S1y3S<q^hHOlIA}2T_=~q$AdSJG
zK`K!9thE(n2l#M}&T0;iPG<>^US|bQ%OfQ`pcdqOu<B|K5AYZQXafX)D`<ujw2uN5
z>Yly%OyJ>(eYN0#eh<F*`PB>YY*45FI5;<f3%OngMh{CD6%PKE!0vzl9UJNyYx!H<
zKr^tQ<&t0z9QD+E3%aZZG|LZOjb;G4nyuSe0(6~rJ1Z#vccZwZr3@?vYBe&0j+5+s
z_o6@d-~X5KpyMv!>lHv12<Y%WW{~&Zy~qXS+0HrOG~?Nuqr&9d`4!FaQCT3z9|1c)
zju$kumBHw1`HsJ3UDv<=4HY1lFX;k>BGeR!vq8Dex3>ngc&S<fx^Lv4M<;mSNVNc{
zeC&8x@E_E4dj}G|1lr2_QV+b=1l)fCHPSDDGHvJam)YP+C}@8S8bF|+0i`Jk-`*5f
z(5*fao|Z@W+tz}%yMmGg@8;7WHwk%Ip5ku>t%LRKJnnh%y(i;wU&}wf{LX(s^-m{g
zxE~aXtq1r!9*IJd#H|dFMnsax0vicl`V9&*SdusnN)rEH^ng`YbNF;7gM7u`$_-YY
z1FDN40Rl?hzLwAUTe><y$4|L3+SKy5#DW%|Rr9y-f@mxLmR42<hTeb+4Zk?~+kY}J
zFxVJC?in&X@LB*|uiKtEbB2e%y_T1Op;x5Ak$)eHif8i?#$K0z3t+=zco{%*KO!o<
zUKbjEa+aM3dC8xbfuZ4-RS73(#cb=Xj(`6_=QA=gFtq;X@1G7@u+u#STo!=NzkwDJ
zphBKsvqc4T(=Lcs0ObhK$i*Z!&{>l_{QcKD|NZafX#kxg0XoX!ILMqCushO0B}y89
zzJ*6O1L(#gkSU-;C|f$%7#Ln2W&^Dihs1AhDihe@E*+py31u=o@G|iK|No$=?EB#J
z(j?0`Y~uM_Z94w__h>%K<Z1b?L_KW+|29_!WHsD2@g?ldFAQur%Q-zjL;jZUN^gV4
z4SV;1FRBJzDFe!ypd|vD4`1xv1?s5huK~+-w}9`$=GR;UF5W;lCWEpbC~bqn3S<>1
zuAJGxhd)5lpN$oN>t0Ym&H<N$pvd*<eBhzo0xpYvI+uWH5760Zpf2-o0m!`!pc`&L
z&Pe0WFHvzY{N@24h5#Lv2`(vnAz=<`B!FwEA8DOiRNjEg@SNkvT2$UKGB7Y6Z&7&x
zE`AjlI_Ic>cD{nH<pG5<EUv(Ts?`Px)KW%=hJUsEEub|kKAjI7TE10Czx)llKn}ES
zOQ7>&<HG|C3=EAwK`~Ow=K)#^YI&^mN#`e@&Ib*@?D$(=fE4#1U;-s08~zr5b`Zms
zzg3T&fdO>xEdwaiwJ?D0R&4lJ&EGN|ygcHdkLE*<=ASJ5?dw`WS5u!Xv2*CyqVfuq
zlA3=qmKgAFD`f(SyoQJ{mB{gLD`f_Wfc)#x{FAwahksis3rOTGBLhQ657_r02R8p=
z;cuA?N{Wy8`M33`yaa{v!w;ONI;Mcxo|eb>TeMq2-WO>2rOn^+8ti6W{+1*TkmD8j
zTNF7!t0n{*ekt>}%w+=!8kAb~2LEsV#m(P76BKgWA!d2>dN8InKKj6r)_97=AgvQ3
z>S=k7zvW~L$c6yWsX>qo$KM9Z9}T~%`CBSE7#P6LSOQkW(eP7`zeR+LfuZ4NEq{wL
z8>k3PVC?7t$0Rtqs#{<sX(4C<OXmYnBDk6cx-t=xXpTYZWhPK0J1~M93@$1buv7<1
z<DmK(mg>L<0z=b3sJRJGm7Ogr3DCv?=o0uB{&zuZfgmjg#|9gfTK?AW0t^hGih$A6
z@*RI`9JsT+2i!gYbvsyJ$fSZwM^H1RdyC2sQ2cdIQ316AJbK*)K>cjSPcI~XfR18e
zRWt?NZ?*@bsuR*4@vyE@Q7B=35t<A#2GXuU+S-r|I?|&XboyrF5m3VjrEv^Or3{d9
z?LFWO3tC_V3ZMT|R8D{zG~JNQ2MW?w(6Np$pMWAj9;~n7R~&z9Ip}%|&@LNLvTgPJ
z3tEln%Jgyzcn%+uzde$tfLltS67OmAzyG~XjG)4?6ViSH?ZyDLoj~z`oasQ7W5+`l
z28QNeJpBEhEuaE&lE>v2%@5@HTdY6}ia-Y*F;4+ExYGFZtvtGg;Kkz)M*f!TEDQ`U
zg}`%9uv#OR$yf6!X!oUWZ;dX4k2Uscl)v>BxTyir_0kbsRf76~NdEXrnm+`Yp#FFW
z(#He$$ED_f|G@`0A^c$k_Qw`*WdT}J)WXih!0^(E2~^BO!;`rNw0rXvXxRZn>c9Ul
zAAn~h8Nh>7_y0rc{rzAua6EzTO1O~%YW5v}*#=I1pt|)HNIB#C7yDBF{eQ_1YS6&O
z%PcSO_qu`{2C9KrJ(wYF+Ryy?8sIHK44qR{Ks6Ysj0Z(n^Do9y(0NJ@0-z{_WTpHF
z1yH<#I3PigGSJo~P!8#y0<IyThJemgz1akE8?>nA&tC%eI#j-M3b;<-*IWWlo<5yV
zp;buhG0-XYoiE@S7Fs=kHt~ZJFf0SZbG%3A8c03T*`fkj3CN-XI!+ek#x#CdX#i@X
zgIoz}mxHPiSl$MydQp56k+(fN-@H@@uNYzQ=yhcR7f#}!wZ_{*nLy=ytHiJW|G_8D
zgENK!=-h~2SEiS<L24lR$MO(=@5M%N0$}xkCV<cU`9|GN0v_E$oh{H%h9?DZC_5pC
za*_h*xJZ!O5TU#T9K6ta7-|Tpsh{5X??03a3mb&@^C1Nmw7N#BeUU;2J%Br>fFml6
zKOe#X1s5z};l<-|NP7S^IH!Q)669o%(_hHkKm_Z{%ZTs+g)6KMsciW7A6z@Wi~_A;
z;0KM%fCF~%kN^K6V(|7jNW29!3A+nat-ss~&I#c8q9ZRq|NQ?SX6B7rP?_q%*Z`^W
z8o;&Ce-=<p2Cjt~ei`t$ID<5R+kgD+h2TkI2E$9B2BZT+<1a`9(tw+Rp_gY8|31*g
zfsDN&UKczqkCkxqZ{uiwX#i?CUIUeUT-*$xoC9i?yfg&)0q$N<I>@ZYNC#SI>0k{w
zxSM}KavMrIsKSyC_TWed|LZ`x4H9K({P}ahra}`2H2y(Z6;%1X>;<o9f`!+Cnt%U$
zz5g{o{9D4={EMBx&7%%fV?(NNa6{rzfAcAY4u}9aM|`dM_y6VN@1Q9Z2L_lqvUO<Y
zNMJL^0BX+bZ7_W%==S?y(<cDc_p%z?^8uCH(Eg22cd>wfZ;B~{k9D#HfBRHW{RZn|
zfZEuwE+^<_aZvC5Wh^-5F!=N)FoG(;mJqOg0pQJYEuj5j4Zp1TTh@a58PF7R65Oma
z;BTD)nv?9!05!4sTWo4T;S|7Rc%b1|EvV;U#oww?^Y4Fm52Ri^$=|OETDXL(=is7J
z0Lm<&!W`72?l1<m)qe2s_xn|YYDIXr!M^$*=pe;|4_IJ@HoV(Vqf!7Wr_Da|=i@A=
z!Pd-yBpXN}4Jw^qRe{ori%LNne}0Ne0j$jEoC02A2u?vDhk;6HP;LgL9Z&)Kf=%oH
ze-GRLpref2(`&$G4>;`yFoB!?E)1ZX13O=Vx^}&`nv)nAUVO_2EnNf6Z!!CT=3BrW
zTSynMB>^-7)D5n;KnoBUzrSFM`}hB)Culu0sGNXgbvw{m4ih|j0~kFmukp9^fWzH`
zvA6JoL&HB#{x;A(ehojX`CE%>{{8pqO@MTl3c<<(m_R+c7JXJw>(z?CMGX<HZBk4O
z44oI7AKnLF?IBsl+3+i#zx7TfsQk!a26dw}`9bafP=?M6%@6K3zi_mXEaPqX6<@;9
z{K}x=7g9&+7PKP;I*1X}f$DtcqxtYf<yvqbYKsa;7#757{P}CZx37cxBapCN1CE^+
zQW}V`t*Qiv?GsoxYjO3z{|&VawI02pjQp)xYzz#&&i|W#aPYV7t@`)B`8Pj*%a*Et
z|G@ziRtZX&TppblUTy|Y(1K!;;iWxDSRUEO{O#*OO(IBwF42LE7xHf-!M~t|j|l&E
zt^xaZ31nv>yj`6SIsFTfmZ1LKrH=3~e-+rjptJ;PPq*x^g7}xebt@>P_PR2@yaZk$
zzyOM*7LWh`|G&In@$Wxke9Z8`YkttUFtq=Fi3Lahe<NsSoPQf?|9=T+CvNA{mqy^a
z9~@rbdIEGVkKuvWeEjkZP;)^G=&+6}Y{6#kVu-nj0%BeHzyICvhI4;-IjD7yb7<iL
zXg#$i<ce8v8L^%jI<)Y;0;P<2QGun5&;SoDtWg1(0xBjf(Tj-;l;#{r8L0IK%IDDL
z9H^w|1sM&hLcmD{GFAXCA3*9mr>KCAAWZ|c??4PtIRQ!2kOs>OH_&Zf(DLGXIXI3%
zY5FDTUNuO1LyNa5%%Ezwfqx$p=pegZ7mo{`me)YlE*G@gy$%|$$zx_<=xk8|8}%6+
zXAB<6ke&xfTBYpY|K0#de*_ZPpcWORKjNYi0NO&701i)ePzxSZ<~En3gl7pTUQkP1
z(6V}d%@~ycP*7r&xCux>3AO>^f243!1R2@sq7snCpC1FdtN{{~ogpd-;IWPbMA&VC
zln1j^{=>`K=cVAV1LY5&&ZjRQg8d9mr=WJdOer+_k=ykO@OC{&9lvG@xU%4HIS)FD
z_y?%10&Z`4^n%Me{ubd<P_YrfY<S?M52(Y36rO^3!V_{hB&a3>4UvFDH4`+{01DNQ
zr6{5L2;@v`p*jbAQWq#-G16!SQozEjf;NH>wOJ>~;7*7%QaKAb0IYM03dm(?{P|nJ
z3{ZCxl18E7yhsTV&fki`;S5Sxpm6R)v|B;p91F7N-~;4PmVkzGh)M!1b?~>``}_a@
zOLlM%lL4g96QmEl--U=DNX}UT%c%S<!GHe$e_0QXV}=)>{Xqu}^LK*ET901aD_x8X
zFBYbNDpgRtg3a$N0ktzx++_fD7sT_Rx@H4tgZ?i@{+5}bV``6rT?ekOE1f-hZEHcs
zdV!6F^haM*`~Um@Vp{OO|1Z@*&hNF20x3}kbu71*{QLiMa?!v4FU^ZVw{C%mE1)Ua
zURzU;A|`OZ^ytg9VvsW-=7G+s_2|47?9u#&!=qc?!}2a@mWto)Drf~fFX(*S7oA|A
zmMVB?zTN?9Vt6$E22u6=9*w_27de220vq^!4|_Bp;fRhsj5IwB+P?zQ0veNLht3#*
z?6Ew?-@X)7aCQFn=(hLhb{6o^`~jK4J66sMF~>2+G4^oU1fOna4$sc7u7*!M4?bn_
z={)M8`PZZMTZs_pqVe~Ep!KWH93I`)o}EWPt6w^Qfo|(nL)1T@Gh{&%c<^~P$o!nA
z<%QBG9<BdNSYLF34Cz$%VSMV#_{O6%8$1+_<OYvk+gF{83@;w}fzAVl-Vc0L3CsP!
z4uSvvBVBzB&d1Ha7)ykke=(J)fo@MWJa8DgZ{4HQ-0;9*(EK6mOfAsN89P{x!K0ha
zqZ7ggrz4MU_HMiX4<^9I3qTPifHbw{qQYT#prJ~G;h4JyLy7S*cZL7_+nf|YXDfC7
z_BehB6!adQHYzs%JKPmOGwb{=hdg>kT~(ME{)-$s=B&X8+8o6JAHymIP3j6nAAVsR
z2udUjpovy=>%e=IJtRK!=W}=*cMt&gH@m|?r%$ta9Crir`33nrIzeX`gh_aG`bl_n
z21xJ=GN4(-Zg>DRZ+ZB|@c@urF#m$iX9SH|d31*f@C&l>3vz&rGCTk?8##qd@aSg$
z#4o`2iC@5t;}gFi2s?0qgA$UyJwOY-TMv|ogA;h?cTlU8;r|7&%^Zi*CV(OVky<eM
zj-X4vyY)SeyMp}%GfvE-^D}tB0kl%-!e{<`X90deSAl551F?=Vhdn!wymTo7`H6v$
z`x>ew7>>D1Fn}&GauNV}JB>e|%j38c*gAeqCXY^cfn)9xjQpDXhe7$N+YXd$B|zSJ
zao+FWf2dDj=>y$Ajv*j3LAgBGqdShnLtD<LTOG9G;@}S!@XWF2aTgV^T_rUh;M<77
z)9aQO$_qU@@4x5;C3+A3yaOJLhtv3T4tRFPs0e`dd35`7fDT;nu>4s9I-1)9v`xc-
z;S;|A*C&1fCl1KW_A$`iM1CJW@e8{B@UXmC`oKf;rw8K+&|W+a!vmn<QP9=yE}+Tb
z*VA9j_rh3@0S<rWehbh@Z6}!G@8AF}sp<Uf*!iXNs)uDi=q|Hjc8^Xl!=u}o!^7HH
zphV3OdEtadZ-4}7@q|ZbFo#P=(yz46tRG<8LFbco-haV*545}lBInWT^a3sqS$*Ky
z`6tw)^K7t3=Vg!PHwh>iBEs;1M=$t(B-Zo2pk0t9DiWZXJq6I>6%7W^^}pA*gQn(=
zfwCXQ!j{u)Ae(DICt2&L_;i=3aDd_$vOcEDqxE*Ft!J-`ihy^oh#q)B{&UYx7L^yJ
z4?!(d7nKM^#trvqK9b<m`2gfC(1HxeJ!Cu2fqLG(E-D7QKxegsR(|xF8i3uIqhbJ>
zkhkyw?db+h(|Wv+d+`7N>*b*K`U_|8fB#?BfR@Z?`hq&8M_)e7|M!1_M>lJs8ua{h
z&|&PI>@QyWfaKrr1FiLleOc`TibME#i$^!BqZ+8JJOCP9f4LVdi^y;w^IoEvHxp_e
zC{@P3)CTK7nAgiXQ4wl?C;N-N0T8<(YX5tK>_(UlTCV`gzs+wjicC-)qUhQA2Q=s3
zUB}_kZE6K_rsek%?#|0E!aP8gdx@5-;S<y{i@$XvsNQNmBH#iEX+(Mc{zZcyXsYkW
z{}Lq+ThJAzWn3?8z5o4xy%Xe)4i**25~$Z}!QngE@8ACyeIOmJ2THDcbhFM<1x+_t
zytw5Fw)@BnMsLUg+~uHo@y_=z1ie5K{4MEFzM?0{?<^`WZg_zbgNcgaCD0^47g+ka
zW9N|<{icizFRejwnCcBud-SD#9%=}|){hYpK2jj}LBq$)9pn_O;R8C**aLg`B!Ci9
z^N;@}THu1l!}3Czzzb=wfB#=^hp*Ri?1YEYQgAqB`~Lg?A`PUo^+3r*k8ai?6-YR3
zg2d6j7dJg2;gk>d`1=<x!4mu}poIgVgQ$MGgZ$2-@?rxhz`9}K!~|9j4ySYzMh5U2
zr5CoKpzJ*QQal$_dV}^uhk{F>&flN{*Q1-Cf19I0=b;O)z_)jvXJlYF@Pf&syI7+6
z0V8PO_Xa4pb*FKFS2@>%FGX3S0y_8Ivm4Um^R#?hq6RL<YZ*WnKeT*iWMFu~269>R
zQ3)T*x1~>EN<Bb}us|Mo;qmXkFZ}f2H7cN0d?0i5z~;C@_T?M~myqv3Hxe};Re)A=
zAoK2m%mZnGn>WMb-+#|;==m<-Hc%Vbh8&d)(B%*bAhWe$?Ue3X29I7>0m%6;Ah$+&
zfKvHU1y9Sjr4PaC;Rf4-4X#n~02N`ZFAShu0|-|UYKa0!lLSaR_iJsB=A$5Hi7dD-
zY5iaF4zx0`^u>$AZeVLblBJKqI^fpaa0j{HMg?N*DffT>_kj-42POW$pt$bl=HC`*
z0FI-UOQotFpeljcQKCWNA9x=&?8XjIYZcte1f{cvM1$Y2AAs6pg%Td!?i~EvSlAHp
z+NuE_5_1;t=(h9e2CWGTkO1w(ZT=-t#{1%h)4%_(mq7Z>FRI=D{eL|jo}N9L!6C)p
z3c6+H<ypjjW{AJ}TR($3C7j6OppfNnRR(nj96{o!<yp9A=YL401imcS103xoDhfz-
zQi}?xx&&2AtWTvuZOaxF&{cY%*%~kn+LGj=V)3E?REhNN0S`)p@4fK>tz10xLL&%t
zT0@J91UNB6rief_ngnQ?33Q1Wh{FNiscW!;sifw>3ue&epWQJk93I`=puNcgpu7Ms
zDZ67-6hLP!mxB)C?FQZ4b{sT;$>7oH2sfd$3RK8Scrv@FNHlOTf@}eK0A986x0Zp{
zwlp3Ac@|c^LDw6CR<=rjwirq9Z)1^Ye!#@P?ZC@I@Mtu+J?Z$(-GH%V4afox(0(ET
zkIo9X#U<?%noqDecDSe*yzYd=AINghgd50<4lnp@85#D2>NU{S0gbMpVs<j9x#7`W
zT;b8X8{GGUBqz_#qaZs3z~SiISu5bvy?F-cyt7VMju+oSX}R-i%K`pY6VO<7w{wM0
zcX0v84h^s_&|WYN!%H6DzxwuyfG#Tc?6v}z4yB;2_}%ip-M$>2-QFBNoi|?Vfcq65
z-3H+O&L*Ja(7OFVhs79P0v+G-{i~<t1^!kUka*_@Ps@{~S3EmGN8#y%Y;y2uZU%XP
z@mmAP@k}ND@Mx56KEVMF3XnPu&@p?UO@J@0z&%oM(;XH=OsFa(K#3IA{sigk-T@k{
z^61<H8DVYxU&7+i%+Bc19nRs=>n`!FX*B}_15*i$N4L9#2WY=_ugL|_xp4s=mLE!-
z;Gv@7(QWZUCK%MDasizLeAuJ)K&ib)vx|xb2gn5)pe1MlrB^^x2;iaI*8lu1pm}pp
z3Bup14665Po&NoQDG5#vu>OEUghzL9f`{dWk}aTg<KWTl&GA|g?tW0C#_~|f3=d0=
z(odlF7-$V9=m>{S7tqydhkYzR@V9^te0cHE3Z6KQzDRKfRWcDA9^IuC;56Xbc?`O6
z*Q0wXD9Al}_kx1lr?W!9r+Y0ZZM?Ye0@4(sVgO1Rpq+;v-LVxu-MIxI?^S@(!)M>#
zn5zt)ofka2t-%Rmxd7;JLUG@2KMv1sFAks13$L|7<rgeH?BNC-eTbYMK7-T45|B7N
zJ+S$7ntL?2f}92J|9PNB8|VOV4;<0P-|7jPMgT_}&jnCsPw=ojQQ`)QHUp5m4M5SB
z8VHHD2#?N#pv48P;B#=AT~rLfQD*>(x`fgTps0gd#^0g@Dr1}V8Tng5DeA=`hkyTH
z@_|zyXkMu^L`A~`yc8=Ew9_3ntibPKd5FI~Rgi(fqnG6>1E_HZDc%fTTyzBG*ANv0
z!*3p)$2~ibz3{gOO(Had?)L#XH^8HNGpLa8INl7Rz?xgX@wf0WGJw~+gGF5pPr4c&
z@aarZiE!+^0&3HP4z&Vr!1Q=6Gr_Z)!4cGoWb^Da@a+8H3mTgRRkl8z*F3u2I1DfO
zcAoa>76aw%)&mawQ;&OEUiRp`2-=iB<$#02@zQ;uHSkiN-3%VB2TFuIx*a$`@&47*
z@^T4_Zzsz&&t8^u9^C?<;TU0$ZXr;Mv{MWeU7ZGy`{^fx-0lGq10U@G@lmIMN3$IR
ze~T&yC^@*O7=ZQps2F&5njCu>49*ZBeGER`DJl^TE&ofTKqC(*PVlh2Si<7jX>!e@
zySf0h@Fk#x^+k*WD9L75_;eN*ymSB`h5$ClqZ^d30zvtTzeN}nlii?pK({|QZ#jT2
z$PxfWRm*qKAf_cp={r#7s{pN?1RY5TIi(GBW0U1!{+5fNPSYfFc=kH{f)#9S1_!9%
z#mHWeA{kN~gR+-L_iAwVY5*mG&JdLhQ1*Jv3d%Uy6&~H$1)xG6lot&zd4B)ugO<ZO
zKx;(1QF53eq6&uPvl7r*CrIV4C$!v+0g0pKGf0UG${P`&h(i>Qpi=^o@|in_Pj9)z
zw+3+W$lv-ATvfOWc=ob@HwkBeX1aAeyX{`E`+;&7XzxX-zi0C?4j;=Bm5kD-pxgvC
zlE0<@&;S3Bg0S_^|Nk#aZ2$d#3A)e@+OG5MjAiibX7cIOc=-e}=!{%GhJxa;WC^Ik
zjPQWQAygh(K6Zf1M-R|!FF4QL2N#i$YmY&7At)N(gQD@YDN;1r+5P(uFBOX+1tqi|
z_2~q~E;uT|ao7pEq_Vpi6p^6C4xmK#Vm&DTc1}?N34-GEKB$uGb}sPg&aQwd0>v$;
zTm#1~hy&8;(<^fUsSth54N42*pcp9tm!jPs;F44m)c%9it9L;0h$ViHfW)Ek3)-Gq
z;L*wC(J2nAR>9|;AtD&u+(Hzj?i?Py@vsO6)qnAzwx)nbFUw(2c~szGdALN!quct0
znhzrbC=^={l$v=oALj6|j8Q3oL@?Ay{uX9XCIc6jKmY#!|6;QBzyB}aBb@`|5aHPk
ziO0R5u^P~98K@kE#@|Y4{6X$JhejSKTs<rykqFt&@`A?%9(|B&eqL1BfQnT}BtYX5
zoFhRI04Z5PCk|H#z{1|6dji<p?t%)B-W{N9=g~O@+=ub#o&bue7dLD{Wy%!rYy&7-
zHNX`N#5#{|j|z`&hXRjI$k9_ETR`P2$aILYTOdbLUGn(;4I~JXM2qe~&=~;T;viX&
z1ARK@fUWoJ{Or^10k1|;+f^c*pn?-ok9vNG)T4hu1u8uLA(t3HlR!7r#mx;MUonDm
zBiMz#yvsWn7<@oy#Jzjb<HN}CQWIROff6PIs15XT-4D>B4KUxQyIkTW8+eWZ%m<G+
zfu;u@gB*lZ>$#{H@V7%wT)N<K@BuUE-j+@mm53L&tU&P-q7nhE_Kv=YumDwitsuXH
zl39jF_g0YE9>-fj6ujC4U4v?P(xVqF3aj?EfL9*)bjPR|ICh=`Reup+4V^A337|@`
z;I#s{JqoS||9NyG*Mk<|9TD()@QhElnCJJ;zL0v*2XwdtYCZU^L>gKT3Pb8a&+ngo
zEFYDy`gXcpW$^5EIm-a43He**g1SAR+VC5==40^aG<e+sY6p3CUWK$0&VwQfCA>2D
z+nqpx*ohoo1us@vLc*&69A2QUYZ~UD@PalIAh`iYOF@ANbP9w=FG@>c4fs|qP>^Lf
zcAoV(?xIov2{K6f04>)7rHj|{VE2OB4}Vd^4KyQ))P5isZf|jgn-3`5JdnffFQ~8v
zh1*-Sa04~uK#hc#=HLZH3?AKJKS8<<t3l}mw2>RsM&XCVjmP&A6%F4`ooi6vdv-Ft
zoCRJB08-50(LEJJgKYsH&;?0yuy)C1@KRA1l?Yc*sQaiycy^W?Wq5fAUVeevB?X{E
zw?U?W+9$Hm_K7IMdIL}kh1IjO<SK(lcP+Syl2O9?Vkap2x?Mo$JLML5bh=i&T#Hz5
z;n9s~FF{t-cyyvRnW~{qD{uu}eD9-D-~o18JUGuX_;fD;S3f?`%hPZ;Ed%T{4~WyM
z3p^|#<!lM-3u&n9GCVr73p_fVD_-V-4rYP%KYTmIJVAGq7`%)D-6b=@qw|6%EJ;g)
zs=Ixl868mj&BJmF*d_e!pv@TYBA^AF`d(Zy1Ep$6`2-5$<Dh~Q6qYZ%Oi)rcX#NpL
z>W;zI4qgH-Zb8SQgA%c0=M|sMH7cO~5GX`I7JycDf{Gegng<ogp!J}j+1}Tn435!W
z1~~zq-hDdHqLdRJmaj0|%OGPwX%SIQcv!x|EGJ3?(Ob+tsPPYR8*2RT12?-M!3b_O
z_kcqbl0ZE{ArD#)2}%c`iBFI2HQ?!MkncgE07?()(4;C4ORA8F0woC^P$dKorB0Iz
z;C8hoWIDWr^#!9TD9T#EkqSx}2&K*iFIB<W(t!byK9)e%Uv*9aM+oS!5peHF7Ibqr
zN+JOTFMqoaNE}vAw1D0GVm&A+bVKH%;fVwkCNETtAZ`IWl@%17p!5S;TLO1g_Xe=!
z@dgkDj%-lh3ABdSqxnUHD`?N{0mJ{Gm<LUygTe{q5YW0m&|n>?<p{C~lv+S318hKN
z3nV3VE&-33zLo{G$JkvvPkVH-d32h4bbbf-uR!4rPcOcmM<D$xkJkT={8JBlT3!LC
zmkaz;4mc_t1of|OgE}|tp!9;=zq(Sw;?Zey*`t@`G^AE3f%LC#gUc*%jnW6Qe-F3@
z^yr=r@+U~Hb32&Ty$9@Ak4_6nSL-&oN`i!}tKn@>g9YR<k4}@rFP$JuzQO0+LHq^^
z4@kJoQ2~XAYs<+JEa?UuWR@38!084YUf^^CsYyJ#E5IcSC|XKbUmQe^vu;ST^62gX
zw{<)^D=IuXJqlhPft}OTT>?7s5LDQBbQ-+0`3h=*fZW%+864Zk!POrqRzTB30WUAY
z&%=OZ2T%b3a*t1^peN{xEsmFezJXR2`+$q|mp{LQX0^aA3C~V8pH6V;@7WDHUa*7@
zmMuQ}g3CupgTu3v`DNyNh!LQo_vJhA>Un4_#O4DjrBRIl_1+*xK$S7S?E3^V0^&x{
zrtcZx1Lncfh~_$^3g~76B?$?TYdktHqVyL$I(aU@>ow+=a$g{Zg5uNF@b=4MP#?A%
za&j{0R8Vk;bvJ^O1t_I%1hXK%l>(U$>e55nsi5ow3O5hrcx-;r0P_AW@VOsr!KNJt
zH`gHHpQDoT(gPH_y{jQ|@VEixE>L6hWeh01d%@x!h^PbQS+G-}i*Q~FgI31F+NsAI
zK&FAL@POxVh|^lYYhGRof;x`chX4M*VAK8g{{<t6_@ndh|BLS+;*$=j)qectpI{Ju
z^rcn^h(7)@4N8}T>7y?{L1}R){S~bK_{$71|M<&?A;{|mTfg;&$$NDE;P<?C@E0rN
zbdVDrz8#b2Z&}0u>a>LmfQx{s3=9mNpF$7*k`Fe#eejjEOD~HUXsLo@^8<O%zVQ7D
z3=9m8nipI^ckjLP>y4Sp02$xy7IW;p+4<9>`4~&*<;$;KIuBlc<idEWGwhG2<>%6e
zt+z`IJ$s87JwQj+%R$@J950rE4h#StU*ZE^zmvfMR?}G^;M5s2l>xMfAvzW^-+Fig
z+WMDnR!%OY`A>bc`8UwC(tc1Jy-?Es_a8J@pT__GWLjfF1Ve+zaR<m)({Tq6a5Nov
z2msOif(-nE4g&mw4hsB&9v1w94hj5%4h5h!D~COLSqoV}WB%+f7aD`+Yhg`b^z}Du
zz`@B5I``9~^S6)Y0qpB<Kr4U{>u)?d|N3Yi1<jp;*Wcvpfoh3r4xesj$od<f&O<(y
z$4j&j<0WY80S<!J19*bg133Nw-8KHexAg$%q=DlvnDsyhQQ%#MlbpuL@FH3p6oT;i
zVEC#c38V=S@S+%yD^X{7BRH5CJS-tIyd_%T8B7gO4G)S~q{)WGpf+;z5eeuFuOldC
z89?)J3k*OziH~}KrZD+^J9S_ay8HO$8D1PV`1k+CJ_FEx!2>0aJi1v=u|wu5xpcrb
zxxFyd1<g~I^n#3Xg$Oo+*pb?xjKiYxLO>T3oUr*xCB*#XadAe5m!Y6KWWtNrI{*H^
zbo>AR|BHzr<()@g{tN^q9C^t2418*+`Hcfgh*%gN0L^Q8bc2RjB*4c!fd<X@gDRh6
zE-D%fFBXC_bT4TCb>}<qfa#GJaWDV<Z>UkxU;y1Q?=0cbt!u-^#NgAZ;L+^Lz{uYM
zx{kyHbjpj5iUs^U4*u4KkPvi$&D9_+iUMsfmjF$72!JgGO*K0D^qQ(Nf=;S*VPI&e
z)nF)5<lpA1aLiSM0kp7!A9Ok&WFeEye-D0_LyrGNj(Id6H2}>ZUH}^f_DwW6yxzaq
zrTy>!OFvjU4HUo?TL1oogO6XHVF!4diZ>|y0zv-mJo+*|5ETALUwQ@p`#-@k1hm!z
zw93lBquUN81T_o~APv?TfmT(4(in?JGaI8vw;*T+g99{7%i__@#0cuhg3gl!RWU3c
z%?#jUw<N$r_`D$dKy4)!Fyj(`%Wu#s2GEq*r+|O|_k-@vdZD5LN^2}CApHRz-~+7#
zz*n4ecy_a>cytCRfT}YAC`SXtk$`dxK;v2(@C04T<I#M?0J<>bFgX9b1TDA%EmFD`
zfbDz-$57ACuZU@H3s7^mI|H=Ntd>EGf64*SHO`&yUj(ZE`@f4llm9qq&bjm0i;b%P
z{)6VA?t=yy1U$YMbAT>w?R*6~+Q{_~Bx5Lmnp(Y1;Nff$kLDv5up|PW&U0aa%(lG{
z(*os$U<r@zVh)eqY6a*xlSk)KP%jiR+yq^b<<niQ;Q^Xto1_g2G0-Gi%XCmv4BQ&N
z3u3{FK*(GHc(HD;33#r+r}O)ZRhpoJ=M%X7>)Cnyg_b&~f8-24UReXQjm6`*GiZ4U
zgD)t~K*grVaTgWPq#%PwuQT{)1BKU8u>PAzx0q+Ah>AxyD3^ea@Tl|c{Nmef2AZej
z@aV1pg`zzq5RZFw)~Im2;8FwmwMK;l8kWaiWT=1w5;UUR%W@qu;9R=gqq`V<;;VvZ
zr-=$^x4uUwhi9{m3Il%&C<}w)Tmp1-o`i3w%5mS;Z>8<vaT$+pYtYcWMhWYSg&H7>
zTvP-=>qN3Sd^)W`R&-wTJot>+yO+fr6g91vN((%?L5Bxq3wU&fGJw*vgGaX$hfjAh
zhYvUrI5t31fhXfp&>Bo{RcI>k>3r|edF;h%Wr*Xycy{Vs2VJ+x_`#zWWT3!nWzczi
z-PWk~l}zyH76Mz<&EV0g;nD0Y!3atiphX8Li33u;fxY;0F=WaS++M9V@Hp-at|xsu
zYg9DA+f-hJs(|wJ@t3B4pxOda9ZhfyM=BvBQ1Z72D1U$BZ@CFdGu`Z-oqs`#gFxAG
zJxIjb)Pa$Sq4P2%ynVXMI6S%yd_ZT1tN@R5eSe{#0xIeGTR~+ED4n+4=5M(JDhj(J
z9DKS9JU|D>xPjuc^ZkEeP$Yl?43t?EUZjEwFYs}foku`JpuM2u$y@)IaDj*LTf#sN
zXg<sVGS$=aUg<86?tlW1ZYiJcBJgoEmA<{T0<U>M>p?)OEbo=XgXi+!{}*-y8CdcH
zkv?5iJm6&mf9qsWx3Kw01iZ2XpX7rGFjvDTEtg78dK`BL=K;sgE3fxJ#;sf#Ks00?
znS;Nj8|+aB4v2rQ%7O;4kAPC8f=_n=hv5Oo20Ku)_hdW<%5<X2@Kp01lxj*9L8%6G
zOtgYe=X1~Rpk;8Nv*QlE;NAx*IrKnNC#?rc)I31zFIo?j$b!bEK;_LlP%=~j9mdsp
z<fRO_;0N6c2^Qvk%D~{*dE_PNyb*AI0QCuefQND*>FGtZ%D?|F7r@ig3u#$K(Bxlt
zfrDq~ai7i)9^b!tcDq}6bhBIl-K`Ev4xkeZe7Y4pLCYClYeL$UzTGM+;6*>D85tPB
zG9ag&@c91C!}2<R>sFAc<+;)uzTGt{65wd;4p9;C>HNpPtphwJu6fO)^Lz6{MvsI4
znLV2Sag?}vH2-JhZ<`Hjr&<2uZ<)lvz|eA%zm*A;7P>j$<N1d;JT0%6l>2lWd0O+8
zz6VvA3g8mbr}NWmnU<5KJRaRfKHU;NmU5+QCLp9i?tAyb#sIX|BSyu-qnjBtQQLAG
zvS>j7vRDm%j{S?^M$i;%jf%nxOMXTM=$>;22L5fQJ-P!DI(<}FJi0w1K-rVS!}213
z%l|+B|9f_x_vtNBQFtu@Uk~Hid|bfCvIcZ?%uSGrZgWs_nAX6+&>f<}0@`lY`Ta%s
zAJCN*M_LY)TmVf$894qA=kV-w6?ka}A0PDWyz*LvU!K9U`3N{y_*y>aZvm|U^X)cK
z@#r=HO_NPf0OiM$JK!UYpz~g!6lnnVXc9Oa12jCkD?rr|e~Tp}1H=DI9-YiD|9}$+
zs8!CeAGCt=MVm5c#ZkQjd`+om=Ru#&0>tv?;|`Dt;kW~+<G}z<H{U_&#;02ZH1h=R
zw1DR3JiD1Zx;;2v>%rXvnQwXm&OUw|o}Gt45p%-h`*-lX{TYxrXujcG=@s8@C2$gh
zjDMVeaX|?*n+C0me0pnCBwnlqA30cH0b17D%lbbZbXG$RXg#W%fg`9`VgQ|Z)ytdq
z1$3yUsCp_R!;4=_Kr<aBpk40YU%Ukw*$Fy`36#){LCexW2^Q4ufh<Y2@a!!CrQ7c>
zHmNZ(ywn9BJph_l>MoG*X#OWqX7S=A*bL^E+d%h6gOd8ossH}}fALA--~ZPKJ$vgd
zd^%71fX?VR_CjtqsLnp}(hSrdQ-tcP15Iab0dtPNya`%u)_L^hK`4FO1Es|>AryR1
zN%I>Il%gEe*zL_xQ2@36r0#;MJ!cRbRKtN5gLNA;KVp3G@#p{lEeA?MK}RrkJ6U*i
z7ddz^m#7%5U@SERWfO`27eJ{+0@MU!^JunUC@}&ZJcnrLg68Iqcz}C;44``{x?Pz5
zzdi~n55R%_`uqfV7xJ?_$Qdpw9Ito1xUL9VT?kHJF!yVqxL?BXfJf(3kn3aafV5$8
zy)ne~>2TLqIe0MFs0gfJEY$`%Tz1kgMh1^&X2ud@&~oo?9~Gn%^DI1?k7$7QYE19|
z&5OA({ReA_hiWN33tIc_DF5&OYuNf$h<|pxkWs`Q{<z#f=Qa-a7ykf<K5qA4`bo0;
z=R>tX+}|jN#r-h~q`CjjEgbIO{2lCmcP!zr{QpAd@fS^?6pR||iqK#O)zi>$e|;Gx
zy}Z~XkLo^nYX!UlwE!iRWPq0V<*0ZZb5Q|Rc<+z7s5mhkb5U_-c%h2R*`QIn4i}Xa
z&~i0r1)pvMk8WoUpKb>Z@C_xPv2P!1R`DN<4E!w*K{t|HvkLtLalSBvPA)#i#NWaM
zYVBCF8iUnnGJ$Hl01j|BIta9TuSD0QJIDjnZdCE<JpTWZNAd;mgk0M-@VGkMPH6cD
zx+Ku0BSj?@bflK4kG1aY?;z`J!RFS2)@3jH0lHY?dx^x015%*!oWI2Y)Hv#fo8)Tv
z)~DM+0(2Ky8fZAd-N%|W6l@AV#0LRjr#gXr(EN;pzZG<noM*QK$4(wl;o57e9tWxe
zD<nQI<DY&&h5>Z>NGfRR<A6iUTmF_sj0_B}El>DcW`Y@S`CC9oUVs#V%<<@Eb^%>k
z;=sQxM8%nZyN`;aPq&AKM|T0ZFo|&dc95}z!=szcuiJ;?Kd4wyaQuG}RI6!tXxFGH
zcpUuC@`7Ck)LL~>0Tng;E%u;QVW4%BpgAxNAIrxj{)TT~%R|x$_+Fvr!vY?iELtAT
zM>#w#@9?*XGchoH;urAd_{1;3{9>mBD9M6K{ni7e=Rrj`v=s?j*9bCG!MF8Ei5O@r
z0O;De7o8y6L1Q4G_8h2$%RuVNOM}9?`A7k*DGn<SJi7zn;rBcS6n<6U@H^CSiviqb
z<Zo5{_y50-H7nOQMh5=Y>wo|MH@wslqT&o~Sb&x<fcgX0tS`TUV!RpDLh5$l@aT3(
z0N2m8p!E&i4jy1m0m!V*<Nq(fl2d!!zyJT6A27c31sw<k>(|?X#z?^JJV)?Z#xEbk
z>L*Ye@qrv@N%4>WC03C2`TT8bK`T^dO8@)+at&A^C>yz`aJ+Dn0&OfyQBeR@030vR
zAld^jZp;1q|Kb|Rq}Br^hdsJkAAJS+-r|K4ICYk6c;PAi@4sX7GZy}q@V}q~;@-aq
z2TSp{xI_8rl92dTcp)ndimMV81yIV6Fue4_=RBzCa}>l?cyXSUkpX-qF=#_LD3wWc
zxTrXKbUQ0Rya&qgjL<y%@(1|*2vGZW1$g-Yq<stWfW%8Sc>5MqRxpAK^Otg<`WaMQ
zFhZlG;Lrd6h6g%aR2(1*{{Hz7I%C|K0V*E=;X6PFQSO0;hk2y`{qH;ka#HgnxKl*I
zQ3ubUFJnP#kvfmQv;i;3I{MNZN+&v^6n3EWM`n3vdKDCoSgJ`L(0o95Fb8s(2kOll
zfXh2GNCBb#8I%G8AsnSIAWjOXwD^Wp-Z_KSXn@Nl2S|AbPN<;r4xC6!z~vo0fwsMY
zmUkZA!5lu_2JrGOO8}+3d;JMy9a4F>=`*anyC8~M-a$<Qmv>I6<y|V+lzK?foB(#}
zCME_3N37+Yc_b*s4q$mFE)Gfmkn(OGXjK<U<y|`?a(Q=B7!>zd$~({^axCTDOpxuk
z$~!}x<sG8F_#TcDexTy+0DmiJ`KpgKtMo@uad!h$+<~$Zthi$V7a<M|KGv*1KY(KV
zGpL_MMtQdvboc;q<=qERG1L6xKYz<HP(=sclf>T+Iu9C@l03S-6+p!aq$u&}HUyU@
zFBgIfLh$-lju&>KDCOW5uqVLnR!}(uIxPTFzD&bbzN|wpUl?G40xe&9|Du*J4^YdO
zJdpkuzeWH3fB6qowt>s_7txac{=WzV`K<Lo$wQBB)}#-h*syr9NCcEyO3uAFDGDop
zkN<&`zt_Q1{4Lv|{O6z)1M20xm@5iOJ4og4nUnv)mpCanb{+*)oseFSI4r<iTi%vv
zf=l9;2SA+~S&@JLUq5=mCI&JlSfTj=qffUHNbySsP>t1X_%aY$_Vt67&2=7qIS)#2
zu>th~(C%Aoep5kY3-7p#iVFj%_OiYJvKmXtC-nCJ{|*<GWVDuE0%UIz=zet1?i$dJ
z4O55r;1Y+wMV*;};YE}nC>;4)tUx)T+gZWY@Cmev0quMNm0c;|vJ=|4di@rZnq5IB
zYFM*Adk5lFfX>|bc8rC;RSjHRB3cT2LqKtb+){Yka*4m?Ke!GDrz@ZC3UJAm3c3W^
z)W_QPG}!#LV1w#G?ZHX!z^*Nkc(FkM;?f0BmqMNCYWUx$+d;vlqecbZ9&`np(hn)&
z9l)-91S;X1p9%1{f;Md-w+F?+u0$yxLE|@ukoMpwa5L};e+%g7MsV#68c}v_`On{S
zosj|DdIaqYgES0%R2=xX`KUN|hp4#tbO(Ujg)aQtLA5w@iAsdyw?nYjVTb^%b$AJ_
zb@);cxwPy6FYk*{Q2>=};MQTF;oH}Wi1EE}2@mx4VLM9ua3&up#b7BfLFY1oOhs!S
zW(tASgHHRE2b~w>qk`N%1huL?nvYb#+J~@le4ozeFA6}J3taxRF)=W}_Wbd;f%X->
zP!{_4|K%L`c#e-X>%-Te#KR4aX;6>itw%SwN5S9n96a9+?p5%&+yXbEkb4$~QRDyR
z4sa0$Y5(|Gvvz{bg^bG~wJ$-(_j|zFmkOZViqgIW?K}XrFF_|)!RL)YcdA0#;h?<W
zYWM`69a=yB`42u{+Zt>+gX4biL=$MG0Jz-p>HPm9K?K_VjDod4&w_HWq~O2*FKxiu
z92h!XR9rx<DM*tGnxbDe!OK6;@G8fPW&9}RvJawMeqk;0@Ba%kkWH-zN)~%`vpT&7
z<vEKNP5hwTQZnJiN&#^B$id$NDIfp8*bbJ0m5={l90#QkaQRp(0E&C0@^Q@(Q2X>a
zq<yOY8`L%W&kr7-2A7JU3I*(Zu=l|=3d|1~AU{li))(-2M{1AG1Ko!UX^%o0?;n1{
z`wS3)`-uGp$nDfrr1maIKLeynd%58^xPF1PSM5ONzmOLG_y2_$r~&|uaFv2n7OUJV
zNEpTOfx?KtB@Q$M)yNMHCno-uufIU`$nzKdQ0b>o{(N3Y&Qy32%8wLIE{2z0ECJt>
z3A(?k^9Z6I5deh^EI`)&`v3pM9o~QcU%z~D6s+G{0o;`405_!#UxIh2BKo;6)j(@m
zI*-1b2wL0MdGzH9D7_s@?>77QA8CFAJYqm{ee(Jw$R}9plS9uyH6yqs4X;y@KrLJF
zm?XSD@#)t6@Pd)S$MQX-J^|fo&dv=9R&!`Z1yzucYQ?A93EUipR4F`=@_EK{P(g4A
z!kPR6#9@V3DazpT0nr%C0_}z9h8NbZhHpV#^S|I41vEd@U4>eoRD%sis!yC=!0M9(
zE{HQ>^$EzCKHUc3`osyfKKc3#<SKTE6F-2B^uk%69QOsKF1Qmx?i<MZWF|Kx)k0d|
zGr(&ANvlsl^)+I=!IJ}&VzAUFpk5@F`b3fkq#j3o@(I*y!cm_nfHDcVJ`rO=u1`S6
zNWZwu{qO(F`S5bZ$C`EGQ&1euhK?(MR`bG!79jNrxYvfLPY^w~VvrlUofV+*k6xcx
zg3UFCnhPJVAhJFIt-!`wpEwDi)F)pE*Czs?Vj3JC_ds(Q(DwZ+P+Pw{m;>Iv2N%Wg
z_PrsvqCu-?U_Q+SmC@k(3R2J5aiY{SCWv|lQjW`EYxk=`A^}qWg34n?XnBlnd;wgJ
zJ3|%tg9~zSI}lVaK*t%bK^%oJ4_3Y_fCeCLbApz8K$N&JFubtl1=W9`f*Dl4KLs@w
zx^3;AFfw>{+rOyefaLIVpz?hoC#-zW_zfxF*F&Wvp#1&pkes6Mq7)nuB`ONwMF4i-
zxUb^?7jiP7UDBQJUMR7F&2D7@^S{3+0wr^B>|A3&O0DhpK}*+MR9s*+JjBovF3)B?
zM*bF%T2Lhci;>&lqplnnUL^DU`~M;iWG2X8p!rOXZq~HNppwPn#WHrV-7W7xeUg(L
zV1IG&x0r+d@&CnjsI)qi|C|lxuesp7i&Vd#*#j!&!S&X0M7;&tG7C;nt}XvdvcNU{
z%LSk?Jj?y>|BDmckSSUYP!LPA|NH;KjpN^cP!Cb=|9>#8@E;Vw-(S3A`}hB)EL0GD
zA^jb;fB#=Ed~p=)4wMem6L8cSzHImfT6}r*<!^nEqmRB60<E#?Jo-`*N~;<muOD;_
z2d$w)9z|+=13G^JsapkEWNdf<bf!IMeXZev<1H$nB}<_GluzgTw9Xb4(CJjiT2z*U
zgpNVhf-``YDudQXg2X@vtAWz#i#?!)EucEO^F8RwHVKd3H7Xzp)TySn`{2G<04P>L
z9ZQe~(5Y0QB@Zqt9N<J11g_Y?N0F?52(FU&TkJp;Ce%c*@h|o;Lt=UjD91y~C{P8}
zo1y|b3J;uZ4No>dU;%Z10)4uR1o)>OggL6yM}?zA6twaHbT{3L1Z~h127fE){MGId
z&=sj*VNY$aV}rnbn<e1h&VT+EP&o>!xh8`whAhYO={5#W*gogq1_>e`(3~6SBpC@C
zP}kD|v|7ufSM<hBM$lnXp51X4pyjWiRkWVWZVo=(d!TERT~s)}9R_!V7(BXTB>saE
zm;-3$IKT&VG4FHeIaZ*R$PkkYpeFa-0h<i!FmZsV6#xCd4ANZSdHgtNp9JK@9FJbv
zqqi6tZ2o)lyBz;7au}q-0b(*-%%@v7@jfGiCuCh4C>O#!1+^UFQ^*Rm|00J$9s#ZQ
zM_Nj;4HPnsM?k5~r}G6$hsc2ebde8AL<Vz!raq5@7ZX;&b37;-eL5lG0_j44mOX%m
z>0hdW%GwFXTvUP>L8B0SpdM#y5x7JKol^pCA$#=7-oDAm@X`T34h~BjFF|!4XuQ4i
z{fi7{Xf6cJL!mh8AE>}X5qSd=0hKtB;1w#YU+#fsjv;9roFYNHz16{q5|+xq!jAk?
zkH4^If!6dM7hgCk94}Qu@h9A8pmPmj{a1`|k_Ma2-@*?n4m!W1Sn@)S2~;Mys7SoH
z!VIzsbo5d$B=ig~y?AgHa*v{fBWNYZ^A`>8Kr`KtdL3^0c~B+d#sZFvm#@KV$c}pS
z%1*h#$na812O^vVT`8yy<{y3e47>&vTu;K5$#vVmXaofn=r)#4XQVTn#9pifmA0)1
z_*)}%{{06f3(z@UFCH`g`~Uj!giw#pr;s+gZ|7OZ5Z}%t;0f){>mHDD%cI*>z@xKQ
z02KP2tsMXV|3@mxTu*>z09iM>fwlveuJGt|-QaQD6|_8n!Q*%<sL%zKRWB?+4(kN-
zL8lUcV$%q;cC^=Z0eE`4RRT2qZj=iO9ScyQUj({g>Nw~UhjXBV8$h>Ad4d)>9(M)p
z`C;G}bnO7GODauzA<GB~_SzXBT_K=z;d*(WI)PlX7j((JM`v#V$l=FZEB^lnoruH$
zx?uqn6rhEpFCH-b`~PwZWIPjUK4>vJgHLDa1P`cP9^IuAJi2Q;UI>HI63FQRpyjgN
zp)))>U1xao?gb@vkK?Tga0{k_L|#mJ16r=K7bN_m1H|qIJCeUO9OR&0R(p^ukGFzc
z2?`^R&Q^4n9&govnrZm|g(}GQPOu0(2tn@Xh1l>d8y0r_Eltb}4Dj%~1`WSM5dXDC
zK#k-VYy};b3kpU4mJZMwtnRG=AeVLT1&O~<1tn*YZ@+?9LQVzg^XT1c08-KkHpSz3
zs|D0BkItzei5ClAgZ&H=elZ2a?%oU5*SQxY1d1YIkaIu`=#1b$a7%YD*k;6Pvl|dm
zkoS?)Zi0w{ViHLdd>=3*Y)hbqW`Y&gPC!!S1{T^2N|8vS3SiON9Y{idK^0y%*k>Ny
zdqL?Eo}fEjS9tWY_B()5m+OWX%~_!B00y8XmRz3Tvko?b^`aQp2Nr^u)5{v=0J^>q
zHJ`k&&H_apgR9|x&^ixZ&^iy#&g1+o&S0%5rYV4hV5YTeVKMD(CTPV?X#?oq^3Lxs
z{_O&1j~yP}p$$mB+zzTKn%{8z-wMjmzMU_9J0Ey-gEKjJ+1~vZSHVF84u?peUe#6h
zj12IAfP_n&PiN`|k51PWFDf%ZKB(Q{)2)GIhcl=dYOULI1JptUCjkDIt)Q+!XYC4T
z(1J~XmKQIKL8f$q7w36EUG3AIitK98sSKXYe;oMR>ox!V2X*ckTsj|mTz=r$dEBGB
z88q7hnyc+#)BN|}!y0_(K^eP8Czt_V$ZK6Jz~2HorwX);iVd9YnvY4Ob%y;o=Jrd_
zqqCR;yi(Vvv+hM&ryEF+#iJYSbdbLwBk}Pb-L5B)DqZk}XT7O6qCqD)fz~d9R_lZA
z9{`tE;7kUx$fpyMy^e$P4oKu>7pTuL;YIYHzyDvV!t2Wy-hcl7e?2P=Rv*2v2FZgC
zZ-R{bd2~)?0F{<1fBydW=mxW28iFffNdM#oH%R@pzn~+xLHh(fI*-5j@%!)pmm47c
zt{1OCoD8@;X!Y9-kdPBp{xpd56XZ5<{qkZrh!5=of%-SALHrE}`Pm>o`0fCR`fd<E
z3n5<(;=3UD*&x0gf*%dy|M(4a?+fqWAdf)`4$y%*$-hC(Z*VNU+=m!{^XR<);zAFo
zuTaeK(iPP0VEX&_|I2%-|Ng&JQTzA*WjbhCbLZig?NGWGN-u)aOQG~RkdDJp&H*UR
zp#Jaw%UNpw{!efW_v}3H80On~47Mu0^Qz$`a2?tFM!}^!MJ3^XiAn_M%4LZc>wo<J
z9|ht5^Z_ls@#%c$+xcM^Xebus;C{%KGEhp5jPq!I!RXP6NVcy)cH>C4C7=am$B~jO
zICX-PtV>7Que8p*ACOHzuvB;$mVQ9iuIPq@)9cG=(E8r9^E>DoMbqonj0}#UKD}!}
zC8J|Vut(z?&>2^dN`EhCovIILRrOTxos6BmH^8IRtrx&lFK7bFqqFtIKP+v6R!}AA
z(YX~=nSje8^yKf++4=w!Yc?#Pp4s~sTRK5*gp|;oQ$K(v@H-EKvK_Qg{{kud!1W2D
zrZ@){ZG|YG3$YWN=RBH!GxN8c2TSh-yS|t8hZU&6+zYN&I$J?C7IGbSycLwMKsob8
z$G^Y-JvzaBPtfS;0sa;)9nc91?_cz$fXX^hBZa@^Bj|Di5B@xGL*)#pW`i_TSX3B2
z5cwRrrfq$|#K7<(^T*%+KHW<}UI7nXo(6Tinsrnd`CIBh=L2-3*M~D8q9FGng-8-a
z6jrrD!zl(Vx)l<24-7APbngSTnLNIK_vmf|E%f#5yy(&S$*Y^?1gNlVVFXnL-5egR
zC;3~xf{N$vLJn8M1D>6iU#o%ELx85*TGhdZa(c9a_lOpPP6z@mO#bd^d9hT?)ACE{
zO^<F)&*lS+9<3)!?}5t!pU$};H-NOa%mpnWh8BR`TS3w8)4LVaqV(zf?$Zfwa3BTP
z3r!|alKB2&VLK@2gPV=uUHVhOF$cO6MGAcDu}80{h%G2e-@n+l^#A|X1CIPtj(K$N
z1(}Q#PKS6vQ3fkeV2y-5JfNwAZ~QHW;9Uv5AjkT2f&*+PXg@1Bz#2h4EYHph9-XJW
zx>*i@18fo`z&txIdvq6ayw-rOtMKRs1rL8q4p<sFh%WHAhJ(gyEWecA;@=)9;L~{@
zygVA>htA6{X08PJQ{r_ED7;^IfBXCYr3SoweqjybGr{>D-Fra+2wEt|;L$6pV8O`n
zV#gAY@A+E=L6ZsKY8{j(LEY?sKHZRP+6~FO-Qc|I(GAYpFBrc3{~r+rtyfU1wP1Bn
zQx2tCgQ)Xth9qxL#s*~;pU$P=)*B+hd!V)?Z~yoUYT59&w1M`ubi-PbpoWJByd?>W
zGLUH=ol`*)FTx&ztOv*B3$KTuh87~b+yR|}eg-^J2O3|8q%)6haFU0dmDlZ-;L}}}
z;nCT;160I#egoAgV0j<ytso)8OP&Y+vBEd?9QWyN1I4*dX97o>OJ{+APv-;A?;kw6
z+d%Q})6H|iv-6TKD2JTo0xdUW^z8f$UPO&_Ue6lPxjfyV_0tEz>!&@xfAF-t#NRpv
zBo10XeWvt^XE!4>TX=M~ZU7Z=pcZx|7X!nK)~|3kdUU&GcxbyNc-Y?mFVDc=K3f^o
zhMNj1dp){)L1nK;Z*2qUp05YXK}Rgrb};a_E(JH?TOlPKxKFSXeB3Umi`8p-*p!h0
zdRnyWf)_hGK=-ym`WuiS^60K@@aT1&;9+^Zg!RSGFCe$Hf^$T7L57cYK>>eD2<TG2
zUN-^HPBxEjaBs)M8XUa*Eic&^7$Cx+E)3{yW{+-g$HueMjl-iGY>-E@1L#@_lxzks
zml`4E(gmMh$gU{l?A8n}!Z|!UFM+e0A}pV!fW^`BnLlX#k>#_}TRxprLC*K+1_v|$
zb_W5EPH^>*2J<kq&VW@GjQlM@pdbWS8xd@v5(BCNtj(hnrjUid#gh+|I7LsHfYt|t
zs+o3B95?@F;&0Uhof8Sop-iCCv{!VF2_wS`v4xNvS_e8huDcanb9P5?cy!JMS6$W;
z{4IWpplEjf-~lZmJKrOfi7@+nSwTm|dUUpe^4yDnIFLKRb>@pLAEDVyK_0Z7?7c^4
zD=1UJ3fkVK;M(IjxT_7yX)iwC1!;yT>iq6;9LxgAcpL}UjbJ9E)9%p?*5(1}f4<mx
z7j&u5`vd%%U_CEEW0mmssz)<8*D^r$lyHIzO$~7d1`o>{{4FiY3=AI4U?+o=fJ$_z
z5=n8;t&hj~TdsrDc7v6?SO?C!;DR5#Tol{^_Bak6hk!T`+yZ`~2J%erUU1nVb(ewR
z#a2*$0(JBkftI~DgMGw^uy`)WV*VC?P<OWVHh(K<KPza3=DK&FRtQ-3r4gu2J^`AN
zz_(Su_zw!?&ej#6tP44I6I5itl6ZFqXyn7Adje>X)}wa^Xl&P`djmL`clLs|_<+m(
z7nz?y&5Nm^f(SIAxe9dJ6nL|snHU3u2e=FJ|Nnn}4@*e?YWG$G_30p41Jqov{P_33
zPbXx<;EO-+{{HvuJOFirPwxcK=%z>a2GG8B52PLTpuK|(;A6+;f-E-t@6+1>QuA6G
zTCR7Cfvy(^4G4395B9taO4OYnK`jU~k8Vc}&;eAvEEjybL0#U`3qFtn*SC8c$P}MW
zL#TjfXCFj>!=u@ffxl%AH>hyn`Qg!d9dxia1GN6~=w<yW4XV2#wLc_5BPIA3D$(F0
z%R!N1xdxOoz!kVp_f}9#6{&VV18$m>Hh6T0c6c`bW8`o7!~z-rIONe;y1)Z6K(cck
zXp~0`Tt52rx-I~pMefmSy4-*fG@7*H#nR^g|6e|bPOG1I_xJzHQt&|)3@>(rI8(mC
z`zNbG{8<S8Y!E*V&W9H8FL|KnrT9RyGo-Tb75!rj^7Qu?taBj+!c<W2rk8b<0azH;
z7{Uw=(J1hWL)NvR?NXp#^7~Kxg5ajnCw>9e`38&(AU-HnzmQt>@Bb%$0dSN46TiS#
zkRUkWf!hrH+rbGB+64H-FSr&|0)65a1h>mx@Gkrh)(jC801JBbLc+dxDX6XaiC<9T
z6Te^q$BT_O!S{#5n%6V+L4F{jd94Xf|KR4e2dIsIfWPI9EV$5mp%)1%lpxJ(&^kfL
zIF<*0-eqX>`VeSG2~s*iZe6z|fCnugJ&kT~!g>+=0a`3d%YqUSajlOVH$VkExEy<N
z2E^{33u>&t6a|f}@#ilERdbH~f@uOTg&{{5g7zOZGlN?Fux61*=Uh+`jpWjoNs#gc
znjV-TwL^{`DA2yY_&N)e9!fp4SfLU0e=DdB2W`IjbpG>!guVyXhFti^|NkB1B3|Z$
z2LeFTKMdf=_UIMmhgvWNVu3&w8`Of=bD{0@?=YpzdW;M&av<s?ve=>OUKWAe4L|Py
zntx$>cIq-Rys!Z4;cw9Zhd)aDbS_9<0wUk~fQ^A6ixXz96v*5O9^hqJ|NsAI22W&n
z9`xvJ1r?Q`9c-E>JUUxvfC}4#KUh61FYvd>$TEP=Ddlgu3ab8lc^Et_Pw=<z0F?o)
zC;3}Jhtql-2ba&FZE&uJ2SA4oOa&Xkc*vvIOTeR(%cHv&G%D+1-3uxR`CBf5%3rWB
zC|*4}y#zeEdqLx}$G}Y_&`36j2dQqnI6S(+`aHU)f}H8m2{sIT!P;d|0|HVkdUPK2
z?EL&%Ep38Fr=dr8k$^{Mp@0Wy#;y5~f=BZ~1&_|c7hp{-AWgl60v^3p0${a99+v+~
zPk!dlj}qV)j1+i%5>h_DFn;y-|4Wn4@N!5Q#J7U;J$k{eg_d_7jGv&bUyn|3W9`L}
z`hWjlih#>BaQc9jQ_y<Dqw^>DzP4*Vy$#?tZ|CtBj~0REHoy(2mx-XWp1|ql#p;)!
z)*(1Uc(mT;Z|MfDFNKs4FXmqbXB<$<e=!-t1~ofgv|k1Fo}a&{2Z?oq8-X63Hw-WN
zbT@)(N1yJ6;1=Nb4<4N-e0z1SfSTLgu?)T-^OHaS|L@st?b~@1Jk00M0XuKl99&Jg
zd<NCnejJ9EJUf4Sbe@2<yLCX~o!>nyZ<b#1=>+$8Ji7UPEl=~etOO;~){`ZoplS_t
z><*}<Uc&C%$#cb{o8PmO^Tl_tAE6D`6`<;z@#XDLpc9HfjTTVL(x)4Iezh;-G02HP
z{4LhtW7`-!x_iORgHA?}L?@#C+W;{p6MWE-149-EEFTDg#=;Q!3z2+1y7z*NdeQk3
zG+qEs)gHYb3Lc$c8$1~gyi@>>*@5HJqgT{Yi;)3V-GGW0P+MW{G*G$1-(t!ODp<iy
zT5#3{Pji8FKpV!;7Uqi_h=$fHpmf;{E89gtMnik*7?l%J+wq0(TTt5u+%ANb?YBT{
zr6FzN7k<GYXF$sLJP}AeeH>KC|Av<D$D!prsHOqsIDSD$lMi&xXbY%`=+V6uJaW?w
zu4rD=zJiwTV&F|j;9)|KPVl%jQX}EG1jt&5C}a`~G}aC|7NZ;7nDl@&9$}>{q<i+_
z{3S@bJ$?zCu0a;R*bQNW8rLt@L)f6o;l*MQyL&FAX%8*~K??yqj)R-(Ag_RjptX(p
zH6deT2mi5nG#_Jp5j_>u`@iAQE$!0{87>1a%I^hbB9BgRjCoidE;V`?%*Vh0IuA_P
z19T--^DzO>&ae-joo+vTpu=pSRkxPl4h4UU8Xu@NeGYWOHP|g4owq>8VCYr;{|~nY
zY{lynkn+Vxdn>3sgBA;3y*>u8gyzw`7bF7;PDLMRc?>C|Uz~piPMP5HwHsV)gW?j_
z81?7|cSQNcz)9Dq)1iQ0(;>mbdM~8hefRPI{};W_{{DaY<Rd6+LC3GXpZ@*-QVZUm
z0uM|b2j?wEP$q|Tt6ReU{QnQiu%PX|9^K%fCXe39pq3}No_GN2ryqA^00EC~e(>eZ
z5P!l7yl(JGu%4E`N`!r&zF~y;2JBgAuN6|(gF5sb;DV|Xoa=o$A9#HK2<xrB{0<qs
zhPWTCeq5-=$nZj9GB^{qM*R8zKZ^^N@1=hH{|}1Kx!~~}(4i|Hy`m{<py{RiFP=^U
zX(=rP9nS>ypW!8+&VMM)0%&8vqw~HGWMJoo-lPBjq2@bA8=iEG*~blPXLR0wVKN;w
z7Y%N~y#$@*g%}^c{*niLJSD{a`=Ac_pbBwF4A>$3ttFre7j$<TB(O0Z1Is#)1`3j!
zW<5l>DbnzyW7IzIw#Ux<FBVMu|NrG~aDfOaH$mm9NB34xndi~n2#(9njSvcaZkr(N
zB(sg6xbOrYU<N6p!N-SrcCx+f`vt2X)A;lEg6eaA!7725+KBUQp@Hes`2*Cm*$g_(
z*t7E<=$M4=X3+k4<Z~9XKov!|1U$)jb9i<h1`UgX+I!v7;OY;w?i6%_KPZiy02yQX
zi@z1LkHOROJZKyOk~F)WL5u4=dPN+d<KA#H9VC2uO)hwXuEuJ;T~Z7i5$K)^8t?Jx
z+zJ{d^6B0RDpq_t*MbGR*MbItVB?PP@jjo<N4}jOp$&VF&YQlSFMK-xc{U$md?Ee-
zG|=Z`xfIl_FFoVa4K)^Qo(Hr-?sl~B>2@^m=se`3c?fju@4??J9@dTy{4E-skPg2`
zuZIBm7BxtycY0WObRPfAUk4t^hbFsypkq3qX@MWo;o=u``~dENcxwA`yjVR2RNhIv
zJPbaomBC}j1JFX5|NrYfARX(Mte`eEqCV`r4@;6s%8U#z&h&#a27fDP`w~*-@ag<#
zcnOj@pt%CtbVf>ug7-m91#oc~>Cww-rp(9?hr7qM*ay<%vQ`FVgkwIPC_OG+WuzY0
ziaFpO7kJ3x6TiSxP>;*-q(|p{SeWoJfXouy3kv>E{DMnCIsV0>$>6RQR8Rmch|$%u
z_{1-m!12QE3<JZ<iQuh-VE4m<Bt(gk;l<8ANRTLkhkwCUHiHZQ_NCxrwv`Dqn1v(b
zZUrSIL_k49&bRZ!i>G)0|Brx#r*G#6s1ooz7G#1Ls`SNPkUEd!2SITdwGTAp=+gNJ
zH0N|=5~94hfmFWxbe?$W4PH|SDQ}<^j&J8Z&+d7kjTzt}+!s?H{Qd9Qy$_T<L6fzh
za-6}l^N>epgn&=yXP?dr4xi2+pff7E+d#S2r<>)1XXi!mY(oNQq_Ud<JV2{40d(9A
zXzarobR08yeD(k|tAb`P_*=C>;-K-_^QBijAY;j%-4fueEzSX|{ja}xc^}l`1*dtR
z?gRxN>jVw{7B(J8p73lwA_2O>4s?qIgCoD7i^>b1PSCZl;CS-rWqqvx>fwQVqtJ0X
zq)y=rTQ5+{1k|Si-BH582-*_$!n4yw<prp|h0f`Sg9aR-Ybg+OU!owFL)ujyy{tR9
z@L6-s6F!>qdKRc73?4f0fS3ug?gNr_n?M~RxWPeq4X#BPJPE78Kfp(h{RXX}1hwH>
zKY}(Lq~HAu8Er|M;L-e>k-s$!B;O6G3Bi-4y`q-je0TrF?QTfwb_OMy?cgCXP@aZ1
zMiJ8vkS3c)FKd`QD8quAT`%r=fHIx{YZ+J!JrifhBW2>pGeF@2o+bFiF96QV9y?aA
zf&h>1xB#E-GLKLEg5Y=ssQ~42&(1r(nqNSopjykP^O48FU(6o->o0gf=P<3~BKTYE
zxfvJ?!DlOaG#{2o>#Y94FX;Tjqcbi5WDck>;D>q)(vSMYFIfEoBn2`wt<(7jNZ`W@
z#}lBm0-Xo|XI+n8*9{)MwF_XC3aHoTy5PkP(EWtn;E7qE?gS1W>jVM*mJi@I6nN+v
z+%N?VKWj^XuTli1Ur@2l;L&*lbP6MXOEhTk57skh2Q{hM{XvPa^Ztw9cVGjKpgIY(
zM(cnN=G}}H96sF~K9=W8EZ`OH37^hGp!SXdC}(<rt^okuiP~B8!K2gbhll0y(kIaT
z=c9Svlko@W)<F$l(8@zl`jqhKc3t3M4XJ5b)^LIb6+!0}bh~Z<No#m?yRPu<tWmK5
z@f19|!R=-c+ra}85FX8-tyfb))hW0xg4UD!K%?}~>gt6+AE<%=x1c>bC0;7N{r`Ug
zQXNA=n`hY#c$+8Q@T6nJK3-@uY;EuV|1VFx`TyU;@*?QSWPZ1U9-y0pp>-eUC&<*N
z+6|CPz@zRjkGuehy?-GD5d$T=mzQ6FD$#CG<LITxSFl=8>&d6L0X+PB987@<P2bK#
zFW<fV{~zQHpKfrXLGlJHZXlC{zMUVS#X6_}e|-J_f5#{ys(@V}h0!jZj~wHm6~R8x
zLIsc+`+E?Tz~$FqXM*}r9=(t?Opq-5BJ(Jyoc;bH@hG^L1@hpFP_Wqh7rqcNa1YB7
z#D+|sfRnYhf@kv|0sa<mHjw^jkW>xMp2)qfga26gp<S-#cZ@IIfF_k8hIn*K`1PhJ
ze|W70T8G*V?pJv<9~1EC4Ex~G>GlJ*e4+WU0Qi)P8t~LEq>p9|9%U>&32p9sbl!S#
zDf|Eb*OxqYf~rEu9j2%GTbj8T7#w$jGM7i|?Gka%T^}IQ^&Y(}(jJzF`P&Y1f?R*y
zqjM^_GVW{zxA7pw$BVw3psEKf1M;3vH+W@)Pd8YRXXioCz1o5-0v^3S0s{Q~U7-8^
zK$9Mz6b@}+f->kqP_OK#FXP2D{+#1JogNMzoyYk#9SmMNeEa|3$MPe8%XM&(4>r}e
z)6Nszxda8kAz0rMKJmB!H1U`YT2KOSczSgEt^keY^nyw<A5cDpv@fAq?8VHhpqQ^+
z04l8_<2=A~j8kubJO)`j3BCca<;GuF&jqT_@Z>&0(DuZtuK)jEP6ef5NUrvPwvD@?
z_Ccn!EhBz-bQgT^;CGAo0ZQzUgzM1_&hbzaJvwi`-~l@ZY_Vg6V<f2BV|~Gn%W_!B
z@U8Rz|CfRwH$a*Q(7^TSya>Kl<D5tD4p1}X#kzjbnAzc%XTSgd54xWZbQKhM%GRe7
zTyFb7I`l8hZi73{p!T3oH&_NbwF^Gi>$p!RSd#~A#SJ*tUnE`!X@bZ=dRfr)@KOLY
z%`J58@Bf!BKmPxJ!2x1D1f9s-&EVVl%v19iY%p+#W#3~95c28#1h1-g950jsAx7~1
zNJl|Q0d$Mh6;Q*mmq*A0>KMyY{O#a5(&ONC0xDfVo%2?6@JJE3V)0?#3QE18r0NO1
zh#7R`q$9r|n@8tw4{Zt1-QEX(vGBJvf((aEb+LmiZhr}~xbyytS=W#&7?6HY8a@E3
zPhj;-9Ow#QHc<6q2`j=nLDdU59}``_xM}!yx^Z}Rx}jDsis0#Nu;2#IPB#ru)#A|&
zo;5q>x&gEd5;T&>;MwU0s%JoH-nX;P!lTo50leCAa{w0@CLoiV-+1`+7HfFGf}YP)
z^N#1iH_Sf#>mR@;`{X?pk9ha8Jn`vV3aV9ox|f2&(W5u!Z~?TR_t}v@zwU-3zo3nZ
zXSdsnH2(MhLDic8xSI4l?gl!86V(2!y8#lG@a%T`0KO>>)GmdJuz_d|&u+ILAclfx
zx0`@(XW0kO<8B~D435Xx7(fyhp51N|p51jHKpY1j%kL$uFP>ciHOK32fE#oDpj>$c
zB+`7$!?XDa=v+zuR`Bt+u!0rbd-dpbIlu|NTd4Vfheszkg?MyBT5zCKmqAMtd#`}X
z0dRuy=$;Fj^6==cT>vVt4tOwwb2h&iL}RD30KX=)hc&o>=Wj6tC3OEQfB(N!|MCC7
zC)6dLmiPEuFM@8a1YN-h3Nt%LenHTwoZt;hkU1Jq1p`jKopZsp5n>_p%XzQi^|l9O
zkqoFPWib2(D+u1Ug37YFpk@T9iSX|UXgtk90@U)`32Q8ZyU!Oq4*meO1P^-b421wz
z&|F1J5h%BSmVLB?_HOo?FnC%X<8M08%)nsy4YUoXRTrdy@e?Qy!EfOfWb(B<!r#IL
zl7jZuLFd;U@aR16aU9fwVeshY@Mu0D;n92ubS-)Xs7>{PU$E+fr{$5-JD$yNBs`#F
z;IJkwm#^j#tjQ2GVBnkmM8cEt3#e}cI?zhY2UL!21(jAW?py*z7?=$mH~>Y~F;Eu$
z<K4?r2C8B_z!!!&YVZp>O1%8^2{a^=U%LSs5kcQTTe1#-$9+634|;%FK)oyn;P;1s
zBmKoxkTsCH@a25a9O*7dAcnGfSb|GK{+2%Q=u9ujRiJw(LCbT%r<O9F@aTlh%~&4f
zZz}<*$_9^MO1!YY^!L9f;}KBUra2x5-#ZRz09)SUZ<z!d;et=!fC|XY@1Obetw3Sw
z(R@&XU$F9pM|aT=kIup$9+sC&AA2;vh6n2|XykMGXnyuM_!<=Rx8PG-@*awpJ(>?Q
zdSu_0@L)U)>I8t6jf?qoeuqwQy=c7%3RcKuS2o!75}<HB03v?F0-8VPIKQByhX>;Y
zk50#km-|2e|Nlbf!r%Wd?}LU?g)aR4@6ik%0cYTE<$d}8|I72BW@0yFycyA&*96V6
z!Gf(5vOetK4;D}>za;_`2%zMd2Wsr}%79mGw0VIzotHg2?|U44&hp|1$fnMN9<baF
zF7!PZPxy3Ncz_P2gw)gE;>Q)F6Beka!0V<!XHb9=s{r_h_Rgvg9-T!$d@MhdKJm~7
zH`}2@0-l}6JQ>e<bb|*-Kur=*T`la<36Aj>As{z&gV~@kItWUD|2z&pX7Pa3r{HwR
zc+;a3JjxAi0lqZ({vWb%{AI^qNHSdT^Z$QG@a(*2_CE=aPH=kxR!#GRErAF@Jmt}O
z>}4Ei!iFD`qU$tX-uVe?&7bh#cLz1)Sv)%rz0~;zI(zio>op$7!K31!F73-Q(0;|(
z3xEF`o&*ms>;+A1T3+_xcfa*=(ZB!ycY{?y$I?N?|H~twUUBE)m#6=Nje7}-vlrUu
z{{DZd{~RRp<z*D;2vf^*KK$+<U)q2cv-H|}|6*WxvF*&?{~o=z_8|5u2-_IMo_FT&
z{}($?gCxOC@E31)f?A*7Up(E3XnWrTi@kqw5h4a|dmr7&zyMhTqYXCB)P^6_%RUae
zmzEP$3fnM%POY{*`;&p;g#}27<pmFZ_e0Rx+?SQ$Swh=&AZbaEBTP>J{r^HA<dV+A
zFYSMUW{nQN41m&4ptJ;NEqLegmy5yt<1Zt@{KGFRq4cU>fB(On0Ofpu(&3<$@tucX
zK84a3K?~yD|3Yj?2Q3osf^sH<IE$bh2JoWa!!L`WbUhk98Om?|_xJzHSs-E|h`0?R
zuK$FX{v1l5gQ`sgS?~<X`2?l^{R6dcj=a?U|M!0y@_EpWZ$R~MM~I3s(iW>0@a-&y
z2S6vii-7No|L)QGwe#`|<FkMNw;m|f2cLWhQH8WE;WDUw)p!JCAnM7=9^I}S9^K%{
zNL2;~1__T&7M0T7pp)A{Cj)bMbmpjdfDhOA=*>|{0B`5?vHVfu<Jo!4r&ssiLPqF4
z7LE;d8Vn^$j{Mu)6daGaX)yS7f;MkLH!DK6DLVcSIm+PKe9XYt@_Xqy573cUpf&~g
z9%K*D;o}LQEDgS!_l3#%zyCdUK}K6vF@egWb_F&D2GD7`pwo;6JoZ6L*i}B7A3YBK
zWbxo%e-2cmw!Z?^ik<IYC~XG~kAQFLJq~vFiwEca{s)~83_3}~r`ObRAtOVlkBSLs
zMOv#jBLl-re-;J?X!{Dh@zTdy_s&w#rhQP|0;(k%YE+ED`))x!ZE%|bx;c?w6LJL(
zhz8AFLw2=-Za;s~_2J+DmIM5)ub9AR3Y++VZZmlQqWHtV|DA_Hr{qR}WX~`$Fre-5
z1Ragr`3@FzBF8|xN&`S4#0}b}Rm%Fp;MCv$pfkN0LCcA|b5uAyt#eca_*+2dD)MjJ
z0=}~dwyD^o^Sw{!s~5gipvIAl3Wq_%9<V$^i4MqG@N(DQ8qmgtchERH)&f!B)A=9O
z4HY0aK!+m1H7s}uFz6NlOBWRd{uWM96$?4a$wUPdYM}G!D?p(I3LWq&xXv1t4AA`q
z1t1a75Cw<^x#0!RS?C0=J}A3(*MROg23>TF80Y*2TGZK{qf!Cd*c;&6`j)@d|KI=r
zF#qtk&IHw2y)`Nou7*!u$ZQ1_WHl-tFNC%-FuZ&STPF-k;U1l@J>ac0q{OBPzWq`F
zI{M|ozy2U7{k2R1`3qDRg3jCafGsuwoeu==_khmZ0Qpn{boM)lVFB_ohygx|*#~rP
zF?y`{biVTJwUK|Ztpe1HbWsuTusq7&(gj{0|J$?kc-jO<{%z$NKApcn!zU9e{{MGu
zsMla9QFi3t=B@yZD92;&pzQV!bOufYBC0%_j~jS2A2#r@{9C#cK6J_D(froHLpw)B
zz~kUsP^NhS?{x5cC?56bb;)J(IQW3Y19bU0DBD0U1cx=y-<<gS|1*Cbc&yDu#e!eV
zMMVRYi3J?_HCa?%E(5PX0NtAbO<tvS;3N)9hM+i$0B>D})Ni1)2g*xOuXyzGTF(LP
zjP8J3`2*Tk{a@rDG$}H^yaldmLHn3In{yc$`CD1RyKvvXP(A+lKlsGS7t$bBCVYK7
z$O2Hpf?5D~2PmyWjb#9Dy+%spFT+6VE#<-MC>-~Kq7$_2Q0N4xv3L{|CK4Xa2Mj=7
zu>kQjUV=_*f|VP4A3#TRUY`Q3--n#4@UjvXE@<w7Il-fM3;4QGq&W2G6`el^yq)}|
z9#}WnJuj?}{r&&)4?G-vLHXXN*T%u8^S@8$OHg|ZR3LVOjz8)2Q4s(YZY`j-sV{<#
z|NReE4Jt!H?&k2dd{>eHN|zjn^YtD1x0Pvtx32$xp-=`&Z=iBr6I`xC!w_D)_wxRm
z4cdKOqXJEK|3wahig!@T^R;|ey4kl|N5!}GE$Bj>_b)ab0}WT?fKGUGQ4s)LSL4I@
z!iPCWMFNz5ID9*ER0LjvNA*GR3mOmQcf07*s}tmT@F~m7D)3S^2L@1n;s9l=m!Pv%
zU&tN@wOwq}J~A-8xOf=MKKqY>;l)u9yYukNQqXRL&ciQxe*FFavIxrY`0@8YY`z=q
ze1^t1pt)p}`WCbW7_@B6U4dWIMWp~l1b|OdaOVKA6OOg0v@$R-FoL>VojxiRpj#<G
zX`{fSyFdU`JWXv;X#)-Sf~K8JL1k07Y}<U$feQEdTUbH-gRhuCd(;hJWu*hif1op$
zI-i4VFnIACe6}-x3+Mvlh8mR&2L4tNCeVCSzK;s{b`^(XE-D#};AZQw7L|6eb3iwu
z@@x92fQ!f$X;8zv7nJRLLsSAlCwU8%{r}IutwcowypsAA=xX^2P+}-}@uT$rfABp#
zFXWDbmKHw(&+#4i>^%D7ZX@^t9uEfo)*{e0rEWI~@O?Z!of`bDA3%0AGc)qH90S*8
zB`O)7op&5szVWw$u8;;DQ2+`|q-M!#koOypfWjPlA&g@zXw&3j#QO1W@Ld2oDh3{w
zuS?u~dR4n-GBP02E9U(?0$A?nIRd($$HVe9X#ESwC{UUNg@N1=P>Y~MB?FR8K~8M}
z-D?E83p@gJl}`XDU>QJGyZH3#^3P<1wGY7dDk0wsWPoXJ$WaEE#pl7MfiDL70&3`Y
zzJIasFlg2bnyz8d2Ffm4pz(zi6@!=FU`cSkhsrZR912QSEo=V$|8My1r6XwFBz%4x
z6oW`E_q2Rp0=myAbOy-fpmG`GJ|k@51-;McJtVvWz|QUiO(%E0fAQ+j-~TTg!6g!C
zzfE_EiUi1S0>?m?HhEgUD{=7Y)qOf0***n$ICZ`Qr8dZM9k8kj8cLp)?@BL%O#)lD
z8ERcM$U0E90$HyE@}C7rmBBF=6%PiG|Lj5KEI2;Y;r8^_s36_b<k8C;G96T{K<g7w
zq<C7sFFge|2yC4Z)H)uJb*f<Bfx{hC@18jD_dob%ffwrzK^pe%pe-?-hhG{&>BKL8
z|3ln|T%LG#{s{$bp#+T&q7*5h^bR^HAxEVGl))1~g&Oou-uEwl)qw7H09|<iI>H6i
z=<XKq1hthtAlC$(nh84b?iff&0d&Ag0%%JnOv%Mp9^D0?^V(i)1}%8(j!{Vf`7y(_
z<s0Oja?lO~$f3b3Dxi+?VGwZ^bX`*c+!dg0i$2{279h7Ncyv2BfD0yO=*`2OAu0x-
zUIIuq!SUNMM*h}#P&Pj9q5{4R&a?9kSUqeAWR<7p9gtcF&@w5|xB~zBL*QD;5~K^Y
zi5~!J+jTyFvFre7_#;O}1C$XJz?GE;C<s7~JpdlD$vNQDnW7Tl*?9zPHYjfkzD@zn
zA0IaGY(8S(VR^SC)DfH}8>%%JN}hw*3jg`HIm4PwpmvFbM=$TKX`q?%6wsv<_rPsk
z#|}{7^Sd1SFLDsnfCA~%V1yc4x*BA!2dKPu@aVQt@#%c#`2QNnnI52kb^sL>jy}D*
zPo{t}fCJ?IFqCpaf^a$E-~lV3YWITzA_f!?IVuW1y}CV9KsCqf5^HFC1Dx)O%3q)$
z0_QIUxasoyK~=Kqj~SqYW>`QQPC=*ng8Y#I@=?NT_6d;k2IMPepI%+QDX{(?I8c>9
z!FkLXaxa>LN9R3g3jrl(9|o1&rQq@}0dDiseIS29?v_pQFlJE&U29V6@6mV!lvz;g
z0`NLxk8TFP?h=FlFQ<U>CQ>`#F{rJFDE~U2zmVAb_dnzckAM6A{(o_E7bMgE0<Hb;
zJo?fKyldz1%P(O5;g>dG{!uW00_^;h<~IsRS=L2G!tg-zFDCvL(D5MUR-pNiO`tlx
zo6Vz>9aR2+k|*dw3y4qnTX%zGn~x|M9sr-P0<X`Se=(O{_UP6Jg~Vyk&L^OANq4A#
zdaAXcsRU5X&j9LQK~5J)1W9MYq+9=&K!l_Afto;|3T*D)zyDu1gXcN)_JagpWbXxq
zY$$_AC+HR#&?*upM$jEHpz(N+x?WaBP!j57e+jxfc*2X<yZ`=wJp=B(7q>zD`7e&_
z1+|eJ7~uCAM!0mVd34L81PbVeD$o&2AeVerW?*pXeEvcjlyy5@R2;y0yzax_|KRi9
zUOe6jiUk)?*>Mak1zO7k3N;50@QjP~3&q{gt{>#?nHrE%P(K6F^#dJ$1=`=T{V!+-
z6e!E~)_|_ne)fr9&_%@nB(>x(XoZKMi;Bey#d6RJjv5t-Py7N9SsxV(MA+JTfR}Lj
zsBnDZ7i3X+!K4h*DZrxgiC@46(n>{KOjT;>(R?HV6qVrX7ac&`Yv4Lp?D`AZBm?FP
zu&BIV2D*Q7@~*%CUxGH2y{Oy+8Q?kc{_p>n=ih^Z;qc2dAkGyK@e4$-d;kSEcpafT
z$KeTx_6<1vJv#q_ZUB_<=-wB=$iRRS2OOZQS!`55{sNDjcyzmSc=X0gd}{!;xtK~=
zJi6m0K(}i8^r{^8w7gSd;?u1S>dyq70`HwDVQ*Lf8nO5X9hc|^4I4He23_P(dKFZ{
zflP)ZJ7rLGaUim*6yl5l`1t}aX7Bv_|Mj&OEuhHkJo+;1{onscH;_(n3<LWp801W!
zZqUiT{4E-wc4N2x3xiDz44{c)Uki_J(4_QXpYCi6pUx8=-#_~HmRx1<?7ZyRZ3l8s
zrAN2EXXh`E?oy7|s^Id$r`weQG&d3N3A)|ul4s{D573tMkDiv7OTB$Mk9t~uEWPc~
zUCQ8NdA+0xG<qiP(d`D>x&9rbri9bCGX!*PdnxGZb^*^$Bak($FaCm4?fVyBL3DF=
z0HY^pV}6OIN4M;u$)Nq7%#0;G9-TKJDZ?@DFsQvSW5?hBuU|ph1E37t0pg#9@If{k
zquAUJwi&cLpf}jV!}3CjjwkeFhwf5_mwDi>DCoSd3$O3N&S`u-0iItyI*UDCpF^Y<
z@JSTi_8`}5y|4$l8hTscacA%_gvW8vRse?Mp!IJI3?9dwK^tQjqT%re(O(Z9XM)7K
ztw(pY2gp1KSI(omS^>mmeeqxisHmw1A1<XH{qo|DzyBw^n7#e)|JS$S?t9S<;_rd;
zqYopc22gp_{6@pG^9M?j2H!Shq5=vk77x(9cAX_EpqT1>4w^%U%+oM1yf`=kbX**0
zk0pZ#zbk0)1a!m({H~BvR?zJ>hhO~K@%KL>d?06Afo|3O5(>^%otHhD-&lBb*9&yJ
zN`MZe1C2{5cyxxSXn0uHD)6^xfl_C00i$Q<A<xd=(7A#A;DVZgp~0i`lWXUN=4bXE
z2Y<2o^zvNy==|lQ`N*S}<wEBz56uf6tq1BH_~jW~K?6tA89-McykPY0{OZzq(DU-s
z)^GeRAi?H$j6R*8IzM_`e&pHB>D#JZ67Ioy%Cl1tbSOya;m(`j(``UU+jR4&cyu1}
z_<qTQ^Mr@usfHRA4hB%G*0YmE#j*L9eMy{S^C3o;&QJ-^rG>C$2|fiI(w_Z($wLul
za>+7~vsyF%g9Zg(bNF`tb=+akz`)S@jUOublEbI-*FKQg%VbbLV}eKXagO7zkfhXE
zD}ZK6+60fC2cY909@@1G9=$9-K!dU^7NE8sDCR(QlxOEx(0&UOk9|KNYWY2SMHoQg
zF5qE#p<Kqp@{|X^`$doDL-rmAU$J@gvVbqg1T_N%K!czHFWR<&8ZM;_KAn$1x8iAj
z^0oX@A_^XIJ`RdHi5E{mNxwTpMWXY*XRnDkXmlBJ+bQVWK;O=Xh6fzM%U54ZLGop<
z2cvK2h28)r&&v-wPk1!HXDo36-KloTr(4eB@*~I<?jGMS`EuUyQM~2Z%IV4PdcmVp
ztoet1>0!_2gB%{s$2cHYni(Ddn+!6ebdP7}$L1gQ{4FA&RMgGq(Rsp$^ML2~3!aK6
zz;V~@E8)ZMdH{67ijU?4pH4Q9UXz0!+MrHV>$kc@h>5R-;Q6Qd5Ti%)JH`@s&u&Z5
zYLf%LorgRwKj^&a33B9556*)g-!FJ5{_t%L1?7r^o}G-%zwP;3K&xw;4>LCZvM=2O
za<1VekTIn@K@*P_KAqn?LqHd<`GD^K-1_%FG=@Rp=W*N>v|Nb+bbbwo2Xqg`aaT}0
zGJxs>0iVuV1}NW$@rO^RuYgCVs{&>MgoLwa^HC1N+b>JN#Tuyp*z3n(c<JRsa8DO>
zPEzMbh@Zh>`0^yEuiR@Z`<;Q|#m9|*|4)Fgr{ag@<WNx6sNvHMI*eZ*v<g`B1$eIA
z@&td&D$vMy=NHe;e;%6ez^x7+kjP$Wx~uo-wPEnE{K4NQ%E-U~>PLZs0h|zDC~pB3
zZY3%LpuUlWN9SR$UKR~d66Emd&F1jvX7cD{G4`~4!{5>jx;dk_MCFG^uQNZ$9?cgX
zogY08zGU`j{vpTT_7c<--0=sJ)a5-|4?<5>Z9d2ds=H5lTzutm@DU3nd_ME%`>-<b
z3-U07mqc1#D18f>)o*_O&!blabXG5eN3V-0g9qa+56hn=Y~W)9nS6S4j0Jox|CEUM
zYCiV?jr2eB>HOu(`1ghHCQzH|Z3zdciDs}F<Rups4p2AhFldJKY8rpeA<zj8;3YZD
zpgY*$Ck8>><I(!RGz8Q$1V^~zUJzw?8+s!l_?$<O2>9{|a6JrK(bM??QQm?^#hMRr
zcr+j40Ill;tv`74(g)PWusrX<?{?m^^Q`B=r_3+wArU<nv{|2H1E?_sO0f(Kj^Uo2
z{~?VA&(1H9xCY&H{DOHE^m1O%lw%plo86N^qe~v$#T6dCyFpDF=z$*KB^y57n?b#9
zkItiz#o`G9FFtPm3!a$i1P!-$XIJ=i7Z-SRv#5Z!0DkrD6}jfodEK+y2)wOO6x1>8
z=JV-}<?!tG<nZY{@mdG$U!QJJvxC3o3@BZ7dvJJk9y7cI-go#Fe9`6>aKbv^1KM}!
z(do+I(W&Rr3_gMkbgQfexLijnr6+iHUh(X_3cjJN1$2)C(&)V9A^vvI9S=UeHsJCQ
zbcBEHM$iD=FX&~#$6owh2O0xy1`nxsf*Q}=-JoLM<9IWO0##a|xr&xUpd{G~7IQWH
z?`n9`)$oAFaTgU(T!OD!5qK>NiGT3D(Ttv*9G;ygd|NM-<T!%HnJ+@NO8R!5_URV%
z{Qkwa^?(Ea)Z;#uw>&zpd3IjppK`!K;dtpG(DA%dAR}52ln6n#>v(?u;$wNMgvGa$
z<(g+N%Qw(aYU`zvaF1>w&(0I@GY5QIFO^PlX!&0v<<ZRusx1)OJuI)4uy}UzT=VFz
zF7U9dQIRNNeG#$&6cEW3KApt{FU`QE3E0OT-IGBy*xV2m0gp~dcytPYjw2{B1eIVM
zpbXF9*~xS4r8uaLgT!m6F9Yaq%ubD$pxX@K<u6$6%lDwOPr>Ruy1}6ciQ3g*tGZpm
z>-TwK{{8CNsdLQ(655`fOfUa{I;^nqXP@59;K(`-jx$gMflrlv=?q%JC%*>NSvdYu
z@d+qHfDC5{_2|4B?9urdw5IXJdQfb4gZnh%9?eHMKqCvFw&?!{2=_K0;Q;kP4@1Wb
z!1~G&`goz41T>{s!ew{>WDNK`(93K8{)cjrT5O>9d*?OK(Pw`hLqa_|zk&*1jGi*6
zaqrQ+BLY<Cb=H6;A^w9pqU?-d2|S$>{uVj#LHVG2J*;1B*bD8Ucr;g3FqCq7K)WT6
zJzC#_+X4Jj4ucByDTg>OgIc7}ImwTpi)nB3w}MJbuue$r3mTO2>3q*G=n6XGL4aS-
zRe@j7)qr2n)xo2C11NC+2UPfU=5l~iBseF#dK`CE0j<IST?Y*+GY@)n7kGGd2RNkh
z=N#Y{bQJ(4MKMS^;9t)LDdc=XqNVR0za3*K^>l20CgIrpPoh-ZqdUN&GgQT+J0QZN
zGt>e!tme__Y5<;R22C%NfbYXJfeeHcdNdzVfE5deA>#`H5+0qQ8n4%aPBjG|6~|sG
z2VNrru^+TD{)HSU!GH$JUj7D^r>$>GWj(rCXS9Q6X-qjkfrc3@UU07a`yag2@^z;N
zwBmk!^93lrJvxuR{QMB5!v<dA2by;PciX@%=H@p@^F<!rt^q#XsTH6s%IeYi9&~SK
zEyIhaYe7{_Eys&H5QYH6{O(u@pYB`*AIsOJ{I9LS{%Ss~;AwfcM9-t!`o(&%;%bf;
z%ODH^P^{hsCC$?7FPv6`)-!=smtOMdb_LzaS0dxlT_N$J9IU(+ynKLbAE-z3q6Hih
zwV*a%3F`~9HGlu_14S{Y8q8et_dn>yK^~vZr!PUPWFYQ1!T|~J!{G3Q<rh#-;i6AB
zXkF+ZkM1B24^SKKJ7`(BXD^F@2WYW0r2YsO@a#79vAj?w=Gz-6;A44>zXfEWZ#Rf@
zq0Ifor{#bDd-jH?2te**=kVwa5b&_PSYqqh$)n=Y?IGX^p05L^JOPj64&bsFB*t;f
zL4d)h^MPZ`;j{^cmkhu8be?~avhMHy*BjC%eCE%00Ihy?Q4s*$jmqG-i=Tmk;U##h
zBWNBC%CCgAw?aL-^E^O<PktWVwFRK?WoxLdU?_F>=&p?baamt*f&#j`)&au%y$T$Y
z5+1#-8j!WxFF_)m@4?|2`%-!}sBB`01x?w2&V$rm304m_di6fgi13RatN#9fJs(n^
zfNO9LPzM+?K%r1#>(Tl7#Z!<j&~nUf3lGReS11LOphssc1Ee$pUvKNc@WOcI-~X>)
zOz`LqknrececJ*~;(qVJN!;+jiz6#wiTo5&@s&0q_(c`Ss?NipmQ(A25`K?n2F7TR
z<00*h7q`K_1KmAc`Xu@=d_4|mEFW6jVO;I|%`MWQgwLb9Ou@slRD!<+)b{WMU8fCN
zj^DE7-rxU@pd-FHJi22QJervp9XpRTKVWpc@UHm-qhs?kM#s*h9@eoM{4J1c6`dtq
z8Na1D^5?Utcr+hYNOR;r=At6N<k1=Yq4~idenIC4E}So1I6rha|M2LH1z!mXx&s(C
z@(8}{sTp(+FuW<pFAutgRS!hyGlJ@Q(401dhjpn2e+%fIOOIaGf-9iW05@==^JqS%
z;L+*!fPb6Y50B$+A3(KI^MgOlCm1_Gn*d4`Udkcr$!=E(kItJO`ytKS|I9w1<%B0Z
zz$bM4;BRpQ)d8TsFE@y>4>mdO)62u)V|jwV4SXMc=XZ}zA5j0p1yn<qsBpYkx&oAn
zN>n(&;po#1k^uGYLA^cDnFox=d>DU%!VVHnurT7^<_HQrkIp~=enH0O2Y;X;<tX7}
zdAP*T2Xw5(A#ncw%%2Y`ufd0J@C$lA_{^Ul^nqV6@B?Tm=OZ7@!@j*f@(Q34B^mH)
zSMVj%pzhJ@<q($%fICE>M)YwIanqx-R3nW)=P<vZtHjF;c>BP&^<-(F<4#bSWcbb1
z@c&B}a86_Zmr~#xbs+h|qt{18-=h~ax6)fH0lIiz@5Kk_fB#>C=D}W=fr6vgw*C?W
z!;4o-{{Hv0{OQT>_S2*DpU1&xtS@&X+B=|Lk!R;WXlV_uo;^Ie;}kr)%TTXGwlF;K
z%{9`Ygw4Y;R-&W=G{Mi|*m)G3FyDd`=2J$;&LbX{pCReevzyJ8@hvDpdK`BKuP*mE
z?hH;E9-Yn)__sO#00%cHZQ@9n*FY%%HDRWK&X31Pm!Q?REg;3ctT!)$k|lJos`;=2
z%r2PS&}0e82`|mTVGAmD8GOL$@)o?i$P8bF4Ow^X2QnWsUBWwr@N^087lV=?Xb|cJ
z?=nd2b3l`1h>C<~=W*~c9N?ord>DT@Ha}$qh178;NM`C};@{>Z0b9F`2qY(Pnly!^
zNqBpWV7m0gNSC0z!|@_`Da2(0pc`{JKuHpOkOpeH%!H>)P`@q`DOoyzgU*4dbQuA<
zE)`Ukb(d<qJPcaKIt^rbukHQw3=A*47XAJ20qNX%be;pJPtbA2pdm{a28K{jGYmY)
z2-<^u+#Ni&;Bnj?H2=fkaoioe_JLoMonO#hf?w0!!0`Wz%Eh2ou(JoKsn=3;^Dk%;
zF9Bo>zov6Q^MeP?CpbEs6F?2u=-9)}>p{(F#u9c=k?z940BS40_`c%r{}(|E{{DY)
zb~b2Xy+`+s6O0TDFYK57{eO&^A^I?)zY1#FUIkV9e>^&`gBrLmek}l5e+b?Yv-i+;
z<?ygPRGtVOF_&C`y<#^ZwqlP371U7oBG>0<KudO?F)+ONzToeFSonb}A@EgN5-5YF
z;CX=O9-SsCFEs4_{r7+l`+}OSXF<dP(5x=MATzkfgBZhShm7GLesOs*xE=?$>i-76
zSTYM#lg^j{$|lw`KsQYDw<v)(X;p)^@Ro>sbiR8rf5G4X&7k`{U2pt_+$1moGTC!%
zAt=n8e}JRx{&mP01S@16X}5!fN2dm;tp)05fP*>|)GP4-5AE}}NPujywpFfSWGG4W
zu(nmIWn?JH@UXTG1c{h~yAZI8liq-g?uK5R1hNO|LgowC|AH=Le$5Up?+p()c7W>B
zBOE@R4`Ll-;O)C(pz}+c;lhr`SX3B5X$h(fUVxyEH%a((r*rspv-@;D@X<T~A8!%_
zjRJID_vrlO(fQZ2^DC&(0TnXuKtn{Z(aw60UK0in%Mbi*prK#zqJQvZCoC#2)-42$
zYqF?-#+*1jIuCn-3Ke!=%{M;1HNqSooh-uMy)5dW*>{iDOZCRStxxLnd|MBcI)h^P
zuuo^H0KXWE3csc+$O{snFh*Zb0~$f^yzc|<EgV<^ZU}>lGLCvRpU&ei_!j>C|9UgH
zJ>2@OG|1KPo8j%3RglUa(mnzo3-!(iGzb8?nELH}kb}Wj#vI^pDf|Eb|Lg7G@OA`G
zQGy!^9=*25PBSpPFq{V}7|wa{yPfmwJm-1v8S~5kpz;Wj`S|4#^NkrE-Fhh=-H=ud
zXxuFVv|=JgMd6r>iUNa2XN-yfs3ij#iEe$%-{J{Ms@<*}pheM;1<flN7#IZjTQnI#
z(@Gw_rV~$tcD=uUF#}wnxTtV|Zkqr_PdexrW+qU%1zNTWTIY0i{@?$g70(W!1$hQO
zo$ow*Ls%I=tDy~Ebb@av1I=W1gZj4JAu1LgmM{2QK7t+KqvGIUd7r=KF$3f{qeGym
zx#-aiy3?rBMMVHK;s%<nl<)wZW)2$20gX)?fW{RZKpq0G8a>9&0P5fxcv!wKVSP~n
zatz32pcXl_lWPK6ebws%>P>)>3#ftuou>&pS{XDI0LtYGpmlWuAQohW9f%bH&-whV
zcAzo&<|7&K*>+HV1cez#X(427zyBOiD3}_Y1%=yj&(0$+beH`7|MKk>P*DL%4<O%x
zy?7H8M<CxFhWM@%w9cwGN5#RT^ZiR@ND^{^u31xX<QMc&5qOyZu5`flHK=3O04hj9
zt^Wi3E!ChQ!p`?Ed_ai?Yz$<o7davrj6oB;m=W;+G`iIdiwG%3q=<Nk5)nrrP6b5-
z4=D0F!E??fDp(_ezoiE>Ci8mk-~TV0K<O5o&OKT$l}Lbw>q<gFCE{IBh=EfCIBkH2
zlaH~8Ln8B~EJ*+ExuAL)bkQxy+9{xJI`|-jE|6s0oWK8HHb4xAgfFP$;LyPiDiAC{
zNkZWDDl~i3LH4HNvsVus%n<Wl{GR>y|I0&=At+FMc<|?e<L@Ob{*FQd1ttF8fEt+F
zTvSk9GULTOP+;r;@69^;ax0X6e+j%83Su9qAqwg{fyRljW$ETx2F5zA7p$QDAl)u1
z$muf-wB8y$eL`|SXwyP(jEVwUF@T)yTR~%-;MC0Dq6tdro$p`B&jZcG9|hM+pb=eA
zqI*3Xl*U2n6f=R%2VLpajhVne=L&<GS&*Dw2wI8>3r3s?EE((u{0Zy{XeVVCD1vS=
zfOaCdKnt!L$3PkI{fqmc%m6C7VFi~Ns1@T0OHrVLO9qd3E`V+<!{Qy#6e_|yO33*I
zXTb%Y&%&EuN?2d)pM^;4u!Gh?2laq9sS3b~DFF}58zl-b9(tkm@)=~kPa1!|j|#Nh
zc>MrTWq|UZ3@HEcw=4!_`_6YSB4>hZ1(nKJ@?a1+FM!4mklhB`QE_j^-~W)JFJw9>
zS(uuF&e-S#7kx(a|NejJd;wJSA?F*s<=zuWRtAlWG|%|^|0OfXcJzGo5`2{vyd3cd
z<>#q0@c3arDEGn=9Nv686%=^r_PyTl;u$E2I*-2eJOB6p%Pi1Vo6e&zJI??8KOxwo
zx10mCIlJ5b#fC5c|2I@~FqCp3)(5<Zp8fZK^x+Ax@#|1TTb>;>PH@bfgYiZB1W@A<
z+{X6kJo+L7<e5&;kV=Wei`n3k%G$&7IRDfG9nKsr2TFyT+rf=?P_qj>yaNia;whjI
zutt?ioA6>bNE~cf>1L1ay%#_^z#MGmUQnCfqm$XA^BCfw;}_Ahz#Rq-k8bPNlhZ)!
zyF5Dof~NdY8W$R%#szD8K4?ity#VN1DE^inP@@g9LQ4!(8}))}``!>01&`hm6^R#{
zKsl|uRsc3Zic~pY2c^XBS_u#6JSvjZ8HkjE$8lHCm;iXK7qm)02$lj_(haf%w6OMt
z?-bCq#`71cpn9Ua7QFBRvJNB717rbwNf>DS4m?~6k<|bdZ4W?cxZ6cV177KuW`QQ`
zA<bV%`TXMb)W82<UxfERU)%=qHzD|^LHx-G{_d%N|G$)n*XJ)*gZNqq{%jE66m%s`
z<MhA(@rSo~9**!{23n1a7T!+a3`^tizB>sL-e1A>5%J+|01EGdX@CFk19fCU9Oh}D
z^otVsv53HDcmYb^uTM^Rkv-+_|JO+29S!0mg}3(<)bO?j@sYw?8^i~Px8O8Lcn5nl
z*Gn*Xbp9?8^5}I2_X0qjOGtcsbe9Wwbk}pdD4q!Fl^x)3nFHE%*<CH+(di6ola`zY
zkGCIvacT13|F8Ff`)3}V-(M^SWr1!6a5>$205qM$zz7+Xo`5vK3Lh^8l?$Ie8sEU?
zfH*w5?T~U@iwfvo8PGPy|DcJ%GL9FAr-1sBjQlNDptFX$odv!*CkXJj&H=Z}Ae-xa
zdiQ|uvV6hb1F8>?f;JR@8jqmUUknd8HrS|W@lOFQ4+br|a-R72|1S1S{^Otp=bgu1
zEbjmNA2c)j-s5{Ihezi%pUz(|>_PYFfjR&yLAG>*rtSD!=7QM{0v_Gj9N?D11ke<2
z?-CWzwZ6~=u0EYhR6x7zKm+N#pxC}T0aRUturh!)7=dL#E8X9}h}HP_-*JZs1E?Z5
z{N~Zi3%XDhwEAudD0%d*Q4s*y2AT=zT%!UyG6XbVZh4Wv<p?MgI(wjE9s(YnJrK3v
z`GFo4@ajqEBmroC0JPi_JgM{l|9^WA?G}iF<{#qxZPP?RTj2J9joJn3FM0Hu3SDDh
zc#+T#a`YS(&?p{wHllNm3Z(7K;Q?~PA&|z-9;g_^4Is5If1L)^f}o&h@aTlZ4gWUQ
zomGqspylN!xk05rL>Lxj9^Dxnh6fsI89*`Q!FUuDW()hFG2{WdQ|Q<W#y)Ti_1aog
zF*103H?;&&kcgTFx^)h8l1(_c9LxqUXE+E-!JRIk-7GFD5ugbu=n1aY;I7pn&~a^`
z#gN^m|FanxJS{))x8(7FmU$e1!3Oeqw>2p0e}k@IIPRj70II#f8Yh7cQtLI9zRJMx
zLU$4<7h5;~VB~L61f6)*Ysv=_7o7x6t$Tz(o~=<y@aZlFErjE52?uEh+4~*5s}{7W
zmcPXn6ei8=j2@kkBn(O>pr8hw<lXuH#kDX0|04}BS+;<8`SQ1X7GhukFNE>vHPrzh
zn*9F7s$Nj6;Z8ZbK=<3=NIBra2592xgikVo($5RwKG2X2$}kr+5rNhn#DToo3rRzu
zgJV^D|Ni%Z<%!+^0eFV!h9n(ds3X8xp&OEP!1<@!g9CE8GAKcV7k;9-L%V~4VLzl0
zJ^Eta1kmup7D!&}4Um9MR(A$)_*y>WZ}|txCEZiNS<?q})IcX_HfV|p#NYq{kM60U
z%Va^BqZ53stZU2L5*v?hh(|nnTOfG~d<2mYC<}M*fu#1{7D%oD%lzmERSN%KT&QAT
z@afJ5ZKx_y17+g-J)o$_U<9RR=Bc2RQXJsX`N{*-U_AQbV&C8YFJjt3>7&{MGONYk
z!U8(grrVtZGW*5C-|`u>GaH;TYE&{_%mqa*D50Bx&M@z8Jpd{mK*I(e-OivS&foHz
z6Fh?1dHnwbaDYPl%PgP(?*?TC*gg!<>4Kmh6sT8)$Q+%mkW=wpR0MoFOC>;E$_$^*
zwcuU3%?ym7Ypy_69(Pp$4Me=)g}4WFHnxjO255XD1DsDfTR{tvJ$hO9l!N>?6|`y}
zbRP&vZ*MDTRf|WbYl25_>j!YR$2G&FxAg{uS>Vyzx&WlE(=`Be<QXpm8w-O+XDi4E
z{%y_)E0{{cJi1*KJbHQg@Bjbr(Rhl%jRkyz<w1{5m_^`p1zK0s2~x<acK`o>&`87s
zk6u=(QqUfSoFg8ct)T7h{DQ5Z{teh<mJ&mc-c|=tsPyt0fei0#1+_dqdRd=5f|vk4
z8|y_Hf6h^UL5RxE_b<XH{Qcj0fWKoqIBP?Sm)T%;F^5Ozs~740VENXi$3STyL?r>#
zD-rkTHNAcTR8hTu;RaO@3045w{ES%Co&_ozx@$n1{=+&+Zcs7sj4T(ZLgsH#f{KBc
z=0e3l=^wOlk7GY*ag%4K-iw^xzyEg%gT|it-yh)L7MuWDkaXZPe}1q;8h?JYfd^==
ztwcrQv&U-BZZ>{FHwS(}w*Y=Yw**l59RLpkcyv2!@QXPMfR1Tue!<8u7$)Fx@C7r!
zV4Q{r=u$86Nk`70b^8{b7cRW$Jk<PvrTGyD=Y{4I%pKrM#a^VgfINQGquW^kR6B!=
z&A_Ol7j!}^0B9A>&;hOhIzb)o?^{80Oo*kQ;I%t0pnWi{pmGy@EH9||z6m-uryIOU
zIRkVylqYCtpu2#>!}5EHo=+#};_!W-RsgKO(qON}-|`(a-j~z|i8Ro@e9*2k1>fFM
z$Y_~QXF&nD_0f{Y2HKU+dcPP_v+V~(L2rplhDWdM<YGpK7jcQ8ecL{uy+a(J;WZAA
z?pg=X5_Sd9W+%`cYpxa`r+Ri?1ve$+Kn8Skcz|vSQ{xBC&wD`c31b1vAm3kfmA~~p
z7wFXPFQvCUdNTz)K<kRET?P1Ccd#-rKsI~Sb%O>pj)1I|0JqG#Yr#DV))y|_pfW3!
z!4o{Royy_UnJNHU$o)dQ^Y4F;<{ymZT;H4%82MW^g9{q)QZWXP?j7K44Xva=-4>)h
z1^LK(3i6?Q3UZDz_*lLzvG(asWdJq1{>+4~*@5mV02MGCKAq2A7@z<D-=p~`ho|LR
z(DDsPH3+f+nv_4o+yT+}7aRetvY^tj8`4^Y_hR^4pMyfH@d&7Ki8RO!9=Gn!=73jB
zkbQ>mx~cVT3AnMQ(GDuMF&k?e<o^A4+@XeOtS!F)YA(Eg@f}>w<F0bSRX(mNw|5P+
zO4$N#fq_?<BC6nC(JW9Ifz*<FQTg=$|CcTYKus*jerIsg1k}F3;W5w}ULMft{{C&C
znJ5u9kKR4tDic&w-<JLN-_`K#%f;X`uNlAxq=PcfY;bSWfy1YJDJZA;bXRbIGN?VM
zf#%709JIKQp$(LVK7r4nIQAl`1(Z8Izkl(t3{ep%jRPgR4Bzft2DEI)-#P<yBil;w
zNec|0`SU#l_%$Jo*Ozu*L5Dwq()|lzP|eZ_s#H3UgYrfz!_WW!Uj`onc^kAYxVuJ0
z0o)FFF|z|ys!jzJ=Ac<Wk8ViO0NT_JI`;Dz*dZRhdqK@-&*N_3ZZ&kx=TcBJ8FcNK
zBfp@Vz>EK&wBH$`A^>WpZUP;E3chDa8+2j_tntk6Vd<hGz~9~pI)||r)aZhw0pSi%
zV7!8^v^?@+aw{kiwSwF4oh~XGKHY0UZDWt)tsn|iNrE@&-ezH7FgyvW2tlh%J4;k7
zd_m`b#DK=dPlJj@1yCX7@mdD9KCfHMvs2uoo582k0(AaYOE(JxgKy_|-)=L{Zg&pQ
z=5kOpK^oGYj7LGukcbv|Ir`qC^Vo|WO`w?a_+FwS;MvP^1#;wZ=~9pGtstj?M*0*y
zJI#GM_ky{d9G=bg4E!yZK*y_e+T8Kzy!^Tq-rx7=wSAb!$nauGH@LKHQT_tDEROXk
zsOR2mdkjP!XYI~o1O+~WM<;6yM5GaPUKA*W9cQhBGLM7h7#JGtJ&v<hLIpjJvz9@b
zFD|x#LR9ou8h9y>G031^+nz!Oh8N~-fB(N+`5AOR{)_4+P&*aUy8x$~jbHx%e`$LV
znr=YlO@`q&kK-*Wpk+9qcmT0M)gzeQxkm-GO87-fH?;d32HLL%YWZ|eQ30s}P52am
zdNp89XNU@TUo80ek{9O-Ks~7%m5LWfL9A}b{zXu3gD7@U5qPn>fPvwqAL70OSl0sT
zeo*L3cv!n~cyw~`x6T8#gCNZqj+e2&K<CSXtC!CAFPNhdRm;l-KVkU>bYLFnsG6VP
zWAYss()jbYfSbRbo!9sU3nX6t1s~qe0G?}ong1Q857FUx|3ab|)Mm@(@aUZbIdlS2
zPI`3CQ31DxVC5tOD5yd6UOv5BATpp%?e`ZQpc_1T*QkIFZt>_9Wjg`NA)wQKUVzs3
zfE0sLgAb@7{0>ws?YIFt_H_-oNb=|veRmwJ9+YzX9{m6Rl6^nYe8Fe_{0aen%{}0T
z`AZK_oP+C0xHzcM`*JH>9F+MbJbGofoc{kGv^LJ8a|S4WL1zh01m#d@_Y|~e22|=T
z2JbrsP5t$nW`d>zyDeU<Yy~InR;GQR9RB~s%RB~#m+e16cThMmcz|NZ+LeR9H3D>u
z;LaZ)uPg=U`s3it4@y;_Ex{TufBgo<A2fl13e8^D>)?TVNK!;jhA%?F7t4W{T7#EP
zLVK>Drekl7N&%=~0PhM1r#sM&mVy^Sd9cLi0cPz1C)XF&AP%Vc__FHb|Nj$wK%*A0
zaRpesLWUMVM+@+RLS3T)R84^EKUkdvj;9Uc|Nev0i2^89_KGr|g2&Udd;kBxT)*cp
z$ovu&3()3Z2T+^I19aXkD4Sc?sA!b1zBmU;G2NhJM?ljIpp%7{f?I3fKYDcbf~pxr
zgAUx51C^VM4?qiUK|5-}eFe}ma4~TCXW-EcZoxBx4tsl<^bHgt3_jgp6G3Yo!Q&4v
zv>QPuzkGqE^B2+}{uKnD8^i~VWJA_jz4+bm_y5ZtxV%TNsr*p}h8HeimxDX{t#99h
zPE&>y6dt{-|Brye;lEFJ3TUVSOJsI{&TsBE03G_+YkThq1B2m#7b*3iN-IPq0$QGc
zMktQEs365>Qw}UXE5Iyhd}f0<-PSKN-h=)7nLockfM0V9BtNW%=Vx$RE*@k_^AAS;
z)^p!LrA4&|5hb5gBedkZ2HK)YWXX3m8|K*4AXYcjv3#I`{?4PY67a>kY*2f-6;$$q
z3%ce9Or3}Lw}CJ8>~K*LXnydQ^Fjxh`%)TIMoxH<T@RWU0kOgP98%>kYxw)$qqo)q
zvf2RN>puv-Uh%jCbkUFlXfTVx<G2I3%72jvE|xL`US0whfza{J&dV>ifSW#0ey^=y
z1|!3ZD=pwm-=Yht&%UOEDjnNzAnG{l?sRy4wgw`yF&(rH9JCgVbsdy>oE0Pot<P3M
z1wD?lE`u^(FxG)QA*z)CGTJm5WKgf|o-7827wI5BgAQl_oqs+RR114{iurVct7p${
zF;MR@z@xhroM9lHe<$oUe_Rb}&A+b-Uh{(rMh)LilPey~kRDSn*dmWkftO3bO*3eC
zbTfmBs^gHV3{;qb>OOE0+RLhZ2-J&%r1%$$K*t?}?t=s$#|0e$2F*(+z>_$7ku^UP
zmTIPgS<qC|k;%aD@;E5d^xDQBWMFt9UIPj#+h7oz8^U%6vHw^9{r|$M{_p=6qSc^U
z|M1IATOo8em_GW_XxrcaFDGyN`~USrkIus{=Yxfhzck$jQTA^u=(MW*1Oa}{CEx*_
zm-gF1GDlxdgsQ083hF@}eVGI0gUkY%G#AP@2dh8)G8IbCfzlpOIvZ@`;g>Dj|Nehz
z3fd6cdGzHH(B84mqc68X=@VN(ceU;K`~PJxh%g2XrFR~E`4+7F@XO2FK#dnje1P^l
zeTVFK3JnI`x&pm{y|V_?_q7A9^%DTC-a+1T(V_ynK^{Dq?$OKo=l}y~N9d0iicO$H
zdh0nnJJ~%ukAk{doG*AmVx8_Bp56HpzTN2xK9*1UTYiI@roE<-2N)P$%R<|sFCK%6
ziB4AzkLIHao}g`Rmq6t_w13I@;s`_<v|Ac9><K#G!4-7aRLObJnIr)oy(N%ZtOC3p
zZ3}qZ9#jK@QWhwcy$Egt9S{kr=Y2Zgy|{cIbaXDHj|Hlvk|7pwfClM66_Tgr(Gm`j
zL>4H4bl0dLkAqwTj{`zWY|y$2&;_pGVUt$S0{<6mpyUJfNGoWSD7<~^+pWKo6XdgA
z+ob)Va{k@tW#G;O|MWu*w-{P3l}PUdAJ*S%>kX6VpMF3FG}1lgAm|vjNYIIkNcrbj
z3%IR>IH98X!9UIujveli{M)oaz5%zfz?-u=Az90z<t=|JXbR%x70_N~a5?DE@VAz~
zC60}O!J*-=Du3$^a7P&2aPeRSr2-C60W09qt#c53evRCA(12_XDA03M3P9ncB=!$-
z(e_Pt(6FTeD3=C!^s*Z40~KQ~D$s#E7nKB`&JvY~7l)pLTJ~#Hz^A2k9s`YO=HCJd
zu?p@31<ZSpvI<b?0IGOV;<EiIs8s~1qdY*jk$!(+atkE12At_UdPVcWMtlRgYt}W8
zp?e@L&(2q%xSxIwRC`TP0S(l7bi+<U+XHUFzt~j<s!5^hds`r_PVl&FLKQ>?RDgm4
z7S!s5Y*BE7%7EKxy)BTICs>aTNTwH(QeON|0X2m8K)l@B0_mrNm9c`AfktF+r+})o
zY(~(5y`YF{naTi;lWItdkbhe?qeH`AE&diER?uDG;S!$R?h2rd-v@uN`dB{TZwq1t
zh28`3wGQ1TOyKQ=cA&mz?;5ZNK>^JMs>oqIQ1J8(xI+P|+S}TB7@(JR_nPLM0~N^c
zUo0yHO==??)tdeP|9>Cr6cq*j)(N1Jt2+jAf`x!bH_HuBYZ5$_)mj3Ug9a?9e)8;&
zSMcm~7x1)<*WhpIV*s77nJ(ecdDlntsYfShBP}Z^d3BhBhL=GN=ry2W&(8NRSSrDV
zi-ZT`Q6J04{4GwPyM#ek{Tzg}vk0wYe(cf9BLPas0^o5+&(3@e&{=|@tt{@~X-L)=
zjTN9P09;fQ(i}V8qddFa3qZrzCLY}Z93Ix9j{`vmbH;+Qg|%o|5QtL*=CEo8F*20!
zdUoqK)H1~Lw_33?Fzg4l5MBgSfZQw&9z^Js6|x2mr1J|p2!JZUP63Zz(fvuF0R{I2
zkIo2=;|>C#lM+0RyQqNIB)@Q~1l1g%gH0d<7A=~f(!JO8)~WyhU!<0Un-i@$pz7c_
z=wvF;;(_k)3{YKe=Fw|<b{8n-uD`fb4st_%1}JJ<`axq}y{3D1F)+M1Tn?R4Vgi?C
zAu1l8-Sr8e<!TNu(!p7vL`B1+6Lj+#f6Fe=PTt-c6%U`z-!CkaAhoQ+3w<yPnvRb{
z&+h~kZs0~lC*(}UV-R@;&ppsB8}_b-Z{g*kM>FU|0sfY^;G+tTGJ15I{tRGbFgyV2
z)`7B<Yv&7(US7LJ3=H6FEI|D`4nELry$?XMj-VTxK%<NNZFe{k$u?jYC<}al@xBOD
zNJ07>pb1Bx&MlAv0y=91I)4>3F9goe&{-pJrUp%V_CoV%XO9YKD9EEz05op}DlWjv
zp(AJ>-BZBQFPe)Gg#+Z!dP8t1LTVgPaRI7TAjO4v+28-Z-R2;_@Dzh$`4DLMRvQw4
z;L8Zqz%d0W9Kpv7ynmqt@=SNJ07%z0kY$}1x}JchAi?M0zW7r3_rH(j67Z3#{4L8l
z5c7J5J3%Sq{fkS5AO|~xGHQusg9Ss0iAS%g2vqVZs5}DAFm}FwaTCPuHT}5*qVH4{
z^7$4X-O&}`<D`q37#LhZ>teM)Q>MM9r=ZGbSN;9}QVhN>$+H{1#40oQ?R@Ha@F}ZT
zbBz`ULy3k5tf1;Ojf5H!Rs~AM?h+oI@4dQ9G&o+kRzV6R&}s26FM_USl83ZsK*gp{
z_Zo0t6*OND>KcHzsCig}#+><Gr+{lq-`-M2(EYdVDNGCuP8~WLFtwm00xAogj=5+s
zGQ4E}4eAwv_MP)@bB{dmg01-hqi^ezQjV4b{H;I0rw$(Q?R)@BtRCH_)_#l(o|*?d
zdU@OCgHxg5fnDIzAc+e!+6&6#pm77x%xEuf>2?N&7o6qzQ)wl59;*kMav^h@h*SzM
z)IkZEn1p&O9~AF<z{WumY6mC{c4H(|{+63R|NnoHRSY^t2s}Ii3Wsm*kxV6=zO7IA
zTNFSOTiv-Fpv(#xZGnXYXyV<c6VkZipK<^?0k2R1O6#DmzXxcP=fwtgP(J?tVn!UO
zTAZQ+&dlA=YP}a)YiL8A3n~kIEZ_6Dlz<#{wFtD340Q52XuXk7w}NLkXn{6pSqW&S
z>&4Y#P=WyqK{64j)@vvS+3zgj_{}}ifxk5pH0%I6!5DH{K@%uXbwh0Ru!ijN&I5}<
z+Pg^80aHNLY2y*lk`k2Z02c<(_;Z8+zvdk9*!#=PkgGXeKm{hmWW$r7QHpnvGbdiG
z0~ZmHR@uwazo7A)ZU+I+PH@%3-?A0#L2&iM;={<m-`WQe5cuXKpupb(9=|y5q5?k3
z&+z{X0g(T?!NWPnUKE2OwG+Hwx#jzMP-wVkfSP0l9+u7-{4IAtQ&Rac3=A&=Kx2J+
zu=%PN-UWaEzf^#an}6nq_GUmS?qw%vB_O!Hh?Gf}&VdvR8_WLwf4K~L?>uP8Mgz3R
z_H_;@&_Rpw_*+h``}^OsSqF6R8)Qi<ByL`oftLG1&c6kn8{LbVn0%lK>BWOwkWq;A
zQ@{$!QF_q%6G)Dlvx9-*#r9(SIjRkma6575C~%Xs7g|?<7K^~E0FPeLEKr#QE&V|?
z!VAkY|Np<VS_A4+fzC~OZg}8j7<}Bsvl|lZ0icQ<-UN>D=w+4I3<@?Em4p{Nz|CGr
zSa?8M!l~y$w@$lffM#!wLk>a&^<qFRs|t@^*7uu0dLe_-FDk)JUud?0w1(BrqqK$-
zH-kzdaBH~dG)8N<^Dv&)@S1E$X#t+FM`;ZQK{F<}HtcNyCwNHpW&xD}Wm(jUPYxsl
zYYl&l1Z8_@EsN3`{+<WwpVz2lfKJpt6$xn&zkKxtoIffgKpPl9`+fOaI6>?7n%Nm&
zGJwxze*U62_wWCgOF&!1CP#vr$L<B777er=16f4Izs)()(a1e=g#&+U1$guA4bZtz
zorgTS9YABFrC)qHt13Y08<Y$@yUjsf0FNqyQbLFd2PhH*K>ZSsJg8rC0~9q33=FWA
z&Wq)syw__we<LWC-oKau;Vy=9J3$5NJMi$L0|Uq}pcs_}NkWEVA<+sl7~XlE2EKa@
zJbY^bYLvo<Z#_U+IsoJ%4^RRFt)XB54c`X5m>dBrbZS&AUUY(4&@M;~h|?XS;_;Ff
zG=v9gsDT3(l1_6}EFe8;lr;AqWIo7|%^N@-g1GNR5ZFzi^X_{=on!FAsBRY(3nX{A
zsCc~K23ZK2UjWgtsQ(rY8uI@7|Nm$H{0sqpO~`=p%No!s$X?ss>lqkc6la0bfbDt^
zI~~Ga3}Qz^*waC5e+au9#CFd5`~O89sD$XX-9C$f;e`=Mvh(Om4bWcJ&Z945!SwN$
z1z`H<%e7E?`-;E+UxIe*y?g)_0dEHGJo=JxC8)eP{8AlEAANabCFrtfsG_T2!NV_A
zptKp3_JGpqAjQH^#T8(|qc0Ca`3u1O!!Pec>5ovF8Jr#uzf@ZF_y0?MC<mk%-d+an
zw*~ES03Y<~0V>B(&PZ%gu>f7=a{#ms?gFUY0Gkd1&98nq2Fm-art87mVptVH12?^(
zrDUD|K*<@rUZ$6IlLKh{kaw~QXi&OE<pIc)Ue+&)|Nrv~wy3;-Zaz2x>P8&|?eS~q
zQ88d<VBi2v=RmA%Q317#K)X>vsapc1jf0ti;Y9$nCoTbUcCW1U8U}_JZ$d$X1*T73
z7#ToEm4mX9N3W^-I#AI7TBFiA2i#lsY-R&(uWmlU1Ztpxtm%NXmS0Gxg9g-&fTreJ
z%oQQ&a|6iD-Jp>MP*W1b0Zq?=FDe2l0Bs~|vHt(R!6VWMv~l$cxX?Z7(aXEf7L+9G
zz{4KUf~nKPz@wLU+gi{GkZV*XfDG&8fNZLA$awMh5U8M4{kWEa!Ep!30?>R0MA18+
z&QuPMUS2L6P<V<m?*Wy;?_YF-#v!}+sDRxFYO8>Ujar__f_%J31>`l*&>0s*crRGE
z1#B;<+jtxj1E2y2Dau~20eK4&S1+=zfQoYikIpSnJHGL^OamLU2ON7I&1{TFHcSFZ
zfrLPFI-uSR#PwSs5szZu9u-g$c`-8$()YAj52+eJNdn2hSs(*J>)Jp;h4A2Hs4$wp
zd!WK#TM?>TLBhSPtJW|ufTA8W%bMWPYpM_PC<CZYfUH^sr8`g^)coKNENwKOVCsNK
zg3=VIQ4HR<4H5)#UOZ0$XKZkqF_wpf9oSu<Gy^JlL9T&>F(|D>SVGf^2Y=peNLm43
zNdSsnokgHLB|2?2$P`dgfi$c=I-y(B95P<qJOEMxUFg^O?#0Oipv(DEIUIL@Is@R#
z3Eq43@-kV0(+M}IbDs7J6o(jzL|+DLBFO*?6G|k<R)L%dO(d?DKo+1Tl9kdB)4}lx
zN)d?YXam^*5+XX0l%zls$t+OG)(uU02m?hy24W_Xb5JLMBLks&I#d`GEl4Tt07$r(
zb?PeAL^1{HQBaE&6#t+#8Ss<=I#vRd4nTq)y{v~OLIMTUQ~{|4bwS{11;lx=I|-3i
z=7TKkY=Pt}q#^}0RhRI>&>U1^9`!ix03N{c=;h6i1I0XR2k5kJ5B|Id;4-tpH`2kQ
z^IaN$&JmAZ*5@l3z-tX(gU$v56-GxulUpF?fR1>AtP6C_crkS!$Ry}8($04;TETo)
zz4f4S2PqkW2GDzXubYFDk^`tMEDgH8wRZ{F%|4yaUsMM`Vi~QVkpV{tp)}OA0uo%H
zO5p|L1<W)wR|;Y}mNYaIBt=phGDw1?p^HmEO#w*B2il1S+L88Rvp>WpkW-M-#1v^z
zG5h?*6sR;>l1T-{U@vRX3e+T%4fPjjhz67lK<jxik_<@j#hL^}a_|5d21^duiVlGn
zvZiQhLev{vV6Z-crinwKH1PqECXRXZ^4?tzNfW<8X#!l*2!Ij=$Z;N>z6@#npnKR{
zGhQ_80VN97nefU7T9!Z(!6Q>}BAC66f#HSNGf<K9{6(D~B+$?zKOYn|-Gm~)bs19R
zvw(-tQ40_SNr>rKB3}k1MN;G&CqN>99k>9gQQ>%T&=+DnT8tM-Kw^B6FNl8sVirhQ
zFYEI@a1=9pbjx~xYT(Wm70_BkQ0#)1@p<%`&H?$SnVAV(ximlc1FA?87#SGAjf@hN
zjE)u+h)ULQkjl;$l>*RVVcS|%DnKI#$6Hh~Ad|EV(5j~aq8U_ybU<Y~po)806`^K;
zc6Wdr0Y2#fv;qdC2~l-{G=r9qgK8g0H3m}n!ZZ$)>_EG&TMzKJh=W2CU&2#(vBU^H
z;capPrxxzEf8eFdkc8*aD>`*40|O}irSaz+106gDN@^fSdUU>nr#}VoSUJC-YsQP{
z?I2_JfWrc`bI=>g2L&#OZw=<NhO7paOf2BR;CG;2EF@9J8iNyM+7<?e7mbf0iSng4
zBwo=HWtSL8m{6kpuox*(=7T!7-KdH3FxVJq1q4cgt^Z48K#i+Xu@~|2pcV{LJ82_G
zF-Q^7^;}OZB$@t&?U{ce1@#UrnZovZegZ`yQo|1>ehVrNE2&`Ohd|=Jtnxh!3?8sl
z>d|ZZ73$#)(6k6z`|jDy#tcospauNU1YFS3q5_ij=w+P-)dbqT2ugf6pa~eXgAtt4
zAPEq30A%wCCQup#-8lu40X4HhihEfTpk{z>T>+W#10>uzM}>ij0hR&4F?hU1g#*+Q
zW&r1;jusWL!d_M*sD99bDv*BA95TGB1#w;kL?b8iPvVf61-AvTm97de_Uof1a^AI`
zpw!9gRsc!l;MMg%K&cy2;~w|u72UE3)G^)zUc`n-;GmR`NaSkZM7&1@<X2FlPTK-9
zc8>}u{6PFLC?6CFAif)z&$@mEDABW`C;AElaH8M1k%8ew&jV1UiD=ouV*5%AWHHzs
z4`NdNuLY2>0j04Ql_x+(qNe&>VURJXsUF&;xCN3TDUGj)f~4_npn4c|F2oBnkSjq$
zHlQ|sC-}NMix-L>paS^$3rR5j{)He|5o=s0asuvbQ4s(So42S)fHe1-S}ueX)X)U1
z07_1vZeEE>MF&g~>s6?S4WN1<=R3EkfUXt+B~xe#>;TaWO28h_G}zIi0#@A1Iv;9A
z0MrcdU89|IR1!d%AQ=FbfHR<)Atf+aVJ|Ca>jtRP<p9ljpy6M50tRtj^hY2k;ERM4
z@IM{&1Z?9AN@=XD4M++2fk!W|@B(-#eFW490F}}phu|osQ^5&xj|#}Ipai;fBgoi2
zDxmNK@ux!hptu0>TfuzRx@A}s@Nr#m0yY4Rvz)#QN^OV)3{6#Egh7%2|AmYjDB%$*
zwXNnMrQe-LK_;T6UtZAuFIcw$lvoj+0WOl$?~8Cq`aKWcK@H6m2m>WSg+69q<dZ1K
zCm0?*4HbqJ*HHg20SWiA7PcWL_FmHzs7DK+X|4ivj0&Q(ZU7}cP-2HHSOK*bz?p*e
z>0C$vfouU4mNP)Ypg}oU!i1#P1rYt9^u7Wr)6t>=R@}?F9%=@t00o%=8lM2QaSnhq
zLG;7Y`w6IKNO}h;d~rAwl$Ig$2kf8_>TFRt0V>(RMRD&G$hwH*ko6IuEC?EQ6abAB
zD!fqFLP^%3Chl+0o||6Qy)~d!IHF?q|Np~EW!S+2FFblhP3MA!rgDygN@LKlD`>?p
zav2Rd&*nI|A#!OQC`m)?hc$db3!--+i}&tP0R=typjwdRT(BhTzr~<*4sD%yfSV>z
zgL-*iX@L`aGkB;0T(k+ixCR=b@7@Cm07S~kho(|+Fd~F+fQ2Cj;vTdyn+=I#a2dY!
z5Ihfn0~vHs|3(2w0>sjs-UgBaWeZq41r$&oop=Uqo`gX1fIs#;a21rPF!R7VkZ><F
z;vwa{!V60$h`YdcB7DsRRSO!l1|>)k4M`U+DjF|DG(bt>7@~75+63w@_p;vJ`WMk2
zeF2JekVeS-7^wT}(aW2m3BBvrMMZ;O(9OW3S5$U21H%i4o1j2j172Vc?t+7?1x@&Z
ztp&|RzY_#GHI&1rTUQxW33s~+_*lN;Z}|pVUSch(ZwOk(@sfvu;hO_!LhU~<XsJ>Q
zcn}U`hT;Dgdq8cHZs@pN=dl+u;36K9E%r`@)Y%%2AX}glu^?;NK|6Q5T{(O}$27eH
z8EVaX*Z^eLT@a_+RRCgNK8SZ5#XcW2`__bmvLWOMnMjCzKE1l@7BVor*yzB(z`xx&
z!lS#I!>2Pj!>2QwBTbcIe;O~FLt3YE1ZcLjbqOy>k!yrUcP(g7RtD(6VT2-AkfIWy
z7t6vx4dGgj7qL+w>p)lZR&#iC!-94Rc;V1D=ST<smfxVD>vqlnZ(Ys<rF2k_<Q-_E
zbGL4uJ|n}6nIRxEAjuy*#O5^%H2o+B>QIAMT=hCJdUmpbr;t<mLDj|*@Zv1P+n}XC
zEn1)r(w%F-)AWXKK?wr1fXxSVBqt~{_4YuPZS_t8YXT3)fo>)21Ya`<nsKny1SN|t
z;8+AL0J97Rxd(Cwm^AoM2Uv7M6E-3Z=YjH7FKhb@P=tbppHap?kAZ4`P<93Fss;~*
z-V24~s#Z`qfLlf~_7JTKFNEwF7(ffSS`GOa7+P-gw+ez&MU9HVi|=+IMSCDcD8hCQ
zu<el9VCXnU#Ea8lwV)fhI`6;O2jYOL0Z{4$9p1ASG)fN}Z~{#o-uLL`ePIYH8Ce<Q
zplt|fX7b?AyW!ExtEC1m-(G_T8Nla<x*5Fqb``W3atSymfv)39K+Z|vh<d^cnoa|q
z8`rISLx+(8bR8TdFU<n&jk6YgtP4utz1*<8G#ez0nzjo-c?T&kT>vK(NM5=%3zC=a
z*n;K*APEj^u{00JViy%iX8H><)ta>oY}p5Hh!iw81%l*IZTttyJxDgjg&-yiI;Vqe
z^y$@|F^_@aMY1g@qd;<#M`t$n+_a6Gfx(e~yNgPMCn&Z(J9AVrKo^N3@||O+iwZbX
ziM$951|@sY$OU^i$Xd{>0%(v0T#06L_;f?V8+3UUByUXz`2d`^-txC(f${+;Z#9AP
zNVl$#4yY7-|H3K|l$?>WSIcCOJz}8snGR@q%%k-re@i1M$9DFBvy0(vaG<(@vTNrO
zXdVOSEs%BtPzLJ;Wu)#B6^|DmR8ce12Y-;wkc{*fbe;q}WHB;QEU07yS5CdAI#VH~
zDySX<rCWGC)d`(Ym=OfYMY13tgTnR2HEU1?sZmjQamE^&i*|ECa?xz?a<x5>LI9C>
z?tnZAI)CZKEU;e4Y73-+!D6TajTe>H;0^~Pc-+UM*YwB~P#FX%FJ7GS0r?S<CJR8G
zfHixNTRPo2DhV%~6#xH+S7)8aK#iQw9=)v6pjnY#(I@(l{oM~5{30DdHi6e29`fjA
z4V?mNdw|A=z(c^G8(3JkftqT)yz7-189)^r$gHCty`teuKurWU&~(!=enGd47k=Pj
zdr-J+u>yq<v>-zS!(4C*f+P-5WTKQ`E#UbZk6zZ@lR)M|rvj{Yfnpil{DwC@%AkP^
ziZZnMqH2&7NllMTA4v4FPX<*op#1RN65@DpS&DG{1F+*UT3I)t!f5S{Nub;hcSx@(
z_hh7KWc5Zw<42HwoY7b<j}eW(J$hMH)`G^Id1G}U(f9%-8V`E(vd)==6pcqg3nhD5
z<v}Z9dU<~+phn{Y(1=4PI2w<Gqp=-4a*pBA3tS){{C{!70u(%iBJmq|FAOviOLt&K
zq97=yu=k<FKvM9q>xMSw@wFe9ctIj@7w8Zaa2_=RyArg(Km*EBcp(R63A_*iv3mEY
zfI1s5*r6Oycjd(|bIAA$XjS)%w=fQ9Ino0t2h<^daT&@1b?ILm19LzdA@_h;dsINf
z1TWS@IiMk^7mJ`A&>+@}sbEfxO2Lb6Fl&zrXkhF`9h9>Gbc$CYlmi;JeUSp@fEHj!
zfmwT0KtsVVd_f%0P3kY4!7Rx9dJ60YN&ePfpoN-^M?f?2NK3&G=f%DF?e+KnOH0sc
z58!oEFJ6QALU2ClY!GlRYyHpPQt=41XI-DMRP4nOufP96YfV9&H_#I9)`&;o+jm1B
zffgi!?yG?JWBFTBpFs5Sx7-CShWhq0<OzI#S~bYN<B#F|Y!E*NZvTsD5I-5g_XhE^
z5PWM8zYxLK2J!n4=1GGcx(7T%4Qdm%COrB7|0T#p5dZ%61bGDBjplFF1j*|?0eJ&-
z?%Hin(B+v3_nwBThn5Zet&bl6|Nrv&W0?BYV0pxtZEMP7aKI#jRWQ6b?FCw6#>VK=
z`59Chg2L}*0N6HAf@44l??TWPgl2GfhoBo9_!Mlc-&2sqp!54c?#y`!4@YGXzvVfM
zk7DjZ&>VlWK4VFt;kTDl-u(ZMNDnCL-aUiFTdCNKD;}U=Lh{zRXJGqJKZDqhqAwP-
zH41c!XN%=auqq#fySmX05_khv!utkf5ah_I>!1zjoku;o9Ryx7eFlranCuA&H{Z@L
z@NnC44<rW;w-?49fB(O{g^2fLsCwjZ-tz#Vo*ATmA|hTtyZ`<FG6}(d4B~?}azNJa
zzYxY^-f|rA#`q2rZu~8vJ68<9z5MVN77s5@dqDgF^8{!YiNMQi;9vx;!vvjT*9osT
z`CGa^fy`oOeA)O3wBH+i${n)&ua8jqj~~JEpnTfE%E0jAlRc=Vx&k}|++EG_k_EI!
zc!EcFt^lYT(<=4}6c&gMTCeU;a0P|6pH?FM0+gOWJ-HXRz%3Bay6m_7t&Skqq4mQ+
zs$S-Ujdx&pG20C-;XHuE_g$p;RtJqbbsho7cN}=LA_J)XDgo-pK*uilTVg>w6G3a~
zLLi$}A?v9z)h&mqn+IBt_d?q3@Bf!fpfnE7@2Ke%w6PVG4>%3Ky$pB{3cnYxT_Ns;
zwKZBz-h<PpA!PsQ3vPF8@%Q^VC^TI_+eK1T1VC-rRwj@$C%`+vy}B2{ts1N?_Y&zB
zhuuN;R&%_l0yhnuIlzYKgFFLml*1e3pe@ayM)}J$a9BaoKeHVox<P&X-JnHG-Ps&3
zGeGWuub%~t%Ysf8dLeAc!0<8{zK#|o4q8|K;<o_<!%Jfnaj^QwAo07PGzJOB-aX(o
z>@QA(#P`C*U#xcd`~PJ-JiUVs$N?pFklA}djY`i>HV_}wXMVZ=11QwM?)T_*0xz8c
z*#*AE2dWOVuJdIJk~-M_6Q6F~1@fStqAp`61H;QEa53S)@Io78zZ`M)F9vHOY<~ul
zI#`1Rl+R{-1?4?`#u8Ba=>~<_gcqxwLGic+Iu!Sfzcv3WIQ`^+4=7-8HGJaJt@}(4
z<Z@g04hDvoIiPe0kDnLW&VT>E40;7GFQP$wZ3N#N#AiY9twH>|i1Ibt1zY-*c>xM(
zP<_S?QvU^>A71=+`uqQ7GpK9;$LovNAbun$%|Q6Kok0GX0`||#29R4J;)g-%-XZv#
zL3}BMIg63?O$3!)5PjVsbsh-&t3iB4I3Fc{{zVSo50LQn2Ahi%zE>dOdl3@8;P3-2
z$%2;qpltl|#Y>Ry!SVcp8)RP!!hgRV|Neie1~MDszSkhW7()Iwh%bxagTfEp{CaR<
z2R0uxpwub_I=i~a3XvguZDZOP7+yBMMYsbLe(2`>LrQ18x|$#@tH4R$0bDP(a)1^N
zOCg)9%K}o=`r-fo7feXvpnP8d666J?#?Hepw}Lj1cOHH@5xk4^@XJG>?fsocUtWRI
zeqj3W%V02l^yLjGeYffF|Cd|9nvTAVYX1BGWll4==kjtYly--jyd5NY8bo}A%4C7g
zFX=q`ayOJN0hx8W<?sKOA3?-~*1!K>?gO7marosWD19ADuY=O}K#Bz0AXYX*X%5g4
z2AkVJV-`nV?tz%@(d(j;-~rl2`m&<^@Bf#rpfim+kG@QRx_u**?+2x~LFwIK`tZxE
zVEX9GKOnPNK_~2V9(^eYG5e)v$KU@ipMefacm<NK1$+7EOG}XOU$9G$zLWuR;z2||
z*#AdgmV%8u{IU^j+ToWSAjx?kVr2)!?f05M_gEkrU$FE3JwW%!f$y}?@aazD0Bx6R
zN4w@)!telSwbWb(@GiL$(0RR}`+(rL{qnc|0gdCpudsyO?*N|WFs*9`t#7aa1uOWl
zp%!zn8$s(gK#P|^cR;;J0#}5fgV{Tey*TO!b}=Y*x0r#{g1T6s(F-=vQiYOA@CX7D
z-xt~@@aSdLYXAS=)AA^P3;0;)ZcxMFK#2zAkR<Ss6Xb9*G4M%brl5mzZ#Y8wavGpb
zoSn}+I^R3~hnyD%K6kj&Spc+bfZ-(<NU^ou-~TUb|HI2mZ5aQBpu^w)FITjqT;DbU
zx;DA_O+^awWeORF2VN|+`}@Da!q}tpV2P(kH|r}&P#G<n&<yGhn%eY&`n(o~2VPX!
zf-eH>j#0@-@i3MFUr@*2Ivcdwp!rAzq?3g>U$&uwQLl7kLj{vX>1zIM4$RFj3~V^d
z7JwF^gHLVP5889_;+P$%H(voifzq?{z`n1b3cUIG50B#x-~+ETfAo4}7#=wIlKHd8
zYL8yl(@mh>_;JtU4&d9XJUbmUJdZnAfHpCD9tW*0WO$M92#R4)tb)er-h;9a=zNRb
z7?l9fx_k$ZUQtDmzd+|TdGxY2Hi5iabQ_e73_vb~F4vDyad@!=beKJ8)D0BV4u+Rr
zY_>t9h$N87-8JBw9!gkW+^_{z86_$PAhjCcGb>V5BwhsCL!xySC}D#7tcdgy2~r8Z
zw-J(_EJ4l_c(MK>Xw(4Ye$W=v|NJd&{~#4Ee`^hh1xl+gtU$>ae8(T?mZ=xoHh=%W
zJ^){j{z4kWU+{tjlq{aMLfqVW`K2=G2&I?cynEcE^YTjt5Pv&}INpZ5e-LRsdnf4p
zUhv#yr-_Q;H}HHSQX*<m>0kmMbutqana5pJAg6J3g0>uV-tg#-766^j&*9N}yM)sN
zeCZ2l!yjlz0(b-N@fPr|Z14c&@fPrjogg;9W(#;F$Tx>bM*h}G0-!o2N5#Sse6I{B
zjv_#+Kn&0(KJX@c50Hpww`&C`9s^!31s#3}Z(n$ToB}#i```ms4@S@_2>dPglt5?H
zz2$GY3SxAZGJrbtEmbTG3@>`kp@*a7uz=D(WS9aJZ_sJwUhwgqdm!t05F=%6P+{;o
zt=9h~tS^pOgVMwv$kH^h$R=yhCez#s@UdWXSwI8V+d?B9`M1YLbzV5|g0=YpWAh^c
z{+1{f28QMjj4u4!KKS*P82|IJEK%Vo7WC|PRq)hyl>ptW=41JxXbb3o4+&6Eg7#y9
zR>Fbi2tX_0K*0fGgT_%{Y}ooYkT}SZAaT%{1)vrxD0v=lQ2~v?K!sro-ax8B<1`>)
z&|C{>c@jtrwCn~X28t|jf2;L2e=Eq{AUARNSbp&AJmSmm{><>U<2TnxCjOR1AUnDt
z`}RC~=YV70quGK1bZZ_YzCAkc{|^A2m8b%m5(lrO=-#3N@&Y97v_RJSSZ`4Qd4<2_
z3Mj-o<v_P?gT}8R3b%kg(cPm0@_>i+78Q`=_*+h}GcYv&wC8VG&&t5i>&V#I0#@MD
z`2*bY_PG4O19WFLo2TU+{<fpwjoY~rpz!tpUnR}zVR?hU9dr*H_;%p89^EcCBtXG|
z;!3#7m_X%NCmV{(Kphk>@R9>xiO%zmohO=~GdeauU<8dQfx;cb$#+3(0zgjIVM22<
z$hDw5C=qwSJGA@<-2e|7@@ziL=wtbqzttLa!U$-F4&+Qw7XxXNQjLm$r{z8V_CKI8
z$JYNP(x53luo_UY_`(`gn1N29J;Vl1qOOrE1o&GU*%=sCDDby}1VLNG0~kQ*02BbA
zbZ{JUKqH6=5(X_j1hJ1p7Hoo;AYsq|9*E7~63hxRdV6ftu@;qnkdQ~`UGS#mHc+nX
zb+-37_=3&j-~(ppteeJ*sTQE@v_%DEqi5$4&;?81Z+WzSD-i-K2~jb4@d=#cLR1Vq
zdu>EK4*q6qergX|`vyzmy)ySZ*TDC*g4Ub+^g^r$r8w{k@9rL`{1otUOQ7yJsA751
z9>c)U4e<<UM+V4$9=$9VK&^xRLQtEjcMsTQFY4<4{|6n3qX9Z|6699okm;NQUh(R~
z_^5LYcqQx0narSDJ|OMrZtyieh=ldcRf37XbuMT_oi%HiAZWMggunm)zf1@3fM$Tq
zA%aWAm)k(MJV5tbABUuEaG>_Oae(3<l)%6@zJSli><#|ka=?S%<+5kzHPA_p9Q<vw
ze*gdP+YKq1TGJrrLn4{K<sE3SzB@+6!^1L0MS;Jy5Hu&+T%+Q_z~Ax-G=&2@ZrE`T
zD4<`O@_@YLz~Iq41so)xem1C3dg0vk|NqO+e_-vF&K__N3lyB7E{jX&L6AyN(FDrQ
zps9ryfp!1?ztjZ#&4Iz=;A3Ww&igNV%s>gD2U;>f%h%4M9+p4(TR?XrdGtE|@aPTa
z_t5;|q4^4QY^_K0FFF3UFQE3yF2p757x-Hqf`pn6FoI5nKj?AsrN_aCETH>TdBphz
zeMA{Nnh$~QX9eBAe$1o!8R-7?uaIEn5%*wx<zacOgw3Oy(W8^;#dXua|2-IAgZ8Y0
zN*u^^k#>s;#5;4qMHcAFU{I0<7x<tpSfEhxusqD)cKjEpl0R(kaqu-8%$rL=CU&m@
zmuEiRQ@|#9b{>J16P>SoG%xvBUM*4g>AdFAdAt*J*->YRih)mOh>FIG=N5negYQ4;
z1_^bCsAzPa1LX?ClOC<#N=09LBbwmN2N^w@-!Yb0_;mjA>1Ox1{K%v8f^X+RkM9>e
zIWPJs9`I-lW$@&8J?PQN-u%<P^gQScSC8i79EK-B`btlLG6^W9clLmf^atG$&f(K}
z{l#GuP(-zW6M+xoV^D?w1qX7a(+R0`pvSv{av>=6pr!N64WNC{6L6(xd+-?ppz#mm
zzyDum{(z;c7t$bp0h|v$j{66~zo5e~K}Y(5@1rmJ;bD2O^bKg3yu}7|yq^*LTm-{Q
zpx6YtIE_Dl4mkWhx_iLBN#oC70*)BiwsKG=0|h}h^uYAa9<cguNQiVo3P+G}pq$v*
zqXJq%4l)c>j(`rP0+lf!GeCSKGeD}ld%z_{C#>*k0at0A&>F6D3YZJh3o2Y+yw`%v
z?1BsgC)Mr^V7sh0fXw1=;R9z_Hn3FlF%FMTh;;87=<4zJj{idqK-YY!T?7rP{9)v8
zJs|>GKv$y@03N9a`H~-UkT<wZbI%CWj&D(cR3FD*tOIQm>&9p`^?(Zzc&mxO<pOB0
zD`>#H_1L%n|6imV{{8=Q59kcI2^i%DH>ea)gvVzmbh%0Q6!46*;Ys9T12lN{LaOTj
ze{jA2Qs>8i(9OH9kt-DVTLeHgm;it4c2HBKc@Nmh4E!x3V5dP_8t^(Ca+*5SU*M1e
zU3?2w)s3T>AtelLX8hpAQfGr(7@$M|YEXe34GK$8%z^1{s9m7s4vHR-BRgAEKx$t^
z%78ZK{s65Zfv7V44{GUZyqKT|>h3^ydV_jAI`!ZS{rFonK<i&DV^lc!+oM4qgl-21
zX*~KO5~>ZfG7D6NwUmLz47#U4c8qsI&Fh6^U2ydZI;*i0TAqWpSwUU+Vn1lZ4eVfu
zO&|`e%?1z243JB@p=QED66zdKNe^zgfu=ri1nOTwXrL|-#22VLKxKJ1=!~>ZsJmfy
z9*5Wsaxy5iK?+~6gPhv={>6VOP&;IsYvfA>@G%K4V6JcEftPH}4;lHl9rUz3#@{9g
z-pl?AR5bQ_FnY9#muex(6Hm)?{4HNV`=mQh_;mgPH(V}1@&Fa9ts=)u9)MyT62qYD
z%0S0ifL%HT+!R0*EufRY7{QGU(86U{nF=dl;3ZCH3%Kxr780<s1FeMd=$ryBp1P-i
z%MOsQkxG`%Dd5I0sN#i|w%|=Q-7Vk=R*+s$Q3BEgk_OfK5&SJNpmlql&JLjN2FORC
zQ1oa%oB=+478HeP{P}ypg&wG(2Wp{%!W-;8P{{+jwHKrfl$`kmi&v!a=R=Ade!=P;
z9-YoFK$4)&1;1eS43AFd4<J6Mlff?-eZr&D`3J~UkU=0*L0JUU)Bt4>P-29#kt-I^
z+7PHPs1K?Dt8QWam6vwE5xMCY=zu3shBA2R3|dJJJ@*21fGKEj7E-i<mP{6EqGdNH
zMh1q48WqUoFGyW!D5wKu05VMDMUx?@0-ORaXpr+eNFmriAkTn20nJ%23MD|p5qrRk
zfL^44INgw93Suazp9*fFTN?fS4{|gkD3m}&JvbAC=9EC)2~cc+x;~&t;BV0dr8d;g
z2>-TF36MfictYC~&5syCT0jxb-?9p{Q3TZWXk<Xoaou*H-bd#_56&MR-!FP7{%pDA
z!S8YqbjFWICz}uGs%VgIP@ntY16EIFR|!xvQUKgn067%oV~@_GB|M;7xb+)<>om})
zMsuwI1AhzX)J%_VSMWg&AhqDDL(_29|GED`L(2{foju?qmB2y7zwHz#ph1;3D0zeT
zu6J$$?^lOJ$^T+-ON$ZY($+9=9|;n|FF%7vw88U{pxXy}p@m^DtbqxN|HktF|6lF{
zxwyL`<ApGISyPFM1Ze0c!SJL<=b;z%=HLToa#RvN^XG#OK<su=DFB_O0NN_ZuL(J*
z85~=#pbXVL1=0})oqcN}2--pIWUzvXzx5-i7t|dj0g7MHCP)5lEKJQ0nE1CH02T6Y
z-htKzsyeeWGI%z#s4zn2Ye8y3<1t7}A;dsMZ{rcr2oC&;PscdN_`{&?UmGLH`@N6~
z1$0{SXHf=*mt61v|A#c>LFdIl+WaN4U^etzNRRGn<bxNVf)a3dwFlA=$svdk_^LA2
z7kjioxu6<!MkId=sIT{86-cD{aE6C<jEX|(dQb}SU?|}Njfi=?=+%NYJX%1<?182P
zTP#354$!a>cu1&4802nf$nkH31lU$kmm4F%7(u;Q&<%W`umSCI0$Cwp`0amy!OOGY
z6K+894RZ;9tK$Fv|6jt=)r-p-pffuW<E)24d_l0~E-DuM+Z-ZSaPYSVGBYr&VD#uU
zwFMo++{@|&qWE1tfQ}siEr|iGca_`^3W6BWQ64Se%`MP6mBXXk*rW6Ci=Ut~se9L`
zfL7Lc^onwTjOe@vIv^>(6?B@x67ZHT*m2s=Uu4#TME9tG7S?$5igs0i#zmij4wSHO
z1$967fYpO~^#Y(>3gGh$O+jT>_a3MnEzo@^paD6sv=~$xw9*H3W)x_RKIAN_KN=v%
zL)Q0zjD&1haZyo#94&KK19U-8ii(Bd?U&|^3=9)Mr(S_Q0zJMByx|3Od>iQK@b@5D
z&_*E8g*?5YmY}1Kkx%ZaZvnY~3V0V0sEC4u;QtrfRgfHEU8AB<!ulc^>M*cn(Bq-}
zp<-ZfSbi^IePIh0aZ$1G>@HCe0HvUkJkWG3NCosRFVHB081z~cjTbzsAge$}?e&VV
zff5YIi<x^sLNzKJhL^y%yS?Z@2`vY9AL|ws&<-X3rh7~b43Ka;q7GUFS^~Od=l=_J
zT~IUG)IA#%Q~zH`=z>N9Q&cLz>H8To14Hv+@ajhn@R53k2Ryn>TNoJ`96LelgD(d$
zFuYg_N+X~-2*(|uT@s)Z%RG8{-)A#0yodtjC(v97=tMnG0E0sWa-v>q?my508qg!v
zL2>aiA2e6@O%-%p7ig{>UefIV6`L<?cm4hU^7Us#?dSona*nA(sy@&xHn{vM0v~Nf
zLgh9ERN(bOE4Ow*28NeyU;h6;@PeuN0prWyKOiPEh$;0OT)OcxLQA)o${>N>E#Mx?
zYugDP$1%Du-JpSi{{i5ROYRY9`O#VoI;awqxxwQWEjk<w3@^@ux+ljW`-Z`F5la84
zbg@S-I23$3KfN&7`S<_pC7=`!uCL)0!68V1lotN~|MJskkXut!z-QEg>MW1Wqn?^~
zK=V{zl^_8IS_S|PFgEbXV$f=Zh&DDzBgly_qCv$UZ1I5~hyxla>eaacavP}WW(b+T
z0No$~D$lw>SIjmaW_+O}0J=Qp4u4BJD4t<gUUi4ul>qg$K`la1D+FW$$R1FW6WsJ{
zy#zXziHXsp^WF=81<(ve$?BIo3c*M8L(S(fytEUvLCK@nv?vplq+L`DUVH}Uv>FwT
zouC8?%Uivs!Jw0$!HMXg8mO%B0bP~hqGI4<*#pirpzw6yZ=1u$z~I^I$OPhQfZAQ4
z9O`R%kiTsWsBzs5Rcz^_qQT!h^ABjJ@(GX5Q$CspKzFQLUhv>|yWnYgg1=prn}NZr
z*MuEZ9@Z=Tg<Qx8;uI-^vN6;ga95!lbeL!N7HFA#3Or==%L8JThvj+x_K%<;QsxpB
z4Um2#1(5zdVAVdB-}zg#{`~*{;*K)tcsB5X+Td|K<kl(j_}e$ovZY>AuMALl{eK|}
zE<!*<el{wupj{P^6PG{}k)WnGxN8Qg^Z2(#L^eNWd}#=7nYu7AfG#lO_vkhKnGP}N
z3^>@KtE)k^#vI7d7-&-hya^0x#k`mRQVVKAbb${31I>(ePXUijfiK`|fij_K^f;s+
z1xgz)u7eg{qjd;h90Cb;?}6%q41j`~0W2QP?2Io|<e(ENpFu~Afl4m$o-ase?8P$h
z%JM0Y1OSZzP#B*B>FS1uaS7{-8gNE>4{BmU?u~ol1-7?FMdO77hy^;r3bcCE7{r0D
z9P;R7QSs<J4o<(IA-1Mt;8q)GVh!YdP>To>(#Ju84a#aST-2cM1>FVj3ObNE1k?)a
zHC>$s3Fu@{5!eeGhk+~x0@d>1OoKek+uH-~+kxxrW1uVs%4(os1Z6RBR}gtzypu--
zl;jOwG|PkX8h^`Ca9ajq&n{35dNlv|&))*>4atML8f(DgY#!Z^(d3p(rJ&^SDiz|&
zy&!M&+Wt>vV0f_*lwd()Y@h}i$lp2OqyOM1AUsNitU3qx7?9HoXtu(I4K(iK3c3+)
z4LHez$LF2FqRfo@!P&oa4mbi|aDZYBR;Gb0V&(vC8_b^q(Foe}2THzz0TM4_yFoQP
z^aR*$ix;}`&|u#KbsMC#g(MSjJL%|)NYDrdtSbashLiz1?h*ZlMbMlAD6~Naz(N~b
zCig;`_%DP&#=uewD~JP4l`kZ~Ne44EI>?~p_!8C^??BG&eE;GYs9=EAW;;QgZXOlT
z$#w>yXa}{kKuL0gEF?;AfKn24{=o1OI6hlVKq;~pl8j!IbAblU!R3eHrJdmY>b<63
zDUc|g1uD0ifBY{2#j|KWMDQxOMa25;Cuo*(3#2L7ZSg`66y>l18AY(WVC}>f$mV&=
z<NPfbKL7v!LRtRr|Ch%=HGQ{?3Md<ZlO|dw_h@Ej1l1PcfIJR8*c`Oa=_qKKH7o#j
za56Bw1g!zZRrvY6`~SZadS)Z^d|uGN9klZSaxb`>3OnEt)Y%G2`~Uyt**9Q);Cm3d
zr-1Lo1nGm0G=P@JgWRGCQu_TZq|E|$DROOn^u@`{|Nmdk2FpWAsTbE%K#HO1;uol)
z(E0uaQ!1!Z$x#V-$?zH03-aj%@&AAqeL@<5nxM1tK{wRBXp#q2XQ199sCM)0JowV}
z=l}np!)Q<XbZfsp0!oaa+7+}w!Q=P=5cN_URG0Odh9p5^ksnlf%m9r=bl&yQ&QbC3
z*nQOR%@Gjt=zQsM@F%ke|N7G&yRA10gAk*K<xTz;5m0IZ?IT(PDk*wJI6W*+@i(0W
zaau3&w_XD=j=QLU=gD`0R$G9U;4wZ0cjCYUFQEJm8pr_;-hf(t9-XcZpgt04REJ+M
zR{%Vi0~#Ixk2`^;miYxs6+Aj!JwU2JgE%0+fd&{L8O=2SBn}$C0f~b&Ld7FM;-HcX
zIbneAh3p1(AP5iM@C&9gz{hR`YYkxIH=r`T<uRzO-TBm`n>mgD{eO?%>HyFQO&*{H
zH=qr~-Od6Yovs2N-Odsoovsp}`SY_C_ywyuJdQhq7b@@z<|=&V&o4IM7c4dK=muS9
z=<48c+!?&M<hV0rDadhW@G67j&Y%lP89a_VLr#)9?h0OW;L+{u0S=Yp&Jg}_*8m1k
zVcYEta!Y^*=+4gL&JeLq(4J4{1kkmZFWN!HXm7R0i#iaayBgY8o*)e>Z=ii;ZcqtQ
z2ND4_Vw;ab`pf*SJfJS<E@(301C4tqcr?Gr@X&Tq@c>VE@vlGRu?v*i{{R0k@1c0X
zqxk@nN3V#3M=#3+&t8@zpz1~eq|XC1Da-+?C&i^fTkld-JU|UEP&x2Y7O{R(9MX~n
zXDm>UdiAgW|6eXi1s$&nY7auoFi_0HQu~YLtPBh<jX-DZP5_C6nsVT90WA{%Es6yR
zf;vnf!Tq3RK`)+yZ0R+f2ReeZ^El|z_`{&`sUQ{J?nDg*HqdO%S5O(+&HC{RXxz-y
zE0Y1V+SH@l;)S~O-~TUPffl9rLXMO0=rz5Z1*+}tzvu?-2LoS}+IiojyFlPYmptgs
z6j-TyB@Utt+<t+Ty5M_EI`6-T2NnO_tPLOwp{*8>bvvX$@djzNfLi6C-ZSWa`<C=~
z|Np<(CHeRN%h-4S|L+E6M$jDQ2}#JZobDFz^o<YWW6$0Yl?>2OWyH%sP!X~F2P6XP
zU!MmpyHR-Q1M=z)P$95U*qYJ9@{k9=`vs3)mLQK_nI_Pr;p=4{y|(e71+S;XK&}Bb
zEs>Wgw1Tdfc=-SSOYi&t|G#)935xJT9=)dbqd|dZ+nNDh%JUAC-a3DI^qL-z1_^ld
z+Gb}kFub@17C-v(TGHSDFIkg8DdOl$Z!mrMWfGJYgwhX_|NeienDY1kOQF=i|6iU3
zaYa%gdVE15Q^B0WFRei`nrVOkztl;CNJET1{4xy8Km5`LOdka;So#1q9n364h(1Ax
zN@sx00I3y)Fkf1N&x$+h*?HxqGE~SIN?T`wRlocX<?Cla;-vHPOBJy5j=nqvmHGyy
z6(BUov<vC*blL3&z00@3gWu(YM>p%Qj|>d|7l6*H1JAd2v%dTYN>bN6x*I@?4E{er
zxi8(L`3;9hH~aqp0npCrZdRU8pc>u6qxlHO%LIwP|Iy`HkmMb($Y1$@(62y1o<ZX8
zf5(u}V2|cE21pCLTvWiTE8RIfdSg@sj=87^FnDyzsDRd7fzA+R@aayF0QGSn3WI|1
zkO$)43d=*~WgeYReL6vF7+)}g<PnnEpv8~PKP1Xhc1eN?$zD^3Y*4_we{n+ylww&m
zLE+SGq5{fNsi5+p+eXF1@_q^Hi*j(1c2UuQk8YMqc{Cp}02>Zkfq2-X*H$!=f#Jnj
z;lKZ1aDX)T+OmKI_JADGdGzIkbWnlizyP|>{!6Gw=U-63zR&~Z+|~mnydK@6lio8h
zcvuE-l&E-gvwnRKs-Z#N@aS#;_r{u!aKt*s{C@x&2L*MXAYzBp5Ys^uzPTGPm2e@}
zLwa=A3%qm}0$C1j-$BD$042OR3=eoT+cT6(f{JAhgeT=anvV#8{pZ>F#G~^cDAZpI
zg0k-O7l%dv{(m6{3YboCrZ}1gvV#HSHBf|dyl?``y$3DaJN)7+h|_!oRN8xV-iVF`
zr9yttJ)9n$KRmkaLH#z!N<?;$(?R8W^BW0JO~LWv6et8i>kU1ck4PK_T}t#D6m}ln
z`Jjz8CF0QW=g#*Y-MI`e&WL~-^lwYwdw?q9ZfnDD9?gdhJbFby>#7)D#Db%``hv%C
zXHcsSRHcHBa%KR<vj`~BN5{VG6ai;0$bJ`y7|2l&zGEn8><b)<;041T9^LjRVQFD_
zz@yhkh3B}73J(LQdAJJX{?4P_E-E~&2TEl?<ErX{pad7p;nDfh@SA7n0Z^eV3{Etn
zZ$TaO-W(ML(6GLMM{m(LP#aL-#T3v<!Jtt#SHmZed<`Dkdj!(@LmX0efU1jdkM3ab
z)jSd&mKXTjYd|Tz`RD%<b&uAQC8s<z4}r3I=Y0>$Qy%>87hkLe1sBNJ*Xv;6=*;2K
z&FplHMS%gd1zh6wR7gC5_EP&;zAs^YkqPop>s!bv`88kzTvRL&sYcDC`G^N7)i}l;
z_UOFm(Q7K10m^8HKp|s0JBfke1)JF4|1UuK*R%7;%MEE@=fB(zrMIO0{XYSA{yZqZ
z{PAdhqu|kPhZ4>bh6g~W2@8Od4!Fzj)6M4D?Eozd1xhr1I*-4wlYq351;AZ77tl_j
z10`&p%^Hj)W#Cm8U%^HBBhVq&94`zc!2PAxD<FsTf_m%SC7^3;L{xk_pM$SAX8iPm
zdpRiXKr1?1|Cd10tTZUwNFV}0*Q5Ce=mKWPn8OoZa0~wZ|N0($eJsdTKLnsgysQAN
zsJ<!m_y5ZZaQ1OvKwAIW_~r$;TT-KfTspR>fDUUjJn$k(6qM2r@V6*}IuN}%DgmII
zuM&KEQ&b{Ay}-`*plgqNK&pBnJtt7J2Q=6KN|vC!WdZ7TfeV*z7nK0`y-}bZ^mI_V
z=>*-h20nwlmvu%6C<-A*eS^#a9m)bS=LL5S<RF*cJ>bT~i`@mFz76!y3eYMEkRL#I
zDuHNF(+bqPO5+8E07M6<#R6{AgJ%MGKv@ISO9o|~`=G7~c&Mz`^do3UAr4fGbl0eW
z?<LQA@ty~Cu0Lp^3u-&aR|TM3hmV5Rt)bfv>ga)teZhmv_C9FLfKHQ#-G$Bsy1oi@
zPZX#$ejx+a8={f`IwT>&12lEU4;l{WyatNdePDlqZqWoufalRVFL-nZ33#+#D*fWo
z9U%eoEjY+~O~t|EAK(*(G+wlb{{8Q{57O%TZx0^qSjz&Q&$$0$2LIpxpd|{<3ZMZW
z(AmbI^y&dRMX}ofd{?K(3zvM*q|6fV(2qyA>Cu-A433>IKsk;VbkPuaU>{U`-&qFo
zyR!o5JbTc5E6Ah*(D+-oLk2kXUi`}Y{~vO8HK?QmN%it_gfK9?C=>#P_8#!uK4`4p
zrxV%{hK%*M+yr$Dp=*ykpwlm)&X`BH2M6e41kl_7csWofeBHf|<reUQ0{#~8ZOEVq
zVnp0b;|!X4u;vEMU93?7^%_C8dUQgj?meKkRzqzCbrWH>g4H6~3SR2gDd5xH10Kfr
zfX?~s;0JZ4yP*S8(B%rAmM=kt1;6Vah?U)2z+vjy%Oe0<<kxl>)W7ZB16i$L`43VC
z@w-BoFMtM&6G1M54m!Q4;Q~2-3wYrc#QD%!*lrGwPSEVF<wgFM^B^-jd%z3NVSWI0
zgOEcGbRr_m;U1j=KAj&x_Z@*nn}0Czx79*z1x+;W0-pffYq|$i*8buIMcWd{RBvy9
z0B9u~s38aoz$~cc5HZMgGNAclWXnOVNsy)8kbAUY?tlj%SROjE;%oU37Jv|AAj2x~
z0GtJy6zqi_T?`384i8WOf_r$N00bRb51L2^x#)#8*!i$K%t6kFUW@^a|HB~TI(s0q
z?9fyPs?w3251ENaNp&D0{uTp}-=P;fK?XZ}O%($e7+xIZfJ7T;At)@`K&!hzf!0|9
znti;;-va7af)X`E0upjy4WRi(P_YF|_25&EIt4&eieR<S^aolb0FrtU4zdk&6ey_F
zh0ZTBg9{qSq4SV>_ai7LK(FQTv3y>_`r<xR1Qh46D{4+d#lZOiTwm{mihzb%d@Mnm
z1C~QYAO!$qnHOX}wHGP_8Z!o&C{V)sq7o_wE_keKR5<usmVt`VM6h_Y1gNlT4FMO`
z@N%&`M#aFR7c>OI3>t$0mw47LDi$U29-Uwj@JwE(vj9jIR40L^Is<$_Cl)z#ytvK|
zDx@Ga9lToQZ(RneLcr@{8jpagMo1e2yrckLzk&yqK!)=R77M&yIKiVE>cGvQVS_06
zd^)HchAcF4Q4x6Q3ttxu5(g(l&|a69W$^oLKJ({02!O_aKqcBsP0-i^xLpLlUmjHE
zylh7n4-nwjge+QnX$&|2Gk-qhJ|IxucsT=E9CAx2DDA$qN46JoAqFU6y<7wr_vt(d
zDxN__`c0m{|6hVe@j&fDxcK`Q2SMTo!Baz^aeG$7C!nsj>7jUV5A8)0sAPh~ljvEH
zSZ~ooNR-|8=wyDOJn!%Sm*xN9>sp;T{{DaY1-uH-R?CNh;l(31P!_S31F^3`*g_!o
zDYn1=U$BA<?>zi+TP&!Lb`%t<@X!Wv5JAiiI@T6+g)eN(-9?4tr2<6oWf_D9>A<0#
zumuMoPI&nMN_#`he5nbh4};7`xW*2w=<rJwD9r_?kG{MNrqL9u#{T_}(q03N{UbF}
zA$Qt>rqfwLSKWh#yDWUV6?|Ktlo-I$JyP<%1RB$BJOVNVb-fHIUSA0F{{7$SqQdiH
z7dU8LR4hC|p$59$sh9P73@B<vEy06FpjpLUXiKfP=p3kqk^ps{A!CH#sVNtgf)`G6
zK$)yWr2>@o3Jfp32n0nU^oFRvpkvL!S4UafsFbk2C}scqAH3KfG)PqNVj2r5T0zS)
zL5;;Oki)w}R0@20OF&D&zk75BNWAz|2%2gEtz_u7cyW{!+E^7%1lbB+C<z*aMQmX@
z3~FY9IzFHVtcDM0xyJJsaiD?n?iv*Z{%xQW&k(9xLECS-YgCXI{v@(PPJ{vtrFnGA
zdV%`Wt+)AGE`ly#1T~spoCo{x&`xUx(EQN*lb|ld_0RkQtZa4+4B%aUP6i&woj`jt
z7(6<eJbIlnJUX2$JbIfzC5lI<Q-Mcs6R76!=med7&*0J91gfJvI-5Yb)}yxxJQ>&7
z1g;Kyn?NJf9><+PH93RFaVJnKgu&x@6Q~LRPplnp0`)<mOi+0MW_C7##xXsPH-S<-
zNaQoWppycKi1^Ge*aRv{K{ROB0*D5sT@Vdw3GfScfm{IMf-K_~>;gG~U$6_*?BW;f
z0uPaQ3cr{R%A%LpK;5q69-!q5prbI0z=ba8?)1(^u)=O;kM12{7HHDzP3+(QFXnMT
zdPw&{*#UHO^FOGP7bWbV^(Ns09^K4_-#of)&%6co7bbuP-wiLlXafg4IKmI`x2y%}
z?zN4KW?*<x15Zhv$G{5}w!}ite>@7>#c%<%nMDEA28G>e3At&-MaANU5*x%VCqSmb
zk^=1b<f+V%Waa?s9>N40pn~AxZkS*;^WXpAF<_5w?HB7nuIc5y4j#I-?E{YndvJJk
zPX*P7KHb)!bwi!4AkK@!%%HBNuFpM?KS4uQpzE|8|4#+i#h~ks5Ae6df}IA-CW4^G
zMz?@RXKMh6)qIEvVq5}<*UPE^vaOfb8+29-=w>Nb2~Y?e^yp^Q0NHW86;v=Vu(2>e
zrjA=d5%1B<`ujEHM5-HU;KTb`K?(AO8YFBwBxAs3^t}iMh8IF0--Bk3JUSsqwtWB{
zE!k_j8FWH#=ld5*tdQ{R1POyzaUilA8>ou|YSDm#6S@`g5)0_E()Exwgl%sGXs4w0
zi#1HplEDy5cqoC5hJ{BVsKtsA9=*Ib-~9jY*$kfgeecoP3JM-bNc6I*gD#Egbd~Vv
zW!=mMxfJ1nPv=^2P#^*bbdDOoAov#e7cvlEb=ZLpvh20J63)Qzf&=PC16W9if+bB?
zx`N{J{R;^eNJyNEgd`#ZBwxP)MHX5}fbMPa>|76;zVhhS_UN_k3kOxPb3p<xW;4PA
z1hmI+G9-N*2B&p@um!O20IlWo0EI_0O8RI91%OBAeUDyNGmyER&JrHotR;6qTP>Uw
zK=VY91knr*g<e+h`h?DAP<i0d%Q^>ib4+J5Xc?zRFRLGDH^uR0cuMMYHt;y!47#@r
zG{N-ZJu}$j9qynub+7I6Fb0Mfw;3SrhX+<4=+wqu(;CnqUFZE5ubIGlTD2lT<AUE`
zXuknXV?KYO3{J;$!9DwK*1azo7`kgzczn7QUfg8*`~T&iACUF49>>AC0W_5G@&jn<
zq1V<C6h|pgYc)XQRiH|yH5{p2c!5?V9OV}T6$$@A5erfbb|dIkGf*G76Erh*+(iZC
zMet>43NPATLmXN68dOJt<Uw<&;5g9+`5iR4+8w~*)A`&7bjvMhAld;m5hC!y2dwk|
z3m1^i&igNHKy-JAihzf;sK6}-2L9GY(4CCEw$-4(oA>_@WUmCw7Z)OteDMLz7snvJ
zu!Q+y9w=Gj@x_5x5MS&7#WA=91mDu$`o9D`AO@=V6+jg~*yAslSRtud!K3roi&Rjm
z1cg*-6e!x>dvvl&y<lK?kqb346-@ts5eqW9^Ztv_SO5RN1g#l(Vg2vV|CdwY`(a*a
zgZPCAzBGt$4Ci}*2Btt`p2}}Q!wUMK^T;lN#)Lsv9Nh<nkrc?gpydm_pg9O1l>$&7
z3)CyN1vU3O!2*!J6=(qarDFtmoOwTJD&WPxe}Dda90w&H29M6e9-XYA&lwnA@`KYB
zWW3hnI5;<fl)T&kN?*qj>21RA|NmcP|NZm-r5(H-{vsO0SAn<VUwDJ~TnKq<5dXt3
zSi2b10Ji`gzXeJsFZ7@+hZia@|Nnnk_Wl3=7r#IOav6NI>Cu;;L;n7MsTB%3*8@aM
z2NAttfB(Nc1Y%i&j@|7%`tmkNL>hEfY3I?GD&e35(V!f8C|wfq_y5aJAQ>i5cI-U*
zQU@eb3lgyhu|mWCf-cjm5a8F`qXG^%4p0V~;1~iKq3`_s!tv|>|Av=*x*aOOJ6d1(
zcE_j`cz*xj+0AkpoE3h6x})6|o}HIGy8Ss`tAg60kimNXmOEfMe-6;*#S<V+mY4Wj
zK{4TBdA9VHM>oGm=Q)qolcoHxjllgRk8U&2LRVFvZa)sgOFo?-JwBF~_@^B3u{_H^
z<&eUK(mNiYRc)<cgM&F<3qbT)ek>{W=sfSy&FRtYF5qDuz)||zquZUs@RH~E55B!3
zmpwZ#dUi8;bRL4J@4V*GE#zVOtMsdf<%bdn(6G0tN4FzHy{F~H5_Zo{lgnTS^1Yb%
z=g)soDb3*73_07F5!9zV%rDPicmT|r0Mf6AqW?HZzh^g-XYUknz<O9-C=v8L&IC$g
z9^L$}mwR-6c>Tz;vj;5u`YF=v4CuU(aK|vu&TF7!F+4lL6G1OD89)uOqc1jo1})!s
zTO#Juy#rLM`hZ4o|GkL%`R9M@fl@V(Zr1x(L9;@ie8BTt9^DO~j&rPIjAJaQ4-A?b
z0^K+I4|E~4Dn!$1Ptd8;ou8oRp?5ccTBfhhAUVk~9JCa}v-7)S7|2cF$+!%U?){)P
z4pLXfMJ2-U0KX=vYXRGE3o2f~M@T>l8_;^F-gt>`4XYU#7??^}Ji6m0z%kaVbJ)Z3
zZb=llyV{$gV(?lCe7`1}NAqD0$S(B~(DvTDCAy#$Odg;nUjVdKYT#jct@H|LD#XF3
z^U;g<5#aq393GZ;OD}`EEnxeh?GXmhm4dmSKucnMR6KmTV^kbK1DYJZou_;?Z+Ra4
z#mwLG43xNfT~rJ}YaT&&T~6@tW_gX6HfZ2)Sp!l68u$0<JOJ8+S?A#K{kuoEn}tU=
z%LR{4NY3~NR>a}aUC8lT4U+D<Il+hPJ^{-Vg7d`(kWS0X{H^Cfd-^RufbvDAfKPX!
zgpcLd5;xCoe-7Vnb?CfHcPxXC<-?MCpUwxbg%J~a9-z&lmIq7HJ**{4KY=#CdRo3K
zy$JT6Pq&YXhiCIqMuZoAEno4sgU)gBZM|K>;nR8l#qOVf{)6TxB9MBTnczC^NCqg0
zLlVzn*nEqprN01w%SVteIwe8Yc{Cs7@a**G@U(o#58ku#x*1dscy{jqB@xfwTt<)9
z|D_zBoo`>3{s)~r^Qx4`v-u^5Pv={oP9M;c4t7XN>5Z50=nY`>=oI(p4(IsRgpy9e
z1$=r{E_+(uDOGqK2{ylz5tKeWn-6k;jq$X+Q=$*{Ff3{KSo)|0lwJoV7XfGrIrrjh
z7$k*&Ou7h9A;KQr>>kZ87(F`K!3Ens@VIY`iUZg{kkfa8);H{j4!`sJXg>7lJmJyl
zqoUw(@CUPp<q!TAO;BwFsxjY#!e&2gfrLk|2m{D}py{@<2#}2uFEW1o`42K#!n5;$
zC*who3l%&&WduBXeFQi>S})ZnfmUhNgKl>_019H?PJaR4&Lf~k?n%%MnvVQ}?BL*j
z{`dd?mx3UtfmT+5Dl}KaldgsbUaxtv<=dbCo}F(I>EPve&|y_`zy10D@*8-0@^Nr6
z;iIAe3O|V#!M~x70?q0vcy@x0GXnWg10=2B13Jm+MgMnDS^=++2I=c|QIU8F-llZi
zMMVNs;l7jxt^U~o3n#=nkgMR*4`j&8A0YSk+6F5zFud6J<<I{YKS8E;9(`#L1Zqhh
zeQ6J+#e)9+hnx@O(fJoNXRP7Voz8($=tvkIcroi8sG9QVE^zSdJnGZ=z~lQj&u&*p
zb_B)8FHn4ROL%l%_vrTKcn!}_(x7okXg%c(&W|TNzJK$uybh_SJT1?F@}oCog_h<C
za71?=;&0gjI#0X#2V+T1L#n}F570WU?qUhU+o0-1Y=TEO2RKW1dn$PJ#&9!wSRN~V
z?a}M>e;+7(JPy8K_UNr)W_+;)>}gj4aC++l8QIHn1GEsV!PkHhlphiEh5W6JptOa2
zbd&>wM>nHKbA<vEe|s5dr`a}F1CQgbpruL-%?~~{pJ3{6HF&*+U!Gw<sB!n=+t)w;
zJ-cfi3@<@jL!O<7d^!_2JdQhn^>`e2053Z8IPL&mPzDah@1S7x>1Mg$*?G|y6q2Ap
z49{)`(8&2~J=i*fZUgY?G)KUp?8o5=E)_dZczplvX?c;q6<l0)egK8$70+()Sa1ud
zS^{msclZiwow=xhLWTh}Imz)t_891j_XG=2d$^Z1-wHHol>@p$+06iQq6DbH-phOK
z7<fEux;X>Gi>z``8@)sY)Ea*g3o;T^aD&5@F#yt}1?}#F&c%v*^cD;FbUuHf{PX|+
zmokX)%jVC2{=a@S!Lzs4!l&~h_>iP?FV^*flH_4<B7YGGHv8zy3*ckTkG^CJ0Hx0m
z!*BnmgF0>CM$+*Y-r(K14;&kOR16qFGrUNZDYSkERivJse?mPvuLgT`e)ed7V}X*Y
zLCae}^MjxPb)W7s4j*eH{+7oKpc%XKFIK-sB=-ZLSsqYwcYq}K&g)=rgGO_Fx-~qz
zeK}rhLgUG|JC^}`vQIT5=n#Bg)C8Xf60|&5degJpSHiQqRKW0(hvml-W{+;MZ_Wlx
z{H>tX5gwW!J-Vv}K+8V)TUZ!D>#x!#cz_Oh@aPsf20B>MqdN$+F5x<dhvf<Wri-9U
zS6gm_Tl5~5S4(e#3NY|Ba_2oeWmG^VnI~uz-4WES5rEc{AQ{i&&@=%$FJA!UfKm(4
zc}<?3F)9+Eyn$F}!`}+JJItf`hz079D15x%qxrDF>tjgurRGP_q$k81C5|4JSNU5~
zK!sNG0Y(qY6UAa+zko#j5TZq|O2iE>y}kr$mvoC9d&v&Ua*%zvt}XxhTRR!S<An!2
zkF%(N3Ocw4AYOavflv?5kD$_&<3-{pP>JgT+P4MGl^&hPeY-szd^!v8<jfDA-#>bG
zJ6QO1%Utm6yyOcS!UVNjJVE1e9vrWApzRGvzB~iZmxrNE@sFOMruY_+I4ED9E4|{|
ztqo2Zph3(Rt3N_AC8Rv)1#Q6tMbeArL!g{l0L__K%|N|1(CDK_C+LC|kg{H0`@`UD
z$zTE+Cjn1fbG$eW+SA%yq9OrmcJ2ci-U%D$y9PSB7WLpU3D4eA0g%d;umAtQ%mW{;
z0_vSGym<Wn&;QpCCwMj=u<+>o>C^ei2QsD3-34wPgTwg6x{rVUzgz_}7PO=aN-y(4
zTCW3MF9L4GDxl;!P)!o>0+O{n96X>k$wv=FO;S?h0j))fIbJKm+Cv`Qpn9Yv!K1qv
zoTWZ^eE;ZSdA-!%)ACE{Bad!x32+V330_)r@E0>EXS9Ta%ky81{OztFH-d`P7!^=~
z4?DfC7_8uk0;mCY7#yGAbn`;*11QP3BFb@(&f^5ianJ7`K%VgF=7FS^ll(29ew$}E
zBi3>p(r@$Q@a#MYO)nq7=>=TAgVM{H(kq_blHj@%G*JDb`aLAQfD3U@Z=T~t!~sxJ
zffeGbOh5}hPzrI-xJECp;6ZR|xnv01KM0)+02ksjKt{p~@t@!W!$IdB!WYzN!3y!X
z&;S3woDM0(LCqgfne=i!GXKTuw}1Y>K95u$9EGHxN8pob-oH5A4k_Y62lc(kdk<<g
z9eFtqbSQY|k(ZmiP);iZm*1Y9*CBl&Q2z|vEb-{HQ2{lTFxn;_-E1C^b}*<3h**jQ
z>YsXG>kRqy>Kyj8yj!B|(QW-A5VS@GJW^ch2yW|I-YtC&YC(bxg7#`az6KSEpwz<x
zKKrn=&I8_50QLJI>BpnnA;P0OG{M92P{}6GZXXqn*Sw&1v`6y+0g%`{4@-{HPafSi
zD*ppGJUfqhShA>;@Pd=qKalwx|1W?Vh8&<XBtUa7-(P$JEpY}Fo#6EO!uidg|1XO`
z>y<R$fd;jXzHIdb)sNwjz=Dh_G`<0)J)iD!<e-Awylr^k#f2w`{C5~!wSDyHc7{}K
zp!SCYA7~6&!K3p!Xtyl5XT{*#t)c?nrmD;bs@F=urD-QL7xK6Af<!I9mEQ2}%~1hg
zsc{t4tUhaa8&v&(=4(NT7<@U6r=^RE1gOfB;0Lv)I@dt1+vzP80Ig>NO{aj0_6sjS
z`%OS2qRkH&`CG1n2EIGDfcN-=LRG-CJ48joL-UjeD6e;hs3`EaD6%pz7+!j<0uCpS
zZkdZP6F|pXDe$*2g3RcKnBmiH=iB<fqz-ia4roS~f14v{%YDmH76yg`FF-p`K}+1P
zGcYiGb2VTrl>;pifT#oSG;aYNE(qDQ+IpZw7&M6paw=%C1V|P51iKdS#V$VGYg9mM
z3qS^d{Kmh{!N9ZIm*K*T<_C-|pmm7dJQqE{tyrG3puFwD2sz0Bq{y?ol*6O>5F_X`
z4v=OK&2t_H|1o=5e&TNe_W+K!fY)1q0u1U&85RZx!`m-Kz%?OgXc)R39;6*|egNZ3
zPf+SP4Z64Bl1H}(Xw=E4^9Oj;$pcj7v4Dnhzzv+~pyILH!lSz!sXY%`B+B1X1C}a>
zm&M>lDCq14Ps{J1_Pn`g=LgUsQzFoM(%15Osibc=gKz7B5-H#A0Px_`1&{9^eJoFv
zJn{i;M*{ckx?MS53-QY{cv^noZxIJs()k@UX4M@o;9>2=0m_)5F(;4jAK_z8LLQwL
zCV*CNb~AWb{wV$GV|j?bWeXSRY{zdUq8{CDAV+@x2p)6t?PR&^(QWS8Y4Aep)t~?H
z;ihlRp!qx|{#M?9|3Qapm@|U9x82~rHE6#cNES5v03Blq=kVxtmw@)2`CHw=lM&$p
z9=$vlKm}BQhvkV9OYo=%I8TFCGQa-u|34_dw;m`>_Gord;oyKsS-PkMl->kwxPaLK
zEpfcKz^96sGw`=ofcl>sT#?V`<lhE%F*q4@xTu)(w@z^V`~RgIBHkS$JiEgZK%-(4
zz#TFnNWOrSL;NkEC66AK9HsAkI{*I<-~c(+!?W|KCnzT5KzmMBJpi@$!N~(OPzV{8
z1TBK~fTxm6;8X%?K6`Xq_;$VkCluH?3?!Xg2DN{>k<-Z~{#H=G-xD+r<I~OV)19N@
z;nR7{xAj1&_-k!geeY{|7PJf+JXk3PAFKqYmrEs&JS@M1nhBxcv;uCo_*fn*$?^fU
z>lnbJT}b1T=xGHK4xPt5py>saomyBp8Ng{%6f_8BcnRc1*cc_qk)3QWemzG@FP=y>
z4rKEluG9e<fpeGe0Ht4O>WBcP4mVJM3xJY<04Q~w1s#Od30_P9o_=iwwfjNIL;##j
z1UxKVR3b_*fRYKQR|j4*3p(x(bP6$l>l)CIgVwV@|G^7WApYxil;GdSA^<rr<fR_?
zG(S*z(E0vF0_b?z=2{H~$kO41FG2Ol`xlwd{`?26jga){29M_n!dlCq1G-u+vxCb*
z0sdA=Hc<7D$^kx~7_zX&vsp)lk-tSBycz&f&mawR@o+ORcr+dXRY{<R7IdTwHr`e$
z@KOnUh#NQ_J-Xc`z!L<}{uHD>1*c>Fme>FO|M%?n<9N+C0a~B(w_FDebAZz^Bq6>3
z51KD}1q$8_PtbvYhxl8->G{@O9O*d&6xrRNQjc2cIb-0{vkeEK^sMz1DLsP{q6H{J
zAc{OtFNOF-od8PIwxCc4_Z%faiTcN9P?2}UqxC?k11K#^fYY)BC@m*Iiae+t{4Jof
zwIFGk9h8>i9{>6O@-Jkv2h{QcP2+;fGti1&%L^r&Km*hk9-x#U081y3a;;=Ks7(6=
zDpWFjIzedx<RlI7Io$l9QtirZP%0>>040rX&~kxGzTL3};IS-33V@tuV*y%PtO1^K
zQJMgoZ#e}n&!F=yAZ?&d-d6Cq@`=)0;G*Ins3;SAtp(19pwUqcP)P<FmIh5Jc!Fy_
z&=8o9<)xAb9+u}pr-+Bb=2?6!50+%&D#yN|)Old@JvtA9q778<f%bp4>|sNT_ix~O
z&$E-~GT3p9FN_|8;(aY>;W(ow=nM%&l!NA@k)qt4!>2bNHj}{Lx)NN=xeIvqx*TNy
z1#5w)<<Sy-&+b}=7rdaYv7oy-K#^_i*?g44$1+Ey0Ms*sY_A2ESfHU%NG!hv#d5{N
zKmT7o2KPM~KuZ9?P3ItRm9-bt$m4h|gw&saw4axN;}_IA*MQbq6`=H_!QTQ}rt{+K
zO<43E1|{hVP)YvHv-6T?cW{AMH_IhZOA1uZfGaLNQ1hZ29L*KrXx2s=zW{HB;cwvr
zt3iuz(D|R9mdNp4;sk0XfWj2yw2Ie)K9=W8WkHi=pdGsGte_GTHRkVu%5ty<%k%s#
zi^0h%l;gD+G(G!R9^`N71&xoR)@jc{eHyT@K#fk2SA2R!KqH5q-Jo_5BD~Pj#Tyn#
zx{!s{Z{T#n4>QE0lji~?efV_F0Z*8{;Ccw^14B5T&8tC9Wd!9r@U3|j9=*Jlk3l;Q
zUcCtX^#A`$PVhlW4h%1fZ-6=%KHUwVg;e0l;1@pK-Jtm{(ClP4%SF%tF{qc30y<#0
z8!~qT%3q)i!r$Tt7KP5+fcn&+abgBg%iZ#8=`D}W7lxNW6J<W#nF1i$<BpJV)b2zH
zenCe8-(H!E;MfM87!1uH|3F#S@@MH+&|D*^RXGzh>(Y7>)HH-oM_vL?M_vRe>EwIC
z|KQJmkLJ~&(MCp}&esj82Jd|>pO%WeHbsPQ^I;CqTnMNK3Cc3>J&uDGdozHNcj==S
zbMJvn04piI3m)`2^#im>;Qfou_y7EVxfeb!4;msZxcBG(%Ol{)a>x<n_8=D`wOjdH
zyubec4{E!j&Uf;+>;>H*1e^0Tf2jh$&%>uXU*e@7c+n{+kubdAzW3*ULyZckIjITi
z&98yp8}j+?pZ_nF;qCzsK!faur4vxQnZM=tH&9V-av9xz&>`2*Iai-<_Lo;cXLo|b
z9Wsvc>>el$IiroE5Eym)0P2h)kE4JmxNwZ4n1J&q<~WKBNE|ed0v>l$1b1CQ>j_^N
zgJK4>4;|EL0_CsXHQ=N9UU01kji$f`-eQzNL*fuA(9j$5sQ7{P-~p9J1qOx}Aqk)Y
zXA9T}(0G~)$oNi3-w#~Kh+2Wh#^Hq^ba=b~+)wuD{O;5F?ghi6|Nmc}0AF~*0G_;T
z2RR-wSAL1VCG9Ub{4atAAA2W*R}ooW;BNtsCqolnH~&iqa9IkDZ=cQsFE4?)koxll
z_nklgUw6XOuTQTtWPAoTzNcLV8s9te@&Py_gWJO1sA=H%cd#2U(g0|OI#L=~@EvrY
zlt<?W6#GGw@h8FKx_eYWMafG(aEp||vlDW~`b#sgV?p-vx6B9Cr`-<VejBKq;%{;O
z39_39V)s;#4?)}NTIPZjLXtly`N{qSEoK7Ag3KvNhPfYNhCFy_Jaj>BC(i|NTAmD2
z4eBH%B6;B}QhT)X!^<vE6SK1$6zVVgz`^6d;L&*kJPPB{dE)g>-%g0BFF*bPWm72U
z#Xk_I6=cE7@c$roGl>0q+Kc=<pcePhmoGuL40IlS$qPEwyz}Tw8z?OWrCFi0vjyl3
zIw*(B;_v@7(E1Ud&ZEH|ou@rIFM4#|0x>|l^EyLRI9$3@KvOxOy>Z~JEugbyEPs~d
zIPz~}X#G~A()kg3ER#>KI|t}E({BEj1N<$WpgM^2lt-ty4`_ebE&gpEJT!lOzxQIp
zjX(cgTc4CD?gSls06oLPqg&WT^P$J(7Y(%x3?<ecoEJbl3Ywu~sS{i*pOwI@0c!&(
z?!4e}`9<ePkd=xT92+bcJi3KTkAe@~N6`&RC*Lo5C_>%xGXMYo{|ulb73F?`x12T~
z;W!M<zN6G=2#kinXb6mk0DVKCEH$|#zsSle-Z#D|H8CeAKRG@#uQ;`+gdsF9wW1(3
zxg<43Au}%}wSoajX-aBZVrfoEd}2XCYF-M1YECJGY6?SfYEBwMX-S%{1w(#mNkM5z
zd~$wiUI{~H9x}TuF()%cp`@}PRiU^bH90daGqs4JpeQvtvp6$9Pa(5dAuqo~Av3Qe
zH9fV6AulyOu_UuBRROMop*%CCBm<{9uq=atp^>qPshPQjrK6Lxi>n($UTJPYrCxG=
zQL0{UX--LIVo_0IB}2SpP>^F}ykmeTLug)cX+c4L5y-zurD<uYMG9&8MY)M3iVP)1
zrFqGTC8?m83C&AP%1Koy$yZ3u&nrtUDp5#I%*jzmEJ`oUP0cF-Nd#1uWaQ^5<R@jN
zCYLB^B<JTAWagwQWacTPq$ZW7E9B;<q=L*=NJ%Y8%*-hU9YKX0xJ8M1>8bI_8L7$H
zRtoX)c?ufk8JWpoAFEcCYAV>-DwJeo7VFv-XI7<ZXrf7j90_Vofx;XTaSHjRB?|dz
z3Se^;G~lsnpj%z5qmZ6oqEKB6b^}POXI^rCUU6n|3CJ_xh*QW(%}X!I0K2$2Gq*G+
zu>=%P8s&+_3YZ3j7v<-rE98~tCZ!gEECm};tN;qzoXpe|Q1~Dl0(T6$NlA&tnaT0R
zB}JKe>EP4}a#l%EX>y4|UTIDaIE{c)63EdE3=BE>i7BZ?@j01ksqrAo@{3BWz=^0R
zFEK|UwWuh+2&^(WF%Oiyl8aIkOHvhzOH!<?An95mC$T6!wMd~PBQZ}QH?blf61reb
z3=9lN@t#;*q5zHK%)H`~#Jps1dT`d(hNNnuV%#OQ1eUi7N=x)1`9%SoUlejPi*pl8
zKrx=DfD~B4Zte^W&iSP|DPZ4&Gb_jwC8Y&9snF!62y-tMbt#$2C2(a0l}VX-DTaoi
zs4A!g$4`Dyi9%6oVQFSjYB5yU&Q`%t&s@&{tG$rOftv`i*%=bPuq*?L@7(;NR7kLz
znJ6S>mK1|jI_KvW<fK+8lqKerrYb;VB`H+_rZEMih=GB@7nE)CK@Q3<fx8lvr9he?
z$*fopq%N^SA%zHaSi&VIvltOB?)fDO+2x5v>BS1=nI##ZtdppamzbMst&pFWQwe6K
zz_WX?LT+NELQ<+iL1J-nYKlTxW}-qtrIl4;QM!gE$nPL7xHL#B%}WO78&GkfM{KFU
zzyNX&xWEF%F*vY_!8tKIwX!_F2;mZ9O$;f5=E9=VJcZJ{oXp(JlGGHWWCjiQU_?&O
zEJ-bb<auzRonMw(l$MiU4oPZ=e34pFQk0ksDh~^aOLI~|<s+yNDTb(n8jC?$wEq47
zq3Q4c3r&Cj?`Zn_e@4^a{}oMt|3@_a{cq9q_rFBb-~T@v|Nei`@b`aC{ons4^?(11
z)c^herS9+lD|LVWZ>jtHzo+i+|D3wN|9$HI{@1Dd`(LE?@Bi2L|A4W;+`s=d=KlR}
zG57EP4|D$h|1k$b^F8?UAA~s{{Q1xF;Lrd6_y7F=b^p)*ulN7_|8W1$f2ju$Hi#cH
z_wWCbxqtt+%>Db{X71nrE>K$H!Jq#iER4e}l?Q+Rdv5ysU;e=#f;e*>aq3`ZP1``6
zdYJvDM4AtB$Hp~;%?8<z5t$4O3>+{1{{Qg&@Bb6e|NdX`{O|t<PyYVj@Z|6RjwgTr
z8$9{@|HtFM{{tTX{r}+6-~R_5{r!LA@!$U|9{>HX@aXUV1rPrIH+cFN)J23F?Pr{p
zTVhmZW@rSdjpM;Zxhq260#=e48i0}~9(hA>_CZtNhtO{bZswrLYeo5)fT|)x14K#e
zY~qU0W|ondmy(m}8eC$LUjWMCi8-FZC1#LH#WUDA-ZQwwyezROGcm8k(<`{d99npJ
zrnm;1#Cryt#|I~ZNLP>vuu{U)E!aFh%M}DbvaazUR%lL^YdqZJPzE;lSr(_3#Dgnd
z*Ie9|BfAk~iE%u-6O5rwz-lp_?Kgn>+zllJvk(aZ>Ye}s3NT|6)d)ny8k#4SX6BS+
z=EbL0B&UL-)|G()N!}nivA6^+xiI)y#>c1UmBuGmR2UlPrIyD-tLgkA&n#DverS5O
z05xzyZ4)y{V-qYJoal+}BY66^gtUlqQ*-l+D&t|Ad~%JAT*2BvhBGiQ1eX|EBqgTA
zLsMLQVsdh7F}TKs1Q3$@&B0kIJ~5{#H8G_!zBsi6DJa0h@eB+M2had$<O>;tmNX(`
zh%F2tB`~Hvl)=Ej@L|87qaTB(pBqDFUK&GQVjien4r(c87AutG=PM*-rZd2s(x7%)
zT7GF>3a9~|%8-_rQ=G~GZFCgmgToKp3n<OWVaUt_HwHmfV{T%J0z?(UC~(e3X$Lcu
z=4I#Qm*>HCz`G*3nZ?DKdFcx3wd$ZYJEYiwnFzNhGbcwOIU^BN<E0iUs8_2aoRFE5
z!vHe`-fKbX>p+SIE32Z^;?$zDR7B`tWAU>5`)|RCz<o^r{<kyz`>%o~j;w~7>|!Q_
z-5_%VnEw6OXZrWQ{NG;`cY)+!_z&~H|4e-U{%?Bx2acV&|NXb&{`X%5O&nPbHQBn{
zsP+qU|NH-w>)-#c9H`>Rc7Epl_g_lv-~X=1f8e-Q_}~9h;eY>i(8Q6|P?Mb|jB3A^
z@W20D!vFp+6+{(Bwv$`z-+v3`fBz*O{~?Gq<%m-UGb>q<IQ205KgklO9^?*78NzBo
z_S>8M`(OR&4?*l|K%6?5Su>1?QxCIWh)DB6?&#GcY&OV#4!eK<K{&wf-~R@?fB#?D
z{rj(A|L=c?{lEVw?En3DaQOG%!S>((4G#bQzi{~XU%~O;{{+W>{}(v^`~Si5-+v3c
zf2i#x-1Sc~sEUBqCm8h)NH#dpGa0E40F_5D^@dpMpJbn0Qv(A~1(fUxGMxcY3WCQ@
z5TzcdoCOz{AVV1#7)tZNUEI_Z?By&2v`1K6o(bv*rxoSrD&!{Sl_utZdsU?+`MHTD
znaS{u7-Xa)GcO%#JU0D_a9t(&FvH-L4Y-Ct(hn>4Vbuak&p5RR$!ds=xYZYDrst(1
zI%*K*NCRG=Y7W#$C{IlR2NGy(2jMSJn-;1COhLDb{r^`F=E4ckeW)M~R30w-|NnnD
z8zKL`{{R1auy}4_c4|C$1VKa7N}&{EbPE<hp!yj$>OsoL7MA{Yd1_*|LQ!g3YEf!l
zaw@cYh(%py9->>$;F4Jc8cj<}O-)HkOwLxw$<HqU4WPjWQILAD3ZQ`!r2cELn>!-*
zK&_12#JoySW1yh41njLO&_GarQEG~U2Dm?Lg)|`Mng<?}Nd?Jzg2&YI3t-*h{L+%*
z%#>7+eV~>CqJsc#hZQAODxmAg#2C;?FG?)Ph|f%6sIJwkt_3xR3M%!I^7C`z89)gq
zF{hZJIKQ+gIh6r!F9UcC1(Y!2K?4(@u~rZU`Gz4eC5555G>M_Ou&9I~C9{knH#3hR
zH?e{tF{zj#IX^FpAvw1+hao8~rxH3W3pciyAu}(tBr`E59^6l2C{9a<8XJ$KCKV)^
zSdtnK8L<K-DZCib-ZX;@cN!WMR6-I^d`V(DT4{r66sCRysP4pqOi#bycv$}nQv4vb
z&tVdnW+ID3VOn4a4q8y-KDEd*xWodfQ-<7o%W`!sb2R~tJGvq{Bgxg!2&5stya+Tn
z4jFVrvJhUL8WmR-m!#&x`VSh_s<oO5x^@bF`FW`f(BWVkP(rW+4}U@i<>M1eD;OXh
z0Z0?q$_ivlUJ65cY96RmiU+yf3Nj9<#GnLfA16ZE_X<U+>7ZfVqSO>chWPlx(!?B4
z>WPnMPz}{n4P}Ur&&^LM%}I@qXNU)<tN3^ZD}{i{kjjG8_#jXZK_M+MGY6DO7&Jj9
z6r~mvffa+24VY1!T2fpBN*nQ@mN$cftpbCFR$@_lv5tb47GzLOlZ(N>EVT#}YM|l{
zIw+>c#l@hfz~GixT!P5A44{1LoS#<=9`(&H(t{@0f};Gg%#_q3P<jQ;E5P^+@Ln&1
zRSeE6@t`5AqRf<3hT_Ds)cB&*;?kUwVus?9)B*<h;1)wsX<mG3UP)#SLaZ1pn3i7z
zq8XBNQWJ~dx*<HUe;JJREEwXG;z8pC4Ds<P`N{F|pv(qyIRhv`fQAMbKxJ%Z9%uw0
zu_O~TkHDayprF8@qrd=)dIm1fyt4f4)D-a0qm=@KwE_bq*sK&7s%vel6^m*aAQcS*
zc;p&nS!Qxcd^`gKY!oCuJ+%bVIRx3|nOBku>SQ7Yz~kdV!@%+J3c01lC7_YZ;#BaY
zMWO;oJTpHpv8Yl9GQO;!uBvBbU{I_MO1|I`O)Jm<HFWqHHvIve3PRLanRzAo3W?}-
z1t?vDjYT9wh04?tdrdtB&`>b;2@>$gab_OG%bEFkdJGKV8L4^TDVNj~P!SF;e-jmw
zK;1+ISTO5=$6!GjSVI#ww49O;bCIr{0%)in;(pMSQ?UYMeg!)Atx%GYssNrJ08Mk`
zrzw=A<`(1^B^Fge2CE^RX>bZgpKkzns1-n!d2(V2s1FGmS_Xw4j`<0w`jixq+JeNA
z%+$ORh;p?23~dd8a$06$PG(gqEQd2FSt%sK=bAtx)}WF067VoJa^_D-P0P$nO<`cL
zQb3H@f;|Z}3R0*lVw+z`PJ|5T!jynr7#|N$anN!jCqEffcNoW~Cnv|}WF{4tq$C#<
zfCfSmlQInr42?m_lmRtGf<itAG<seH?s9_@3AoxTDJ@D>&@j>@O}(Ke19biYl;c5B
zq>x&XSqzSfy!<>}SOS60StuwmFeriZnnEHx@qi|+Kq;U&F*g+)j9~8~g$pRdz=9+>
zKd&UUqC}B_0pwMf@m5yIJWxKw(z<~uhPnk}3j+hp;h+?esF0gll93N74iu8|OEMHd
z<qfFqnFpGbh0Z-e6cvM_8`PGB&VHq)SSx@E8az1*QXxaqGqQ_`azA|P3t~OY8^NIB
zBm*?tSx{Pn2-H&0>_|zzLV9WmG#5eJy6{QhWCieur9xr}I0L3<mZj!FTJ@k7KPX1P
zBR-(nykIwX(3B52$gta2tboTtusz_09~M)CO7j%*^HLSy^#VLSASOf-^HLOwQcFsU
z^1x1o)F+?_gS3gD9)vg%WFE*GMB`8aT*)Y8mJ}mdl3A>f4xW;PPC(`tDWrm`Xqexj
z!2z3z;X-o)ip4M&=YS?E;r@U)hXLfCL<NX(km)m!a=5Bu5D(40WZ4C>2hALazd?ej
zc_|=!z(D|RQ-f#YixtSS37iZV+@a|%xwNPVJar8VD$q<OXoL||kY}VKbrT=~0@9bL
zkegUg0E$3xKNAw43fZZZ;6wsmIiLV_At=KqX6Av^f~Nf;N{e+AGV_viO2NfAIF;t6
zreuPqW<ibR)M6d3<iwn0(8M{Y%>#<sM9}0e+=ZnD&@_>kUk)k0L38V%2|93rj@)Qb
zNCo%MQuMe&GE(8r&Mb!Hl++Z3Qb<9XkqUCZh9;~8$xl=8hxc2+rh?)jv7n$Rzn}>0
zRA>?c_k;DgTq_bm^Ro&N4=N<4m82Fa7$XvFv6Vu#QnI0vl|r<!j)Iwvf_bctf>N>(
zNWer#!Bj`V6eIxZXBg@kfJDu86by6}3=pDV&ANtQVIz<*Oqs5cj)JaXY%Mrqok5K*
zP?ZXGN-;EmQj1a*Kmn722s&_tBGkiD0;tGL1tm9-j}h5WM*%Xd4=;xxUWFt=czytz
z333Q@!oMuF2-IYNPtjW`<bqqx3ZNK+7PpXYJXC{fv5rDgDWpsTCyj!lR8UyL3<5_T
zNF$^{Xr-VEp3X+E_cHUK7Fk(AEYyIm*l<cM0U75Q?CGo!lAoWGlwYCXT2Ydk2X>|}
z*l{3F#K(gg5ApFDphY@53VM2apr%m{s67u(4zPjk1dx0Jyfw!FXBF!yfRbEVeojt)
zIXL~pm%LOKq!ueAf+7UAg2svq6lNf-S`1plQjlMawoFCA4*wz+E-shM6otzCQc(PW
zYK@Y7g#=|tHcM5oDS$3t&@V2@(aW$)uvhReLJ|c9XijQ{UWT0x7eXzp%1s1m(Lq+8
zQIwyT4^pj=T9T}%5S*WzssJA@;zDjJg1ngzo(xLNftFX`6%z{J>2HOMRM0XMaJi8L
zssur$LTU<EIk?pdUI+vVy2||0A_bTipb-m-B-C{#(Dg+ySHr3taG3(C7vODdP_s!9
z96N}%Q+Z-B7bgP)gDY(AN+Gp4Ik5m#0D;ERV6ApY9so6TONtWnigOZ6@{6D&GN9N)
zp6@a;fREY4gWA@xo-0Hhj6~{AL)wc3diY4{A<Yp(Gq4Ba6Z2ByGxBp%Qj1VbK&UqX
zby!g3KyCo_qjeNeJJTR>To|riN1@su8n4klnZ+g1a9(I$W`15YG)d_wfF+^4SRDoD
z#GD+^lCbFL%)F9V9dMf~C$%CL1dx05I2-`AKQphSR!5<lOsnwN12rG)Xv%$rX%W<X
z&_D&q18^%qfdLW#OMnM9z)paL8$2|i`l0>@t459qg2qruKgkw@>;-!(6Vhda^Hm{U
zgYzNdISlB0h$;pK(23O`Ht5Iz5N)O42VPnT8#_>d_S_U1oD)maGfF_cJ=oMGJo75T
zyZ=^JXv0IPMTy0!3|w4}C01MvnpO%7@$t|$OmTcXTw6S-lFUqw2Q>#$i%KdH63{vD
zVuT2&v_bG7nH=PD2>$iw&wsDKfBtX&^XGr;-#`Da{`vD?_3xkm6aW1Apa192|E9lx
z{!2$2<U&+4Fi0~nFhnyjFc>f}Fu(;-%0Y0!nhcxMMJy{)&`8Zo&WE(Qii=BAAr&H`
zcZ*vetgZw31fmPHz7H}T46dU=oeW6dJU<!Sj7VWX>hHpo6vvkl=<G5uFr<T*Vn9Y=
zijl`pic7&W^J%3yIh6{ax*687&q!4W2@VD|-#`U1czhl$cEE#tpl&6^jY#7SARmEr
zF)-lO2O7u&b+9w@PzLxkG!-HGptVDMZfZ$la!z7#F;>gqvLGA5_F>hB$1+fygXSL~
zi6}lPu{f2G->?lxf*MCSjA4LxQ(>W$p9dYsv{J}REmwfcXC#6a9>Z&8U8Hd;kh{PG
zF2#s(HY+Pgb!BA*Gr`IV6xZmL7j!HZx~dtp91yzh5^N~6Qv&IZ!3@H;ln)faplJ{I
zx?xx=0^uHzD?rNPK?7${>p`B&1uc69ts;bJLH8nfAOI#A4~>%)$f9si0)Q_ago=SW
zIHh?=;RN#lC_OMrGh4@SGB9W{GBBK2_~(BGCj&#onm_*+a56Attoidlhl_!sYt5hk
zCOixb^Vk0Q|A&Wx;r`k`{|$H<7>w8b`TqrUhx58W|M&1QF#K8n=YI%41H-2cfBqj4
zWMHt__~-uvAqIwsjeq|8h%hir-uUPL5fKK4&l~^zHxOlDP}%h7{~A#ShO|w8{+oy~
zFf7{s=f95_1H-TFfBqMUF)#$}`15~?7z0E6jz9lDh%qoM*zxB-i#P+r+8uxXdx$eI
zyxsBVzlkIRgU-%B|3jo17^dy~^M8dj1H-c2fBw73FfdFw@aKPz3<JZ11AqQskzrsk
zIQZwkj4T5~!@)oQx5zRu+&J{-{|`9^hMdEH{!fu-VEA+R&wm3228NC!fBpw3GB6xJ
z^5_2>MFs}8qksOVC^0Y`JNoB;jS>UHo1=gJ|50LK@HzJ9zkvz^1KY_z{|~4zFod1_
z^It%ffnnvzKmR?{7#L2R{PW*Loq<8()Sv$c)EOAGPW|~`p~1jlb?VRm6B-N*UZ?*2
zU!cjraN_iz|97+)7;c>Y^Z$z$14H7OKmV6#Gcfd=`SV{!hk-%i?4SQ<bQl<7&i?tI
zq07Lq{Oq6q9eNB5-_HK||3i;~!S&pq{{{LC3`@`b`F}^Bfr0h>pZ^sG3=9{}|M`Ew
zfPsPU!k_;lh71f0m;U_UVaUJ`aOux~0V4(mmm7cnuP|a@cyr^=e-~p02G5&+{%<g5
zV0d=(&;J|73=EOC{`_BK!oXm3`_F$FQw9bn5N*!D&~W?D|3Bso43lpE`5$A+z%cLj
zpZ`2o3=I2j|M`Ezih)7x&Y%Ag)(i|~cmDimuwh_0ap%wf6dMKxsk?vvXV@|@MBM%J
zU%`%nLG00=|2=jL3}2r7`LAKmz_9AwpZ_cD85o4$|M{=uz`)S(;m`jQ4h#%mzW@1u
z!jXZ2>&Kt}2~G?Q`oI4C4{>H-2>$iwe~vQ)!|Y#w{!egbV0iND&wmCN1_r_3fBw&L
zVPJ6i^XLB-7X}8czkmK$xH2&GGXDKP!3}iJ*5Cgx+!z@2nEw9Hac5vCXZrhpk2?dy
z9;UzlRXi9N&N2P{Kf!~6p@RAE{|o#K3_Do<{@=mL!0?0R@BcHL3=ABsfB!$=WMHsh
z{rmq5=nfFpzyCS77#K2G|NfWZVqmCX{rlg5i-F+=>)-!9AaS<8|4(o+FuY*@`(K2c
zfgytP@Ba{P28J7)fB$dbW?*=s{rA5Q4+BGl-rxT-co-NYjQ{=*;bmZ`F!}qRhmV0_
zg~{Ll8hi{4J52umx8Y-8_+j$*e*hl?Lx%a^|5x}J7%D9O{?FlOU^rp<_x~Gy1_lf3
zzyB=+7#Mz7|NWmMz`$_B=I{R%0t^f%Z2$hhAi%(|!|w0@9|8;vEA0RN_Yh=YsBrxI
z|BfI71Bdh9{}MtB3_D!@{!bBNV0hvB_x}$e28Ir=zyA}285kt||NdVi%)rnQ_xJxF
zVFreXgunk&L>L$<694|cBf`MI0lM~8lz|~5>F@s%Q3i&N<iG!qh%zvEl>Ys{LX3go
zM(N-G65<RD8D)R}$AIX{zyH^WGcf$9{`>zAh+p&fzkmb-14r%O{|OQd3>mF||8J0B
zV6d3__rH%M1H+EFfB(;sWMEja?C<|Kk_-$PEC2qtkYZr?vFh*t7AXb>j}3qSgBmI?
zHvIjcBhA2|vE%Rm1JVo(7N`FHkC9<uSaIs_|0OaE3>>Hb{(mFGz>snJ?|&0n28I_m
z|Ng%q%fOIv>+k<3pmO2X-~T^k85k^X|NYM+$G{+Q_wWA#IR*xgyMO<;$T2W<y!iWH
zK%Rl&#mB$@*T^$4RQ&q;-$Q|c;m4o9|EDN0FlhY!`+tK114G2$zyHsG$`gTq|1%UB
z7$g+_{bx~PU^rp=@BbVn1_lZ9fB!|485mYr{QIAv%)nq__3!^0Wd;V0kbnO@R2UdC
zLjL_PP+?%O2>ti}2Z$f~@4t>J1H+2YfBzj+85nki{`()I%D|uz_V0g<Dg(oeuz&w&
zs4_5|2>bVcjVc4fi?DzH52!LQNQD3Ue+Q&4{NMi%stgPn;s5?8s4*~fg#Y_rqQ=0m
zBmCe04mAdb7vcZ@FHmD(SP}8>{{=M$293yn|9#XM7%Zax{lB5kz>pF3@BbHd28NEP
zfB!i&7#Ma${reBPUEoF3zyA&z3=AAG|Nc+VU|`UQ{rCR?NIw4Ge+5kjh8bo5{_oIa
zV8|%{_y36|14BpozyCip85nMq|NAeX#lY~Q{NH~SEe3`Y761O1fXczjfBy}%85kt0
z|NY+sqHF&BH_>5W_)+)o{}UYsh7&FS{x|3{Fm$y3`@cb#fx)Bg-~R`?3=ACY|NaZ;
zF)*xX|M%ZUkAY!E&%gg`^cWaACjR>`qtC!_WBR}U9Uyw%zyDwK85lek|NB3|fPtZ7
z@xT8!3>X+ztorv~$B==cV)eiO7YrE~IBx#?uVKW%Q1Rg3{{u!03@4ua`yXQrivNHA
zSxguhX1x6O-^PT2f#dbR|0hfs7$jc*`+vuTf#JpLfB#KP85lg?{`+5H%D~X^_TT?0
zrVI=}-v0Z)!<2y`<K4giS4<fgG(P?NA7aM9Ao1nj{{?0Y3>x46{WmdZV95CX?|+6l
z1H+2%|NeKFGce5f`R~7o1p~v3U;qAxSTHbT{Qmd9#Dan0#qWRr=YaTs{{24zlK=DX
z{|gHS29N*${ufv>FuY*=|9_7q1A_<C|Nkmh3=ADi|NlE!F)(N_|NmbA;xqsMKgWuJ
z;Ro~o{~xRv7-q2i|6gFuz`()w|NkCqQ2F%#zlse5LkI8w|1~xY3_E!L|6gFkz>vZB
z|Njje28J8_|NnE?GB9`u{{L@b%fK*0@c;h?TLy*`g8%=|v1MT3(ER`3!j6Gqht>c8
zOY9gJex&~Y?_kfs5Rv}>{{edjhK|ht|6Lpy7<Tmi|Np>&f#F8q|Nmbc7#M!^{r}J5
z$iN`c|Np;&BLjm)|Ns9MjtmSD{r~?5I5IF)^#A{#;mE*{G2#FJ2aXI3Cno&=FXF_&
z@M6OM{~AsV3?38z|F3XjV5pe*|NjCf28I<A|Nr0N#K532>Hq&XP7Dk)CjbAx#hHPj
zW6J;k5-to37W4l9{{gzfd&U3%6I>Y>GFJWnf5sJ5uKfSc<Ho>HvHt)66>ba+5}W@2
zXK-g=@YwYKzl=Kr!-=i`|F^g^FmUYn|Nn|R1B1oR|Nm_~7#K88|Np-NeCregg9x+(
z#aI=@z*r%`D9yvp0lJV5be^gVXao3+KmR9yM&bAb-1sEC__@nD8W`-QthJ0)lt5ZR
z`dt_p7&a{W^B>mt1c?hUFfhb0Ffjc1_2<7W0|bD?3K$p|RDS>Y4>A%Y3K9dINTBfh
z&wpKz00RR9NDOqUmCf%z|3PC<AYqW$8U_Xii{F3#gO5mssskOb=koi{e|C@}kURqe
z!xaVw28Z8&{)7613{HFky-ZGg5<Se0d<tzWj(i%;tS)>8^;~=!j(iG^d=gH40#1A!
zj@%3kApe4{>G`to&wsGz9Qg#AnWDJ(I9$0M`8XIrce;Si00G(81hUVGPoRg%kx!xx
zWOg$PQwkTKgbUa>FK$OJJ_$!K8)P&CD7bSN85m~#{`0>Iw9wgyPoN*<u0CcbK80Qu
zCq9iHR!2UAHa15-i)MBgz653tMlL=JM?M2bJ`E>61t*wG-MDQS7#MaiGBBL^^XGpu
z$Sfy5fj*E~y&$uCSX}rt+CXMCvoYmx@oBgqX?Ev^hS3j328KU>|NJk-<_|ZxKRl59
z;R4bN3L}sf#;O1xaEf7{y|j^mK^m5B0zmQ0z`&sJ@6UfuB?bl-eOm@l9P~2<@=5eD
zyJ7LGKVJhUvzjDU&w}mL0a?hvz<^|@A;M0+2F_;oHntwtUY0)Qe$aIfpfqX1z`)?Q
z;Lm?iMg|6!ub>cP0LQ@xCI*Hn@_+v)gA_X9iUSu=9JuopFmJ#f2Tt4x3=9l5%nS@W
z6#xF;&B6foBaS$j$i=7OiWCQ)+|2EaXku>MOfhIej@+O$zkr#6VfKPQ{~bVK;K(O{
zCH!R@kis9d-X4^9moND9KZJpSfrZHi?6w{zH)uL#U;wQR0Hw!0s(=57fWqgMHCPQs
zK5^$Wh~(naa7M}}PTZg*g)HL2&9oXVGr4p7p=t91r5%vFK;A%#$HaQL+xZNdS=(58
zn0uK(@dt`?b5Q(&{16Gc7><Dfl<zmNFfgR3{rwN>8!~wC3A8bV@PW!5P*|N|VPL3G
z`}-eseJscxkk|tj28I%~zyCpbmm!N!0F)ArFflMJQ2YBopNWBig%zjYConP{LGzd=
zH|SV*kl9FnSXzhh!vsc{Cm0}QD`-5bW&WT4TR`Ew*b1bT!3R{XGBYsrX#D-p2NK_6
z1rGmyCRb1%K`RfuL21#2Zv!LKZLC?uksB0NAcK+IB#7ju4U9PQ$ASfa{(l37uN}l)
zpfoMO#=yX$`S-sgs9eETM!CStC@($-CO@oBa_44Rg;m0l8x)5nYzzzwKL7cj4|234
zC=QvTL6HbblM~n&7_Mmk{hx%(e&jMTfN2R<YrMF@<A8VA7#MzN{rwNBBS2+P50eWh
z54i9tG_$z#88F3hffF{Qly>C?m+u0g%L=vs{s)~?3DN`26Rt>ghXYe0TC(uwW&ova
zA9e-?4V}OL-@yIl%**D|%iP1lbdQUN9bCtN)RnL^Fnl1O4wOc6SQ!|0=>Gi=8rx;r
zWC2YhPFT_iw9W`%3g_apaKTb#fYaO_R!AT2ASlhH!^{JxIafYd9pnj*UvEAK=4ep)
zhiRZIwtO(R8j%kikdquJKZEjt+WbHNy+G-W8Jruz;T^!nz%WJs?|;yRh%D?7H$lVP
z1r+8?rChLz&z+m;JD-FbxK0I^<$E|77+x6s{l5~FR<M=jh_vd$SHNr!@(Z^56jW#3
z03Bj!^!L9CC~UgT!C?(`2THqvsTnQqUAdWZF@zYv=>e1skn&`06(W2v%DRwwfBu8U
zuvwJNLE0En7#JAla56BwF#7v{DztuqwijIaU~%ORiYr%0`H;XgmoLMMuOOT+!;vq6
zxd*#vJ-C??z{*1TGMxAlAax=O7XyQW`QQJ|#Mo27Y|Vr<(|K@%(rf@114D}S-~Y*=
zLKqw;Zm8)M94F2oH+%CnFfz}@?oMw|eE~ABfP;ad#p~~XaGDi11IG)roOI=bg#(dk
z7L*QmfXe*2fBu7N6qehj;IIa@6>e}aFud{p`(F+e|Mx+INvLf*7d`_}nWo?ZYt^|!
z@;t}@q&S{gfgHyyZOlDPka_@AMjxN^=Rc^7Wtk4K7bJFpoq=JB&)@%`!+u%%VfI4H
zDT8cyBhrJLfdN#vquHm3Y#+!rkRL&H)b2Td{)2|pSUezhfyCZ$GcfG%`TIW{WC*z2
z_283eW_Aa+hCz*0M@Tyu6do@)85rL9{QWNp3J)HbyAW+%P<SMA@gc&)gB#qJ5Mg9s
zD46r-zauE0zXh4Z02*Rru;5}~*yH>6{~kdG2A0Pr3=ClVeR$cN`k8(DSp0igd)S)U
znU$IJ1ekdl^%$5d*g-|68z>!s!U^PLq;NJYhleu{n?N&r8&eNkFKZu5Kj_dsP#A!0
z)|&I@zcniZ1Iup^4-$S3oD2+p3;+C&0J%>b<}XCs2o%OCoD2+23;%$_iRHfuIL-Ai
zd4lQ=M?M8e|HOiqfnnRiKmU0_4s+xa0J+hJmw{nM+~5C=ATbv{fov{Ncm{Ftakz2&
zbMbL_a=UTyad>eD@Ns~{3Zx9R-^C{YYO{dac<BqFZ9Zr}X9X_<!xS|8_V6+=>>$!U
zkh!3CUo4Wjp!~(a$H2f6|M&lIyzOCd{o=*<fsxr2d**iq#S_Rp(74~0#J~TW@tOy1
zUr%6UzKA{lgZoS%H!t90VEB^!_kSWNut3N2F)%P};bUM3NcsDJ8b}P$_i^P@fcAY{
z_zaraBG9@%uH2z$BA(m~;ChjTpMhaP%HRJ{poS#2G7H@1a08WDE_@3ZnO9+VGdK)D
zb;%NL28InefB&E6XJBACZ3Ip~(6Sq?Z3hj94~)#Ou$u`E2T<Aqc@-)BYnH&%Ki>yj
z?YoWh|NIASnq?_70%-^P^#eZx!;|X2|7+oXbw@3q!F~nDw>v1l1(<OZ_RzQh-D4!u
z^7sE6xOr&hJ=i>G*ll2BzJ%SM;IIR?{{$Eqw)Fh{zYlNv0oNa({uz!wvNt!#tUCe>
z3>y7^|AUTC1hwU$ap1}at2e-IgZedrX(?8px^gpAFfcG^2r@9_O!)iXofXp8gPMhi
zPjI~kHp_+2p%kl89^B0Ta0O=#Rvlj4ptvvLXJBxc`uG1tP?@#K0Gytn{W(xGHVxie
zcjd-bN3a$l(ux6c9dTjqpZ{4PGqXXhGX`*b>;XRmL&?;?|Lxcr7+65!;BwlTm(8u8
zxsRon)eT%s|6<e=NY`UvzQqJ8q(O-kROYT=Wng$V_s@TRP#v2IF%y&@OavGh66XB<
z&mqLXz%m=+{(ew@6nX3e5q|D`8<?3-U=Ju<^?_m`!jBu6ksF`Tei*0*h?@WB|0@;-
z1{P2lGB7ZJ!Zv`Pf#J$pNcqCzWe5#hSpCc74G&vKNd4Br&cN_z@t^-7f3YZmYFLOl
zGx!-8{;d7`KNb|8VlZ>S^(CmP^g=i13@Ch;K+Smv2`i9$K;bX4?k}XB@CXuC(7Fd?
zjw`x3A{-11JTP;1LCgV_!z%<C7<AVC{a+3$-`7FRK~A%-sN+rUd>5FQ=3(tTVC`RS
z%twUx1tzrc2KDhk;eBNBpZ}mMcUY!F+yyFxKxKM~2m^z_p1=RgKmySEtwV%?p=QtD
z|H(*Vb3_;zZtVH{KN2biYCCNZVPH_%`}hAvc$?n^UVdTtDS)XTYqs*_W=i7Xvv9-c
zD7k~jTtq|}7#8e<jxm775*Zj6Dg+rA_U!xn-=3R+f#sn-wEf}+&lkSneBlFXzRUnM
zUmO`BIfFTzSx=xu51iIO-asnDQ}f_qh`SAQWAUH=Q$T5|A9O`80|PkS2{AAfoc#Mg
zoRfip1vFs*uCvhkamZ!c16JmZELcMVSAIH~3wIme16H*71?6>6{9ai62hwg;MYwH&
z5CenBrN96CIT#pNWc9)MsUOsK>SK20!&dHIU}aXv?lxRwf4WF+yMW7WptRQm3b$R5
z1(Bfo;EfmqgT}4D|7+lN3nI+GX$MgTx$reGGL>P?56<8*3=44vhL}5l|AS2jk3%Jb
zhA_ZmR3YLF3<X%^Kyi0Kn1P|?&fovK!VC;7dV0|C!PcjTwhb0AF)LwjbAgIoZ0U+O
z2N8D*(DNoN?hF<~+XgowqwXNL#fUI4NWB01zZ=wUIjKw7Z4FGMwp$9b5pHY1<+jU<
zpl&OHxD7myAi}`F^Y8Ef#i9%hEGhWh2Cjp>_!^j)RdKa7m|2+lCNPEZbuhW`H86qO
z;-I;OS&ROF$BJ0^AohaV;R=!r3{H#x{8s~IUhsTC9DF_ilm`UF85mTA|AEKLSl;M>
z!wh*&z=h9&nUN8BpvjpVGzJ7R4yi0i%tC~VLo-^x@x>x&zi}z3hJf_hcStfY{1N^K
zY1@Fu>3rbjAjVum05d<XpaA6y7AXb>2ho53o8V<Cw)6-N*Fe4iW&!MGd2@r(&;l_A
zh8D4Z|4&GQ##SNW0j+nijs3gxUEpAr<iuJwfx5id(zk9VBCIZO;3%6!7XA6Z6Vwiw
zsSOHh@OaD{DF%ie`v3k1fkeRV8h23t*M(1k$r;?OcjV&$)tw^J3=ALi|NTD)Qs;wx
z{wNu3%*UCVsTxfPoIgQnBt@Em!EVW)|NbEJ5OYT0amZ?T4<9tg1nPu4fy)t4KAi(v
z8({DcGS&^!%K#YzZ;^zU7Yr)jZfh|xfPCP`#{sHaFGw>mm>B%~ZwXZo5_=-ez>r|@
z4?af*N`IjEi81*1AGB7IWwsW$K5J$I8I;JyCjc1;0M+9PG7Jn$4F3Jk1ephtjt6&Y
z!E<yrG7Jnq4F3HGnFo>v*%ctez#wAy4?af+GQ&iQfkDCW-+yJ0dyTai7<~BzKz(44
z`UV*W1{1@7|3UqBkQty9o+8D-U|{$UJa5Rtu7#1OK%*kg;9)>VY<WpE9g#j1(DPE{
z;y?f8K<?PC39=6C4;ER_U6}|sgWM${%fP^6_zylO35pLLSq26Ts6QBd_yoN9IKb)C
zMV5iV!SLVzjUW@j@#_j2D*(qY(`0xA!{^?PNHQ>7F#Pu)bhr_Vxh97Hm?GeM9Jyn_
zDHEJ1VBw5ZZYZYV@oUc_X#4UuX!M5xwDgDpwBF>3;lKZ&%THL&Yk=*>n70D=pWXQ;
zFfz^J;xljo&y*s~KSE4HnU7nTig3pS#%8uQ)*hB#<~~T-3TpiYEc)|b2o&y_5Z$13
zQ6tB|5MlK1KX|D#xDJf~r+rZP&j77^Gy3;m7!;<^biYQ9fuRD6dXQNs<QN!wjG%c1
zY!+l*2$cV}$S^Q00GS0E%lfDe_A_c3ZNL<WWi0D~FayJ?g@68o+{1DLynPvT#U=wN
zy%ZS#`!5YLZwK+_8Hg}2WWmhqhnQ!>z`zg!N<Sw5{x^Zjt9poe7-P@wd<M)HK+}fE
zv(~QQG1n=w3=9*@{{6ou#=yYh4ABoABSrL2k=ug}%uH{w7P+qA{w65Mk<!@FWJKIH
z;Obi~TJYz8Ehs!d_JjJ%p!t6V28J6x|Nb8Y8JGu}=Wzj*x4wJ^OqJkN?a0UBcK8@L
z4|XUpFx2=W;v1CT=782F`Thg<wHRFZ1em-bW!x4828IK^|KRg{pfdY}0%&~k-+%Ch
z*Tk3EP1wq8P@KGwV_@*{`}dz6<fr{=;535~CoX&rpo9aOVTUgyaKSn*+?a$2LkHLt
zA;^!Q^6tq3Xd25_1BDd0AD$u4z;I{5pZ}epJQIy#zXxbu#09dB!GS3coI4TLGcYhL
zk!N67;P>ypJ;?3K5WUEG+!4M$z=f}XsgVoZ4RS=9q4wrxfaFq?Jia#(;fDgGEDmlz
zf%5p)1%Lj7YFn1Q;2g~W%6p*osv-XW{(l1bW34JU9HH}Yj-Yus7rp?dv&ebR5o`E4
zBH0~)UZ!U(fcBBXA@*i4Ffgo8U|_i8|L^~0P@V#bgZoH`b`7|_kDMn8Kojs-ms>D%
zg4*A%;7~$dhyfZt#1>9d6Oh9RX=wr|zCq#Svj95(a34~lgW63IiVO@qLI3_A0gYEb
zRsn|-wB3X)54-S9U}WY3HN-F{=fHC(pmYUFOi20oZ#=?X6L5_gzM22$zc(nZ=0n^D
zGUtmT1A{~OzyCWy;<Hu2ZG|?_x);#gK>|}Hq_%S8<8a{y*N32$K^MaR{RiE3%u<Y|
z-hrtIuHG4<K17LuAt3^)-W$JqP`ccr!oct$;vcwQ44Fr81eGi9d=5;RaI;;w!E=Ng
zlo%LNBLDq=2paeKt_%)W?0LZ*G_+gEgqa(_?NHFX0BB9M_<Tq^j^%<fC>$0b*L9$_
zw1P4N!;{#5|KEb_+e4XsIm!$S-{wK>n~G^4DBVm@W?)E3`u86+kIK>ru@6tWap&8>
z$h;ktp0Q1YLdVJi6c`xJ&V%+j;y|r7$hgBFWd;V1jDP>Xfz}8_QOB-53JeSfVRqRf
z?8;DKV7Qa_?|&vJ94%pXVH;Zp_e;F^CNMGQf&7J;AHZYFpmdCuAKu0w<p*4S(bjo?
z{+|Y=`zPQPVc_)5qRPOqq39oEZ2hJZI87n9CvqW)&<T_wKzV)%7Xt&w{6GKgK;~?O
zm;;&t_W`YyE&BIg9yAuXR0))x1lpJoW38?|Y%b00%*-r$0y%mNpnew*JBJ%&91_$=
z`84m(|Bs+Deiy_{P(N8gg@K`@64G~Jc?xkGv@PJur_jrSDEGkg#_oI(o_q=3d=V~u
z3CVmBj(h=3!B|@cpu!H6_t3&{VKgEP1CYC7Ab*3(I)??&HfR#Wji9>KMU8=BLFK>y
zeYy+`Ea6E0cIsz#?PKxmWeo(6rirkC#?aiknT_Q11eo=iKw~W+b3u!sEEfFv{~1(P
z&WEHKP#a*58Uw?PW&i$XfWotyU>WMpw}A;%ePdZLfpyGtZxq6>8*rtUDNFzS2VI-T
zVhkxiL3tFk$6~|UfB(HeX;}~EE}UuEo$mr8a|!mc9lVYTOIlV$a@z%5W&47qe<0)2
z2Owbva@z%U28NW4|Nif1W?*31j3b{R#>L$E9xyWNg2v`C^BH(75#(#on(K*6|NIBt
z#>CPOF1H?_y9tz*d^8vs*p~hI585!qQV&)q0IydZn9^ZwL{K{dv@fM*%fJ6Tp!6ON
zaVK(~0~P+RTzm?Uj=U3Snw0^xW^RK914GExfB&;V`ZOT=u(abE7@3(d8`scwELxi1
z8i7a$4an=gK>ZL<nqRu~&;OgCynYpu=0W;FeTW=w1_q05|NeufkU(Ofybz$tz+kfN
z-+$0O?<~h5`4!oH@OIu5w3ezTq#VfMVqoA~25mo1fY=A}_X<r0hBe#%{SO2Ay8&V@
z_Ii)$0>or^2M;`M0rCrIZ_kPC{~&AUz++!!;Qkq?F67W+V0g3r-~S|#KXoB_xEa(G
z;Beyxjf8^q$LKIHSnT-sKMmwr(CkGFWbB{@G@h=*z|gY;lJ1b^<`8WiaGHaTffg`b
z$66?PaN{VgoVl6#L6re!B?sz+gX-xYIt&bFcK`eT0yO63gKHfqxNZTh#dQZ|M{K5n
z${i7H28M#Y|Ne7=@{qbBxITcExoG}@na6Y*>-2*Y)^@jR7$UtTU@K$gmO$&4!=RXf
z?18<Z%fRqvKXe=jJk|y7d%5!|1ak37xPymyyt!TYB%Hxa@Y-h{JqCs!`~QJfJb=cO
z1QNJFH5h1=12T5-2ejAWz`y@bL20U30qoB{(3-_w(Aa(tXl->HXl->fn+sn6a~LCL
zQwr<4vD8q6{{pb}D{2-)#}0%b{sZNk9eNB5H3$Fw{|QQ4-l$`A&^%+nbPcs{<aYSj
znX?R#b>5(TX*P%cf$Mfq`s-n0>gM9(a0abo0F_}cbQl=k9Qyaa3Y5MV$wTXACeSht
z@S122cSu}0=rb_59R3F`!;spdE_@2mkv&Jy>T!sjIr<C?GY<dz51uUn=ciEcdJsQ8
z4sctwN1uUV#o>SdSHkBf5d9VKm@XnufafQcVa*gSNMmB)7241>{d^7RWiY5r0@WpY
zi~juQ0fi%IT`H&z2-=%>^xuEb#h9S5fwm`I`B3I>z<Cqw4(yX`&fqnI26_w(DkuIy
z<}>5upyB8WX|F3V1;EO9NX(-2H+_Q<=|Z8IxedH77*ua`E&THzq@G0#G?E7y6Fp(T
zz#wzt-+wcZKLSDP_EW%R707>23>X+3PW<~n6C?-T58w*g58w{!M>C~!A=Vc{%X`pX
z#0@9@f$K_0oI>-C0h1@BX$Kh}1-0QO=rS-oIRPC<og@p+6VQ4IJpNY#(cr|#;l!N@
z_AGcP58P+IAk4sUZ^57cp#CaL9B2@d0bFN20Zl)g{P%wWDD8#8%yfZ{DKcfi=YT!9
zLGFR<IB?|lgl#?mg$>B7NPWMbfk<JAyawPHtbO(kG}{50TM#i~U{E;ukK#4BpnAx_
zfPul~)W83rODS3A$$-NLxqgH0$C$v#oC&IbUBD}HAzL!Q^M4?}lo&8D<SqCE9=B(y
zk^!Y5ly%mi@?eGm1H+oL|NgHBmBC3U_JG%s!tE)8ECNCdm_X`LP<a`%;Lra+P?+06
z!UAOX2LlEMmW%)XgGTFEjKFpaG&6-kR&()jfX6sMds782{`<cU6zJfx7TO<GU~-2<
zKWLzfI~dM}_IrH{85lY){`;Q~Do<}ogTn@zcHH>_n0`UjJAoFCf%_dbh71fRE<x3=
zLs!qt&Is4w0v^X(1KJ~Y1u}ld(uATOJoe%bSMS9QYFGP+Gcc@z^;4oit5G3&OT~nN
zLEs8x{2o*u^e`oW^A@Q62->Hsa^>HD(0nM1F~kmNd4Z_=96{?;!F8V(-vnmnST3vu
z7p{Jqt3M*`PQW$(XfXfJ|Gl90^?8W9L2g?E+7tKc-~Z*HHHXQNG=WhsBfG7EnOTz?
ztJ}bBTTmD&h%zuVE&lWW9%x)i8Ior~c1ajBF!22O_uo*Pfq}&zl4tRRgF9aXJ9C#j
zR=aSG-`M&g!l8j3xgh{5vl$q`Y4OO?KmWIZ)&*2T%0^J$*ka7UutDuVWUq&fJUE^8
zg7ynR_e6o~OHhh)g0uwTdBX$iSlm`$ggXMz$1;Dd`vaaUVtJ0R-^7H0VS@Vq|7xHx
z1BrvnV2nLk3m8H9N&|U(+Y4NWfU*@*S!Rl4{{rOpHz<BU?eF{R{`}7c<*CgOH-O@2
zhY16NjpqOVTB@M+r*hyhz!N`Sd>2@m4+&yj003?ugX$GDcg^)dgbU7f2^-e``43wE
z&vIHGq#Zo=-D1wbaKZQge@LkVSzkKCoPptv?|=CG2gq-0%o!M7`2GjieW3C1aOgVH
zBjyYYAFznuF=t@-fkpfaXo<NWsyU!ORt#vbsNa9^{sk6pNc#?29)ZgX&{*wOE<Ob}
zSUrY)thU!15e^t*wJO{G{1*e2v0EYj2gO&51p`Ba-+%CaB}n-KuIt?S6!PIElqa_b
z%vNxi?XX~ASmXEqza%&mA!&b(83V%(zyIKRn<XBS&QaZOkcB)G4~j@oxSr5uU|6*E
z&wo`=`pk#83)BXbv1DL4;rIVPc%~3su7leFE_@1MuqHIP9(S>1V7TD-|3Ant3^9BP
z!F(Lx{U@Na2VVI7|6dMrqa$ek170tLLp<il$KeNRggb&8;h?<wz?6Z(#Q*>QbWr*&
zhWMcuv{nw9SHbldXyv0gsJcYXD_G}38NCp3QGlLTFK_z;p1WmHhWHs&-zAtaFx=nv
z=Rc^A#3Br_AG-bwy!IKSrp1hbfq6Sr&2LCvLRJF`I}Hoa_&YQ$J%*_PEmz#Y#V6nj
zY7Svrs~G8taIXPu?L4T>cV`=9e<;fWM4s*e?JW-Y|9=Chyqf~C15ciI=Uc$SEX|I!
z%*8dXa?%6go&_v8%G}&-fBqYR;%hp@ZJ>6Kh9v_-$M!$}pMlbP2R^sC^Cd8y!I)eC
z^(%8M85k@g|Nmdd1zMwx&kS(g3L2YXa>ZI?VV&1|>yGdn#`p{<Ux3PlRonmkPX^Vi
z?GV3#+Po$<3=9Fu|Nj?(`p)3_Zs<Bkg=Q9JDdbj&GbEXVTfdNf00lM-3{z76|8E85
z3B;U?D<7<H0q)~4Idh?JdS!r&K{r@2Fg!{5|GysOrme6r@x;CMWdS4e3+$bD(2yp$
zT?KLqQvGt(4G}I2(ECiVaQV6mnjV88;R4FLGS&<XCo=y3pARZWoFQ(*sAoZ4V+QoR
z>k4jv<*+j_oZ1B)4^x7e3mQjRV#~lFkp2HZc+Vp^yyL*_FHjnpV9mgwlKuaGIjG&s
z1hEq%4}ilI++PEg98RF%z#P7Vv;i+jF)-}f_2<7QDBWI!v~NJ^;D<E>gH7K5|3)Cc
zorJV+Q0MU+m=+@!uF!GnH!2Jan|J;B4?19vWdp=Kkh?u>7#MU4{{Pnp<(m}{^Dx?G
zV0VMlwhLbZ(-f>Z7iy1%AOpjMUC?oYB#1qrdVhlr1H+es|Nq~C+JHeYd(isT;5HyM
zd^RvKPiDhv6KLoNT;9uwF)*0z`tyG=D2$RJc7gJ|k39oJMbrQPA3+HU98ZXR5y0mF
z+Byc>a1PmT=)_%t99-be4g&+j|No3`TUc&0eRO8%;AH*j%&>#|7UM@}h8e=FjV=tk
zMOi;OGwc>;ed)|_TIvVeM`wnU8X#43b-+UUAVtlFPXs<XgG^%G!N>|Wl0%x+k-<g+
z%;qj&WnkFEIE(QN6G#n<07MDf9%k0(EFclpP}XK<h6L6-Obk;&`d>1#u4iWW!pPde
z%&?M)m4V?pQv}!~wsnlGZD2!05?DVnGGw!!Vq{nV(sGnh2dsjD;s0z=MlO9;28Q%Y
zOgotw85tNL=du2uEy>8k$;!uU%4)^n%F4h1mjP>JT>!EO6dtn$8QBgoM$KUY=>-KW
z$V^T~ka`f0p!sU7+6-nG=8Jf;GBCs`Ph?^^$0*6b(7?nx5$q8jaaLOf3ke2>Xh^7V
z3WYK-)UkFjf&zv`MilHgQR5s2hHZ=>EeAll?=lK^f^~Dqure^{h(g@e!pK;;mPziv
z62n&}x#`LbXIWU+C^JlATgWtDnc<UQ>~|%GIl@f$l^8dR#4k~1cq}F`Uzwp-g7vu)
z<3CB(_ezYPrC8@HGdz%HZC7TTBhR`;nXyxmwO^TGxe`dt8YPhU4keKI5halNlS&}<
zx0G1FE5Sks6jp|eYT~T#IT_4Z=d&^dv94ugsAXNp#W0Jtor!^=nS=Ex2jgoF)(;#=
zdj2zVNVB>!I6x8%hZL&|gFS?;eTHcwBLl-q7RlZ63}0FJ4$Cv_;o8W|!0?%mb+bIf
zef~pC3=Eru@33r^2Zxxd6gb2<<yjdROayzt!6?GcYR(|T>d#=r>IIJaR7hBxonm6`
z;bVBq#I}HsVIDJU6CXnt3tKxM!$uaiiF^z{*jQKbF|1}+TFS?;oQrifAHyv!rJZ~r
zYuw6Nk1{bdGqN@?Gt6LQ{l>&_n31)Kh2bV6>tAMucZ{sO3@uEoolFc<nOIjbF)U<e
zUB=9?o0;_yGs8t@*6mCTcbQq=GlNW;#@NBg`dgXd9V7EOWrlNnb)S_P_6o4xQ)aj<
zz<N!Y;k5wk0%eAFLDm_{3`+%BCo3~t1+(`Hv3^rxcq7ERU72Br2y2@%!#8md`;a8-
zCS``3lB{c$8TzGIpD8n(mja1QlxA&KVR$6NdQzF;wk+#EC5D@FI{TFw9>{}C-lW8O
zPMKk!638XDlt8Ba|IfIZQJgi1!GYD4;X5dcH8Zi!Wn$RG#M;5cu#buLFcZTaCf0{c
z3~kJ;-&q;vFtdJQW%$O-dXI%+3Ja?%!v+@C$1DstLCha4tXEkX`dC>nurjP-WnIF?
zaGI6%1T({FHrCDT3@_POT^U;0S$D8AtYc?&WjMmldXk;t9Xso64u%#E)`iRrt2scb
zk8`jt;beFLX8+}2J;2E@nUi%lC&PSB)|H%~pk%RuL@Ng@Oa1@P$YOy-475e>|9?hg
zb*X_f7#SG;F|yv3VYtjBbykL<mznjd48uKU)=x4Fdssx*$}rqu1If<eVm&Iuu!x&=
zs|>?gKBm1g3~fTfYh@Tt34v6;5fObW!|+)Wr1Gyc(^DCSnKB^u3NZQqKckp2s61l?
zrHVI<tjC!cnwVJkgY&Z7GnTo`OT-vva<MWn+~?t2DaP=e_a#VVnh+B>QS(Z&wlgx=
zu{tyOTYv>*=drL}5@I;Z!gorDVFep2149evUzSTk45#^+!3ualF=)f;$lz-U=F9$L
zV(k)S*uu=$B*?Im6{LaVEK8Rl!xUb04aQ&%+Ao<vo1GuB$W2va*u=`WRE=Q*?_JOl
z5kjnU)fjq&-!d^U%oLx<GFJ^81q}8OZReOkXS%Fpk!%L%+Rt(fce%DOGcZi%XZ<b5
z@RuL7QudVaLYCih$lBO0Gwx6Z8z3ak>dRoG!oW}tDnI5hs(?jB-HjL+dKhJQGBG>{
zCCLR$tUJMBhhB<`^f5Q{Eih(yEXaDmnBj`h8-)eNAd95gTNzat7BjN`Wn?(PXsW_+
z095LqVS391>Oz22AY&F~CQ}ffMG}&TSkfRga>C(qQEX>on8p|bb|4EcL<P6$Dn<r|
z$Be?=VCS)L!-O|6GBCVm6rPMC%<zA9En|`QJ0=E(_pGejbQ!*}MQ_t(SjNdZO_yO6
z7wa-z#!I|$({veH1X%a!GRzdr*r&_zRG4+0F2gmEcTDSa85T;gp3`N#D8+hAmvOlQ
z>pWe?Gb*fox{P0SK<r;SAld&qAcI<TL25d6L9*}~@c(RIMn@Ue2*zMm28L4BJ|>1f
zM%Jy2jPn^;uP`!iU}XKs$atQSRgvKhBkMLMhE68dV@wPinOH9~F&+d3;A<w<4@{uq
z98%SS!c4#%lmJdM3jb$h_yCG4P-cV%14y3Bigi5`gD<Eo1j(pD0*I}hk@Xe0%oY@9
z^<=PM?P6qbVJ&3<wIINCvn-=vE2AX?!$(He)2xigSV1J*8w~I|9(x^Z6RpR<FpZIQ
z4L8Gk#u^5O>&&2ank=9j$ab)SM5nSZWn^Hu$7!*Ln_(Uo>lSW?lU#BP487b!;Mf&l
zXXRl~VPybU?`{wmvnbkv<yhpiQD{Xo&_OCsm|0J9GHhaDy~)YY#}>)JFoE5Zf#Dvz
z*hO%O#iPK=z+lA6z+lG;_B346Rj{U~AWcpT3==pa85rJih~34iN!Q^DGXujS7S<g+
z44+t75AZPDW?jR?z;J=XlYwC#r`QG_h7VkU3=GG(#ZK^mf?j}~RgM9aq-|N@%?@Lj
zA@_JehCJhCxXn71iGkq*XCec`H7<*HybL$E0~r|B@rYgHWq8LU^NtsnQQG;eH#r!l
zGHzl##KG{1nfW3ILjw!bE)IqjtgMGP81}Ml1xb8omwd<pGJ-RTm4TrXmO{8>!J)_@
zz^cul25ABKCbQ1s1F87S%dmop^&Bt5GG^AxybMQ~S?}^POk-ia!OO6NjrA!nLjybO
zTV959>>^)z8K!Ztw(>C?;$ZFKW9Z-%n8e4hn-?VV|39O>0ILB5D20HU0fnq(pz`1_
zBg0Nc)_sf&J)rcwj)`?M6T>?u)<w(={mh_J`Xso%eg$U#|If&(Glvo4P;qGUjp6_7
z7G}mDO#O_kTca4JGqUcDVpz<?dMXN3SFVg?Sj5V@HVRbxEsbKB#LmjV(9OZh!0>^C
z^?Ve=C(e6}3=B;?tj{7DPV=+gjAFRX&w3?_VXYwR#Yl!{f;JZ;8TJTyGcX(yX5ARc
zxLj1=T_nRaF_7|Y;<?|V7@8zmo1+-!O0xcrWOygZ`Yn>-iZm+&!*_X*l9ixDwn>@w
zS|r0g71obY41ZNvUq&&UQ)QhH#V|p=XlfM0UF}6|3=Aub(&k1nEHi0kWMJqsXPp_z
z@YP(PBZ}dig}}W?hPRdm|DqTkgX+!$HmnCD8D`sMFfc5&m%JFsu)@KUf#JVn{KQCx
zwa%;z3`bm87e+FCa$!9g$*|EClu=w+A4V~3b<<^FSm?>RGm>$iA1edHvOthIe*#(m
zMKK%>VVxSquqKR^f#GR5$gLm4L6U#NSs56bB0%206v5gS&G0w^q`D~*q`Ey4WK>Ti
zNFlrs_&@stBjXcB5mp8U4ORvQTh>^HVAcqRdR7L8d7u_F^GQ%z14r{(Ce}?%40}N_
zewT^$5fj6I5c3=}>q};aC(NvU%nW@jtPBjRSXeKyFq~zPU|{$H;;&(4-NnYRot1Se
z8^bG59Xf$ci-F-h8|!;EhNo<-uh<w?f+Bb;JL@iXhFc)!R8U;6;$XeU!Ek_s^*%ep
zO^`q<C+k{Hh83I=3=HQvSs55!gNSxe?LV1|bp{v19xm2%j0~5!Sg&(2d<F^s=VEQ)
zW>^j?MR#*sAoXDW|7SD-HFVmUSWojY+-72Zz{hZrS>`ey!+%!R+k6Z&xk2Pj9+2!V
zJ`npDABg?`KO?^Y>ug2_HP&g242__G`Tw6$XbB@Iqt0bw-NeDLj)`>_IG?gaKvt3b
zpRLQN<j6Xoogq<YIXlBqCf4cf3}={`x3e>TW@cW`4ocnA*+G>7s8<5&4~R1I=z>cc
zMuuESzX&Ar|3A3MV?6-1RT30i2B5s=!FryFAq&*B+{MUx1zc0gfwLKF5<@Jg$->Bb
zhLK?wBkO!dhOLaOyCCL7%IpC%V0A4gC<lCo8V;^IL>ajy+!+|=F+FB(WCL~Xz_k^)
z&fsAcWY%QWW3Ys{4=e%F^PiDFoAoX;!yQIu28Kh-pp^Wd5mw2AN-q{r=?!X2va|9q
zfNTU+X6(-3vVjK_^~$WF3@(t?3yVLb8He0_kV$6U#LiHux1Al-0ol*a@SE9m6Fb8L
zR@Uw8AoDqtSQ!|cA+>`9sFLhqJj%F;o#7GFZl+o63@2GxmqXNnI)YBDiXc76m<1H7
zAosxvREGbv=P)r&WU?@1VCVxS_vK8iOLQ4lGqY~dWq1Wj-b-0o*XS~wW0k$F!?2Z&
z^@%RSLpIhkx(v_QS?}mF9N-YTqRa4uQ|7h~!#=J%%%61_{`2)PGBCUq1f3A~Us!I1
z9%$5nf#HfM>uVi`Lt?C5x(pM<S%2s-tdL;6t;29h!k>ZRh9ql~F5?3k*2Q`Z%Vk;r
z=rWv;V`X4iEYJE`hvBh2>th{;zw)dT^%y2Auy*P(tW{ub)MMyU1Pvr8vd+|FSf<2!
zM3-T=GD!JVW!5*k4BJ&f&i<?_`Adi44Jf1*s<Y11V|WWDk7`&kFx=E;-J{E}MF-^5
z13Ii<bQ#X*ux`*}xTXVg3#<V7KYIlu<19vI*2kdKRmH%tn~C)R6Z11B*4Io7-<Sd!
z7=AOe9%Nyd$in)YiD4NF>qQoZJz(}X7SJ$8BO541PGe(z$i}dSjr9&2!$CII7winz
z*;o&;Gjy}FUgls}$j-Wqona$8D+j|~cGj!x3>QF2<uQn8<zSu5$uOIPbpZ#%4i46@
z91Q2cedQUT!eIx9fH@SDK4(v0Vr*f0!N~eaiQxw$>sBR(lPs)vl^A}qNL*E7*upAt
zR*B&uE9+4uhA*tFdzBa_vav2uV))8#dRK{IIVbBoMaJ7)AoVl3mAaJ}?sHphP-583
z%i5;IaEF)ml@h}VKGqpZ3@iEfFt#Z%EEPP-cvp#`Ntkto62nJf)<;SVzePa0n?;o-
zC^7sM1F=tw3(ZnyI3)pMKac>Kv|AFyz9Px`Pm$q}6zexdhGuDrNy-d|q$RqP8Qx2?
zHYqbS$*}%XVwf)j8c#SU3(|E(P8npSJnJ(>hMfwm_Y@gsD1yY7D1uDepa^o^9!0@6
zC5D@dAb)^HhC#&&!~fZijFzCnFqk!+p_nzDp_;XUk>MgE>mx>nyNs;eObq9lS<@Nj
zfRg$O7Le!`7S=C}3^!R>53oXut^fZSS2A0(ehp#R&B!_@lwkrB>yl80<4ko^LKzma
zu(pRVG_kU_hcX;tW8ECg@R_Z=CzRnB2kY)&P@p!2F?`@+Z4YCZ#XXyGO(;VbFYA_2
zhS$8T_d*%|^RXTdW?0AH!#F(z)Tv(_%<w{x^++hgH(}O2p$yAKRxq9pW|$+!x;mJl
zU!3)3D8p?@){~(OJyJUu`$HHe$*^7wW%w+^`Zttejy&s&P=>SeI~c!)GF(z*y%Ef?
zS&8*QFvANK*3%&jOH{8h?hawNrp`J&jA6S5>&g&@?V6D{LKxm_i9QZxxUVgGIhbLQ
zF6)C3hDCa;Z$lV1>9M{DVd&LoT@u33XW-Kx#<1H^bbc7aS|ia9p$v^CtY3o}UYoG4
z3}g6h!n!1k;j$@fQwYO-GuFw$44vkcZ-W^wTChG1X4quOx-NuanHB5i5QYm@m4`zZ
zrrEI04rcgn!+JS{VSy7UWNx^C!n4B_6nZyYK|!*>4dnk$caVD?c!IqA!wY0%gFncZ
z4S^spJqQHb6$DbVA_!#u!ywtO!Jy*q8Y8%*pTWesl8Ipn6YB*ghPO<t-<cVjnL&ey
zbD3GEu`+CCW}V2&@R*f#8ymw<aP9q!jrBDfC^v55V%W~kx`&-%5eMsiaK^jE!El(9
z^*9&9O-|N(oD9#oSU2%7{N-Y8;%1n|&H9CxVFNeoR&It#Jgjed7*_DGuH|7^#LK#k
zm*Ffg>m^=>O?<3B_(0j`2`|H4KGtQzpz*3{!VI(dS#R+(Y~*LX%Fl3tAJj$@V4W_=
z&@0F~NsysSh;@|^!vZ1Jr9upi!mMq=Ag}T3IfB~9Lg$$nrZGV}=^_HG<_w@B4mO^Z
z0;-s1n=&d%=`b)%WsK=zVc5>Z+Q`Csf{FDHGwUxV);TP!YnWLlf)YJbEhDIYd!fg`
za7PbRKf5v-3$TW;s<CRbTCv(Q__H!FtYu_9!N{<Qk@YY*(=agnWn`Vq#Bhj-^)3_Z
z4bVUkD+2?>papsi3{$}7ykKHH$poqo|1mZ&ukd7V;9#BP$v%yf^|%N74Ic9qp6v5^
z-!RVgWZxsqy3dpIpD@d2PtFOVW-C0|SBry`J`!jB<H<ft&Sa7&`y%<jOp`p>S13s`
zFg#XeW?;Ak^6)1$)+e3}J?gCeUJQ%WS>Jdv>``ZJ_hR^?!TQCMVTvZ}9Z!ZyTAhq1
zJsCD?vrhM7_@@oBYN`&%_#L{;^SwCl=o(z~<Xol)5;>*^varX1^|1&08N;Ai9t_Wn
zSWkK~tT$%;<-u^<nDwg%!*LVV4;~CpO;}%eF#I)PUGKqg#uOy`-Sh_Iau0^h7OWRN
z817k!Uh`o1Y{}Z>$<S@Z+U3b`+KP3#2g5RJnO`0Z?Y1DxHrcBF@nnBv2NIv)!n)mq
zp~IDRzX!t+S49SfkFM^wJs2LlB_H=-|LZP0%Y%U#627%8wG0d@p!Hdxb53;`7&LT2
zadwB1aStPCl>0d&t1BpWnwS`tF|n>@0=NE{82&S}&gEj*z{325i}3;rDBV9}Vg1em
z>f8NcVYmuvwZ39y?PX(cU}J4%V}HQLdW@an8yl!v>Skx%#tzC9>)09ou(LLDu;1fk
z{lLla7*zTE1`!=xti4<eGeAw!O(5a~7s#?(Am#yX5c3B&>sKcBsXVM3dD%bmuwLY2
z|I5SL#LK>hmvs*>`x!n~1{CixxIh;-fM^fMKt5Yk7vmF1gH90K@ccj9m664RHAs|;
zfwPvQmc5p(mbI3pmbn(33_&THfk8xvfx$qB0c@THl-7XKpaZksXoJG8hmq0Sj@6d|
z)KdX9YAaZ$GBeC#WL?V4u!oWLDKo=8M%JUupiz!i7Et?lD>K7kCg!iq49}QYuQD@q
zGqX-*VOYSN%D^yzMU;U7k9%6Q85kC5Gcat?W?)zWrDs6t25kn07?6AZGm033&Pimw
z&%{v9dL1-DP;(yK>SX~9VuKoQQmm#729Vw`2NIjrHsU!rh&b2<CBVI%|Nj}A7&WyS
z7&b79b_p>&Wn`T!%rKWp<eCt}F(%e~LJW_YSf2?o%x9j<cuk1mJ`3wtL54<F)-6H|
zvshU#3o=Y#W1S?#aGsrYwlKp*4%T-<3=_Cmn}r$LxLLb}8NP6{o)%=-Bmj~<B>)nC
zDWJl@uu>2txm6IP^`Ia~6R3y$0NV5x*9H%m)H77D&R}Gi3=-W3BL4qpT+Eok%D_;_
zI$adh`F<_JaEg)jnFzyIM%K?F3^SR88blfHGO^whVOYcbk7>Fn!+ti_iy{m^*;sFi
zFq~yKm@dlD$FYF%kO;#`PS!Ib4E<anljd>FVmvOwaG9HRuL#2e9+1#_o^6afL>L<Q
zST~C>T<2q5EyB>l&$>*6VXgp3`jP-^uPDPxL80Fw3@e0KcZe_?6k=@^W%w%ulKuam
zaW5k~t0sd3D+5C)YbirEYXQSdM%Gn~3`-eVw=*)FVPsv%#PEob^*JNMXGYc*CWilv
ztaF$^0e+MXG)B(D@PY{>@Rx~oE;GYqX4V<Z3`dwjN$CQ3M&KPY>wjj3U(BrSEDZBl
zSkJRCykTKo%mQv>urf?$1<e{fWM$pL&hU*D)Oze;V_nb6FoTVCE4aToi=E*&8|zed
zhS%(@AJ`e@aIkLYVA#aLI+qR9bZh{359HP`vVP}aILFBPoP*&UE9-j>hRbXq_FWDT
z`Tsv73#bF}|39O&B4{!2J7$aNtPJZ|So>KSZh$I{zaZlOe?|dzRtW}SRt5$GV+Mvi
zP_^@)QQF}==v-n}+xKh?e_2_dvoS0O4Mkr75&!=)@_@QVYJv<5E>Pvt%RytKOctwH
z7#1_LE@ELg3+h-+fZ707t|G_)4)6c}8QHRyFfNB=2k78xqIMSx1H%ILZHxz%8TN65
z<~UaK1T!#n@yR?>W|%Apn&OxyBz97n;hzZWMP-K1qCLzPl^HrfLtcH-tT&Yzc7u9q
zJ7kg=7!Jx=Z&YSzmuKCn%&;4j-41|8OaA|76ah8H#aS5`lvy>vB}F}Wgc#h!93_TR
z2!IdXWnj2)5#p&0mmoBZRPX>DQp&(!06OHIfq`LyG80%T;54MmQQ!uV2MdDEmhy)1
zH(ZB^6s(4*Yk;a>099WBRR>YUz#!oR(T6Thth@$jvlmP;Xk9s-_!>}mBUue*5^@h%
z5f(yVHSA;#ERsk<1w^V_fTRu*b4Z4O?h9~-ggZ7lRF$Z_1FjGq4>TY&sw`pNffW#c
zUVz#U)3F1Z-WZr6>E;3xgoeo%#6tAJ_z!TH!{7<=7cO%qpqaz45@Ig8dpro3vjNQ<
z1*kbN_Z>jvJFJ4(1CvL$4<=4+`U9H12GDeYZodUA-{1)U05ty+a;JeCBz*{ILg)n0
z)F+ar4^Vd?31MY^04;jJDuXJhun7^q5F1hDUqJnbO%9|oVH-j}h`#{J4?rugE<nW-
z(8NJ{$imxE?S+|f0GhuhKxvpbj1D*k(T84cHbBK;>NddmXyugxR2)4W9Ds(?fjf|p
zG5{^WhZzRC8v@D>h0?HG3OYv{Bn0E<fjCI&L3<HFLa_Z$3<V$_0|WS6Uj_z-l35V{
zz}6XiK<f+0E(6F~ZIBKr5W&E}5CN5kt>p$CiwctZ`VVs4eFDV!4B$=_0|UbXs6sZ7
zA_fMA2N3HRxS)Im$dMKd+)zGfJs^k)RmQ*&04Z0X#xfiLox9Dz0A8mCQU|*iMI6Kd
z?YoSEFks>apoMu13=A-LdVp6iF)+aHU4hy6??1%-7n~vb|3mo@+Zh->K=}ti2R}0~
zF#Lq_L1#8Xbc~Y2IRqNe@-fV>X3+fP2BpKGbQ+W{gVJqKdK#2o2Bo(_>0?m(8kBwp
zrN2RGwnB)FVo+KQN}EAxHz*wjrPH8v8I*2=($k>yGAO+bN*{yL*P!$>DE$pevlT(@
zhtg_L+6+p&LFq6kod%`LpmZCQo(83tLFsK!`WTeH2Bn`t>2FY)4YY}#fq_8`N~=L>
zGbrr_rNf|f8k8=B(rr+B8kAlJrME%pV^I1Ulzs-Kzd>m>(Ba}B`=PWNls1FXZcsW5
zN~b~TGAP{!rKdsZWl(w>ls*QfuR-Z&Q2HB`W&>Yj#K0g1rPZLc8I*Q|(qT|K4N8|m
z={6`m4N5PA(%Yc)F(`cvN<V|r-=H)b^e|g7D6Iyi&7ia!ln#T^X;8WhO1DAjX;69@
zl->rVk3s2cQ2H5^{syJlz?)1M7{s8o8k9DJ(r!>X3`(a#=`twY2BoJ#>19xQ8<ai<
zrLRHhXHfbZlx71Rk`0P~D6Iyi&7ia!ln#T^X;8WhO1DAjX;69@l->rVk3s2cQ2H5^
z{syJlDxvugN~=L>Gbrr_rNf|f8k8=B(rr+B8kAlJrME%pV^I1Ulzs-Kzd>m>&_;2P
z|Dm)Rls1FXZcsW5N~b~TGAP{!rKdsZWl$R8D+Y#yP*_b16Twcy+6}OF&kJZnK>)OY
z71Z8ngS3PkoFEN_hH0Ri))*KV9)5*1NlwiIU5&xO@Ps=A+@^R@2D-|Yfk9yD70^92
z3=4|<BtVS=hbn>3pteNAu_blAAWIJBe`-@^U|{Hqt#Ae1N|v&G^R@@P3=A(iS(J}=
zG3aW8whqA^ZD43*Y+`C=Zef|2l$??ZJ|Y4xiGu<18^~WEKY{$SppB6M<PWePK<<aR
z9gBVg0|P??BLiat69ZENGXrx23j<3-14BbYBST|D6GKx&GedJj3qwmI10zEtBO_xY
z6C+b2Gb3{&3nNQo17kyDBV%J@6Jt|jGh=gO3u8+Y0~13NBNJm26BAPtGZS+Y3lmFI
z15-m&BU58j6H`-DGgEU@3sXxo12aQ2BQs+&6EjmYGc$8D3o}b|19L-jBXeVO6LV8@
zGjnru3v){g0}De7BMV~-6AM!dGYfMI3kyq214~0oBTHjT6H8M|GfQ(z3rpCso)|ua
z#42d`8zKb?ClCu1Rv;P_ULYD2W*{0AZXg;Qb|3~Q{6I7;45=LdHowDv7ya(}z5MsV
z-*<k0`z`oK=a1W;#6Q)4rv2IY=k%Xve;EEs|26#^@HhK!>)!=`cm2Kk_x)e4f2#lN
z|3&>P`Pct%<-a5U?*IGwPvpPef6xEP|LgwG{J;7Cx&JTzGc(9BSTF=L<T7+HEMnNp
zaD(9!123aGqZ4BcV>#m_#x;z`86PtKVH9IBWb$E3V`^lY&9sf_0@G_IHf9B8Yvxeq
z0_JY!rOXGIZ!v#m=4a8ulGQqxWH=UF?f+G_-)>R;!*#pL)`S`;{1)qeWqK~wtJCSc
zu61hYstwt*?z>9aGM|@vcIw!y<Kq7cR{P)Cv+vKw^8Y;7vK`+~4BKb(r+&g(`3t?x
zvqB9uVgfI3J-KXc|C++Nr@P-Nmn+SAl^a~)FwyhOy6|(`Vk?Dgn#{v~`<hJ=IOIRW
z!y^CHv<b(pnp97>mR$cbegE{c=i3%MU85yFgUjT7-zHP7-{}^ctnH6ox_{+F%dWGR
zrPN*S9-Velb@#dX*^^tACe^CsthxQ|Ry=P++Umt>9}nM~{NvH*9S#3itysHtYqwWT
z4r_c;d$7SllZ5|!PKK)On%L9oH*Ig7W`Roi&-?v5p6-~x_x`dewIv<r<5&JTKYK<0
z<N}wS*`oaWe|+HR+Gc2&8mhYC?3()O3&$SW&t$XK);b~(^W^fR;>?*UDy#TTF*JYL
z+Wz;ol;ETkj;DLhbOhvcp4ro*lPdWrLVP=Pw9jD<C<#J}nxr*HUstSc;hgfL!qUER
zvncz?>T}Z%6vVu$K4(<dpV9Dg^%9FqS6!86iL0sm&sYC_<ci^<<hLu<p6Ibiy|>|Z
z>T0Pzj^oX<WDA{s%ElgvcrLw6C)0P*tKI^sly{7`yvpCtnz=Z4QEPVXmg)-5PvsJK
zD;GWq*>dRU?C42t(QUS|(@q=>Ha)R<!Sr7-TePM=j$bfy?|ip=sy&vsO%Bao8Z&>!
z;-Xo{zMb3mG9-Bao$Zetl|G4o{?oCvBIfe!a|&nf2P;;8juM+;WgtKO&ejEwrfq&4
z6MXUJ3LBT@OK#T8{w?6LWVw$|*>0&h4%^=Mt?t%o3124gUjBln;l!6umk7+B%QI);
z@7V&+HNRLV-Bi$6(|Ue+Rh+j=gYMlm%nnZ!_xJyIiPN8x-siZZXU<%4<0~trA8(m-
zTXNpb^835;_D_4A{qDnTYo_+~pztIH@7oC~!x<P3oC25n3=UA57`@okIH2_hVEuQP
zTIpzG3u_~52I*)MFpb{dhp8h(yE{8uDQGwrC1)u3WagDtC|K$l>lx@8YC;$c40^>G
z#U({0iAfB4dHE%&dg*zkdP$|3IVrlCDGXp<Mq+UWgI-EyUU6kEgf1z9$dsiP6=&w>
zp>X1h81#x#a}q%spsa$N5(d4@yvz~?y@H$)z4ZJN2ECHhiV_CBw9LFr2EC&El*E!m
z2EEjb__U(L+|>Atlp+L=K`%WyIX<-_Ikli9z9cazClz8?d}2{iVkN{37#m~`$acM=
ze6ULsb2F0}Ko){5X3zskGw3B17c=N3=jZ08=0O|BgaQ$dJZRhjG*$pf6$}g(PzH=f
zpN2s%IzhV_zx@YawFtHaHvR#lYoHYuB=sT2A;5}3<K_$u;IR*=weax~*f_}n=l})C
zUXW3+aSW(1187e+$ZVK?*mw(!hK;Yl>;strV}oeWepk>~2TVU~d;>-cKqWwSfYd{|
z3@{oryaF0Kf$?GEConnzY9Yw|APjRq$Se>B-{Hx?05=adUIU|H<25k*VftbIj|1&d
z1YKDJG7M?_rvlV=V_<-f7lHJH#)#1MgU+S_IT1EK1sflO(XeqasPPOSKfu@^8g!or
zvVH|<e;r1H?-m9rgkk|S8Z=&qtbYTvT@0gP?uBZDk7L2aLERH%{Rg1>Vf03Mkk4Vd
z5#xC<5ztBoWc{%5Ko|`hCxod-_kS~VtPvLf44{1oAjMER40Na=h!4dmjbsJ}hHf<d
z5$7Q8h0!sfwm4KTh(fm?bmkGr{V@A?T!-j~(G%=Jx)2x^ZZHwh9#>@j9^w!iU^M7V
zbeLKY4Uq-0Ab2YS0|OreXn_fY4;w%AFoURs#WzG2k^f=t0G%BT>Zw3njTm2zfa-^-
z!=)c|-WSOIF#QS8@!15Zeg$~KhM0ivo?8qI3?L;i{jhPa1{;X`KY$E}<}r{7F!#XB
z0S(W9l)&^C_(Aj)*g<H}wj7W?7>4PG(T}0=57Q4D?`3d+=m)Ksf$0U&Fnur@bQdYI
z{jh#yf-6M71gLNaX@p|*^anb(8DtjB{)QNcz6x0V4l*377et}!{|<FOs2m2#!!S%g
Zx_X##$TZAum|hS)1Bd-EeIPX;3;-mlL!kfw

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