From cce4d24b44041d5fb56312930b0c73c6dd8d17ee Mon Sep 17 00:00:00 2001
From: hm19 <hm19@inf.ufpr.br>
Date: Tue, 3 Dec 2024 12:00:22 -0300
Subject: [PATCH] deslocamento funcao
---
compilador | Bin 54568 -> 0 bytes
compilador.o | Bin 2736 -> 0 bytes
compilador.tab.c | 2425 ----------------------------------------------
compilador.tab.h | 107 --
lex.yy.c | 2196 -----------------------------------------
stack/stack.o | Bin 3200 -> 0 bytes
ts/ts.o | Bin 10696 -> 0 bytes
7 files changed, 4728 deletions(-)
delete mode 100755 compilador
delete mode 100644 compilador.o
delete mode 100644 compilador.tab.c
delete mode 100644 compilador.tab.h
delete mode 100644 lex.yy.c
delete mode 100644 stack/stack.o
delete mode 100644 ts/ts.o
diff --git a/compilador b/compilador
deleted file mode 100755
index 5d43220309af6300d59e77a2d3f4bfa79b98b5f0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 54568
zcmb<-^>JfjWMqH=W(GS35Kln}BH{p{7+#!(G8h;b92hJZxEUN6WEo@_*cccXSioWs
zd6;?_oxubVhtV7mE(0@E-wLQaIxPcL2cto50tta=kbNLFHhh5xA_}7!1R#8nK2{JD
z%7=-=Xx2oKBm)DChKYmpf$eL6$TOhP7nC95FdA7OC~PjQfy(ber9D6az`(#z05+U~
z0j3WW93XuUp!yy_^}*;5AO|rpFu-V7c!G=p;Ugde7#JAPX%~p~3@{p`79<q#v?K+@
zj+q7GF)*OhPoVa}XpmZv%D|^3DIj-(*u-F1um?fy!xb(D&~Sm#Q0p1=b25|6O!RY7
zbaOKEN-K0LEX;JxO!SKL^^CyjPlSO1oTl9ULK&V(`grUVF@9dA#klIe{E~v^$2+<~
z?gqI5WFANj$ju<Dpuq*!3yMmRJlJ213mF<11(-l$svyM-3=A5wJu(+l&*i3tCJI=7
z>V_pvs4OZa#K^z^%|a*=xeVCF4RMHDFfuSGpqK#Rh~rQ{6^A$z4);XhP=5x8csveq
zOB~{tafox`aL*JR>eFzDZ^I$pheP}W4)K>b#4q6x55W;HbvV?6vKO}Wun&j&g*e1P
zX&9S1UO3ci;}BngLmZUev6(N2L;X=4;>kF|hZ~3bb_NCpK?Vs1g#(cE4J+4fF)%PF
zL4;7qAgFo+H1+GD;tpuy3^|!e$)MuGj3GU>B$**CEvK|NgQ2*jD7m1LA+;j2grT^g
zC^N4ljUg?+AT<vplLwNDk1sAsOwNu^&d82WOU%q+C`wJt$;nS<C@x9K%wxzbPAn;@
z1gXwR&11+-%`HwXVTg}UEh@^(kI%_ZPAtjH&tpi=Nlh$DEh++O$}cTpNGm7>xuKx6
zq!^?JWKS;4)S~3X5|BEG@}fKtH!U+KH7}nbt-L6+B$XkpC^a#KAr0!>`1s_C#Q3z#
zyu_T$s#K6ml5-0f;^RRc2D!bcBtADWGmjxHwWuh+h@m(SsxPf5HI>2L$J5C<-bl~T
z1kOaTjPy(y;ypur<5N<LQqwbwOHzwMe4TUh^HM_+lX6lS;^WhE^Yfr~#6y%~Rmi}=
zzyyXc8p2}+i$T~h5~P9!hd4qF0|O%iGq{}s$`7D~F=gU3Hc(4MoDou$iezT;f@%aM
zD8E!HlM`gN4yb@<U|_fatyf{`j6oP=3IoFpH1Pw_%)o(`o?!eN`yu*3bq1)8f$$g@
z9w3QBjQ~r%KoS=Pi$I7ENaBhRAu#y^Nn8ai0wG}e1k|Ph<ynX*0|P8SfW%?-7Dx`3
zA3)-2AOR?T0V;qP7#P?YKw%0M1hp@a#9?(LNcIPkIH>*viGeZHogi~Sc7Vkg7#KK^
z#6e*M6Bj@d2kC){OCX8E<A#BOK><me6Q&qcCnJe-A&DCxiG#`<n3M&QIJBt<mU2K6
z=LL&E2oEH2K8O&Q3_ud+2a7<62qbY>+62iYAc+ft1fVzrNgSF4!7>F%;-Iz-Sdf8%
zp#n)<3?|6Hz|eps4r&{~q&kqqC18RK3=9*H#3hl$XCR47A&D<Q5|>62Ux6f!+#uS3
zBrc1jeg~2`s7`@N9Y7M7hY2z;Fq}XVM{WmQKoZARKOh+~${Y=W(Gb890-yQiet9&%
z;qd5Yy}6!&!K3v+3Df@z9?eHM4uf_4H{G<3f#JXEmURpa{PGSA|5ZW!43ON*2mk;7
z|F61g9RouKs8)S>0nA?n;)AM;mj}T7Ss*^Bs(85p%%23}gR07x3&8v?5Fb=!yqo~$
zH-Y$|s^Vn>m|q3rgQ|#^1z>&=h!3h7UM7I~Ss*^BN_ZIn<|l#ppsL`d1DGEL;)AMy
zmj+;d5Qq;d`d=!5`CcGCsK|dQ0OmV^_@JWxB?Fjm1>%E>_?I94f&6O(;)9Czmk+>v
zEf616q`$lX<|~2tpeq060We<*#0M4aFE@bsLLfe<NPoEi%;y5}K}~^|6To~X5Fb>u
zzia^Wf30O;$N&}TFAKo@Par<1D1Vs%=Dz~*K}Gn>05Ja%hz}~dUpj#Kw?KSQk^RyD
z%)bQUgNo{x3Sj;z5Fb=TzZ3xTLHg4sfFc-#LFvQrt!L-OIFHUp9?efa1cdnXvTloG
zVDRYWwFgtS?QRSV|3xRQWnlO+!K2sq;98I*>n;#w`J+VCqnkAk#BM!M!ukIJzdU#Z
z<uH`?=(U{)lI%6@0#Ta(JUTyk9DHZ*aqtJT2jel1i~mYQJi1w3L6WTpN;v*MNaL4x
zVPJsi2f44owstK814F5Hs7JG{5{T*1`Lu+`quW+(Ed#>~&Hw-ZzexH2|Nk-8(6tN<
zjIoFL<x%v%EdT%iKggg^kItvT9?fqox>-xsGBC6r;BVc;z`$^vH3_7Tfq|i$H32MM
z%5|JI2rA~$&B_jOT`8YOH|y;+3=AHftY1J>H|tjr)p`Idvk}DZWPJppx><jNsMZ4|
zvL4;6??LQt(HkJ@;3H-a#tR<ZpsZMG^g>gafx)Ajbty=yTl5&1;$07-4nAb|=#}Bx
z$KU|6@c4^%IS|eK;)5($$7+z8PS*$g+eBx8nBA@qIs`nrT_1RKy1wXU1&MXKUU<zo
z0VKx1je&pL0go9Ty`tQ?3=I6+SOhv;&v(0C011gOc=WP<$!1{S-_F96)_S1CqucdD
zCu<zkRF6*9@HGq!uZ@tEv*tsT&**f$&|G_=s7{1`o9lUyX`-vJTW}d9yq$%KfByxL
zQbvT;l7&#SEL|^@&O)|jK2ANYNcMX)yFOq<)|LU)me%~EhQIaqzyJRyAWL&Xy*i`Q
z^-6Q?6^2qBk8akI)u7OIebCLCwwi&V)Aa(fj_X-a7k0W{@#uDa;nB$&0#XkOZEe>V
zoveOP9{)Cm4pvSm=NKrSK=Hx)e-#5mbL|yf{`Sj!3=G|_S3G(}T0yzbqnDMxn1P|2
zg$W#V%*6~09*h_4{)1xm&?<<2P^_|E1#vn-&O5#e?7Wv+|NsB*W;Fzve1Nf&Rbv$c
z!^;jnP-50x4Kf;}nRVSN28Larvdp9Nm`AUz{Avb<7goRi|M%z>6$ZJo*Yr^VC^OqW
zDPUmO0n+wj_OJi{cYsEdUfP3AyS)n1aq#G7O+Yp6;wlD)7jJ%oO*;y5U$5yZh-uT{
zrul+Q<7Q-Fc=?eR<hI^bpiUatZ9=G~HG@o>2QjT2Vp<Z!G!M9G|9}4fzXLR~^l~xS
zH2YPcE+E*nBP&sSY6>zf0AiXZ#58G$X}|JeKHUg1jSJ+qP_StqS28ew>J^V})-qJn
zp08wJc)<iQ?e<DgfSF#-2T`_b;HD*mOj8G$#tt@Z@k#~;P_5+A&8mTF+DwpXTYiAU
ztruci55%-MxM`vw(=<S)?c@Q4Tj)v#22h>m(am~m1&U9-L8hfaOtXiW<_0lM0B+jx
zAOHXF;02kM4K|H^B?AMfhV|%X?Ljr|?+ONn7ZMQDKCS?H(Uc8h+MzsHxK)BoV*{Bc
z3pQ=%3I+yH{p``rYKLmtdXQ<SzJq<b7-HJ7JdmNbC2-TUL8h^TOgqmF@@e)8NN3ff
zoAtwT6rU!7Osj#I778(~4Pu%a+_byj|Nq~?3Noz`Y?|x}2JjSyM>p#tRMUh(rs+XU
zV~3dL3^DCSF3hL>Ak#QNrWu1xJHMQP0o0Q4=w=N;HSOqf28I_8zJYzZb2-S1rvGw5
zlx-K>G)ItW%plXAa)Er>xSW9j)DH3JW@SS)tsG?9B#3F*5YrArOtXQT_W9fY|2tSf
zrcDQ%X1tt%0o01|=w{uq3?<w&L8iGtOp}F})&Vi?T@K8rOF^dbflTuRoAz`WWSGUH
zn>7p7wA;%V7+!q)3ij#wWgst_Izmia05>fhWEwxnwBMW{pH5!}8vFz2QyEm#dO@bG
zfSA?@G3{p#$WYrLxM`dq(*!`Ktp%IrxePMI?$OP9ZYhdS?LnqRK}<7-n6?RG8VlUC
z-CzIz-ysMxEgo#z@1+dju_2Fc)&^A5J}zZoc)<fP?dejGqfGN5rftiHg<CGjG|*hY
zOF^({YnL)GfZBc@-K<8arY#1Uw(ko#+@?cJ(}tLq0XIz^WSTI@ZHGBP;TFG?fdSNV
z^yp@NvINDap&-)=Af|ajOnaOSa-yvi+_Z~d{{P=00y3=>Y?|Ow1_n^O)1#Yp8mejR
zAk&l}ru|+5GRAZ!#I!S6FrPMqOcMo}rVcjk@Dc_FP^;CWo7Dr=w4F;B7+zfY4EE_-
zh-pC()9T=+nSx9c1DSS{9pux}B@7IpHm^rF>#xNqKFtQ1)&?;x9%33d#54oAY0p3Z
z|Gxt?GWfC^Y?}HK1_n@z*`u3v4XSCfAk!=$rU^n!JCX(Ru<fHvm``VdOp^e)%@%Ch
z&BY81p!T*$H)|ZKY3CO+FuZv63GCCui$TViRzpmi0yoVYWSS(%wD)WvpLQ>1U;wq&
zJ-S&1P)%zDnKlPvS}DXdBZz5kaMS*N`u~526v(uNVAE_DGcbVK`X1e^hZdoPn=!~V
zKZt4S5Yt{|f}CjkBLn8s^&r!vL8b+RO?$tHfdSN00JVouO?$eCf#C%M#I&1>K*pFZ
zf|#}nZdxM9G#QX-tYFg?E@EH+4FP#{v#Oz*HXUTzrjOuo>xP&X1u-oKZkjO2G+B^o
z+gU;37QBdo0W@&r(am~eA&O5uL8hfZOtXcUCJHf)4{qAgkN^MgkOP^P2{w&&5oFrU
zqnou0)wJIW85mxOK}>tU5bV<{86e8`Ksqek%0Z^dgG`eKo3?!+0|RJK*Q1-&2Gz8+
zAk$8K0Q+<y#I&gp(~97xX@X2s0GW1{1?1Drg^(!`k8aj?3s8I-4>GL^Vp=f7v@nQi
zDsa<ofB64@ha$+dda!BI3mF(d1IQlTtP4<069k#212K&iVwxbtv}<WFpZ0=G1C6o2
zGz6P=b^!weXqeign>7g4w8IM+7+&0a5BBNy1)u;kJ(CWiY&+nl*@H||2D$AqGsvg)
z3m6zw8Nl@d3#w_QAk!v5Ov{9r)&?=n3U1oR_y7OzPyv}X6>OT}0tN=q(6>i7>$dqQ
z;ie8U%?V<fG{iJVh-q(9VLn|9GEEg^nmgFE$MYE&K%*8O-K-g?rrn&+!0_VBJFrjB
z&IftXlmTMeJh*A0Ak)-9ru}3B`E=@h(BuW!r&6e<b%RV>1~IK3V%qLBkfF8#aMRd9
zrtyGGTg?PAL$q!lsIPis9s`3%@&}J@)?*-6=fz#1VH%Il<1fCw|NsAG6%*8NFH6C?
zSQmg)b%#Fi&^+YPd7=3QW2fs4{%xX>U|~r2k<|sv5!D4z@UCjNgGK9s(j<>=R#lLA
zw<sToLXwv0WEBSqb+fX7Dbcrc85lg^3Ou?+kAMU^1w6W0AAwliqNhO=T*Yw*&_p<>
zCwv$r-YvQYM8Ty!x&t`6S+{`1W_U0j0+s6^w&kIs5|3`t6LUeGsv90NKppE&)`@c&
z7+zdw2X~V|J=x<gesX{~cRadT=Yq6#y1r<xy~9wV;nB^S0upFG!06G*8VO={vj%}E
zP*=<KPN(aImwQ1Oq?^?SD*6&sY`xHCWMF9i!NlJJnvMi9`a!YNdY~k;`3EC^>woZ|
zg6LdOhl+vW#SS0PSVM`nM>nf1*cjG#b3pO;Wex)aC>9PKd?n9#;o^_x1G=5AS6*KF
z2<qA0o&(av-#QPHKU(I1`lrWVc<?YVyzBytiCzGi;tKco%sC7UFYdE}ym|ptu7P#9
zKJe&fT@GQsc=-X82fA6~LHuq}4-kbG#sMHPXh4GGU-ZEZv;;|Yf(;CVFkie}^5Osg
z39p4bdToVM7#Lnm6J=nS@G|cG|Nj$SMu6;UK4K9adl-4_#lxeU_5N&dDn0?CknDHh
z@aS~C;nB_d9V7v<X$y$iEjkxOp(yPZT?!IQzU0w-h!K(|W`G1N4;Axx^xBqyoWm{(
zvWK+*B;G9=38LU;bUT=|9w^oG=oU=`iFdO$fhcg!@M!+QSjx2nl$l<3ure_00FQRo
zv4RW}H3li`W(@&RVAY@)bUkt0bqgrAUn_cmGFYz@qX*dit~We-Js3SYeQ)q@6Y3CX
zcHP3*?YhO<^+e5ek8alMv%p3k08vN|vuOUoRBCXX6(kNa)T5hqEl5eX=rj<8P${}-
z76U_PfXqu-W{^Rw?I7uH(E<>KP~{+@?Ro<2$~`YZ&1g_N2Be}})Ez{@6@mtiJi0}L
zK!Tt_j&27INJ-J@dImJ=(e0qndZ45b!jxb<02%sWs8<1t1W14>2Z>$}_SOUZ9tRKp
zU<Tz>*B6}u60Zeek|GQsRwrC_^8qH0<O?7%50HJG*FeQrEjZpnUwCvnalGaMOCEOs
zby&fg!3tXsl!Bu9Xc7a%3k6}2?_FPjO9|IAuyUYtCP<jI2uz7agDALPyO9E=xpof&
zf8Voz|Nl4E?g1^vsbfFx3TAk8vzmakb&JY^C?wq~tq1s9?t!wo>j5n=bp#YsugyKW
zSs6iUyG38kKrI3tIJ!emcqE_d4n5+Le943Hln3L5?$86EL~(?%+x3XG>z-OUk8ajk
zAbp+3UpT$`|G(4qKy&SZ|0QhAwFkIL7lTO)k8aj^AT`~h?H~&7Dvxdtj&9cz9?2iN
zU61qzFm{F>0R_be55^M^duk8-FO~P`X0-rm>pcD<;l=;|tp`d#;kYu9f#JmsK~On*
zq?6Tq1_Q%O&<c_lf1m&Ve;nj9hSx?fK0N>bznh`?2MbtB8A!`gL6APUBGCBgbVxyU
z`NjYL9^Im6ri0Af<1xddoA(7ss@wD;h&uR;*@N+;M>nTOcOgf&?+K6OlODY`d>)+_
zJvtBV17*Dz51;@4-^sckWB}{V>7dfERNSMRwF;!Y^Z1KJ&q1!|Z%zFVvWT@CB-|}p
z0;1qS(k<FB9h^hDS<4|NxHZ?FU?`P1?h4M{9^I_kAPt?zUw~TYul0|+f-}2EH>)*B
zyjxTSM8VBF?qC5b3tqDycLk4@b&D#1oacI?mxl>7P7G4qE&5>^a?E!-NLU`^?*r8o
z-J&0-fr8@%<DqWWXVVxMF8*M=(CK;wG$IJf1gytEI=gw-gDBAWFXIW&Krtv|bn~tP
z33i)K22rrklk|XO7#|@}pgV(Rd744;-J&@l3hr*?Eb}Oyf#JnlesJCh1F7m3wFgmf
z#oeJ-nqM(>21s;^IzgR#p_A1dq^6ry1x$(Zf+)BSaK>X51&M*G4)DMy>#wOGD?}fI
zC?u5*9NnU?L1M6y`vOGyX^>dA=oS!#qTHjC_4!m#sO|7*KH`B?n{=~oo(ih$zIb%A
z9tCOZbp7%22e@i<{lUMDq2)k{q(?WH2^;+83xf=Pzh(tTe~0VmZr3lMp;z!2_=gb4
zFfVir{7WZm6v)_a*B>68tie+uW8etoj1ds!Gdf+rG}nHCjDdd!nI^gnY7d$P=Rv~o
zG4RhwW8k7uP_ryuzktTT5w^_6sizUievf9?AB-N|tW&2jFnCzH{@`!={_p?)Zr3k}
z%D1!j4X9rSQqbx8<CyDb#%|X)AlHKZ{v{aV0I1*Jbh5^QR6_h7J_X`;gmTt!i1Hbo
zu5X%a-yr*aRVXBk!G1^RxC|1;>UYUVs9Bb-Z$N%W=$VgGPb-@J{8J9_Z#w{q2!>MD
zZr3-jS;09J;eU_jHwK-xcRV^vL9L^l$)FtL`U2Gc1u?r_Uw{YNUBDbsT@Zzu3_&%O
zrRxj+W@koF<4t`s14HuxrcT!<9^I^bAm!bn-zOnwd{D0N=w|%{671%^4Wi(Ay4yj*
zV}=LFNX82uovxrZ{3(!vZqdyk3d!aGj&9c{pmH3f?#F9!kLKJTj2_Lo9~dEN8#L$h
z0qpcnkj`$=A`pdSfCC38L6jf&=yv_!q3!wuWEQBdMB;%0#2cioThs(Z!F6{#NOZE=
zf`qzRwZN39Fo;4Z5S5<<E?_;nSvf&6-J+i+q6UHk2iTvMt}nn1v&qp63@`Gy85lg8
zb6+rayWZ(M1ghXcK5)I@(aHK7q`eyyF$^87`=A_;PS)KM85ky<gf}HUn%{sr6H6z8
z5}W9>i3|)N6IiE$`3x-w_*?IQO9Iwnuo0p$APVkmP}Fp@rhvqt{RyzV<)Jcuk8ak0
zi3|+K7#Lp82Ad%22vXL~ngpW2Exu0IA0FMTS|C28=O90kf#HSt*Z=>Ue=wB@H2+|#
zPi{R>;@13wu|)871gL*D0hHQ~zW_DdU#xTh)nz5@;Pm;rqMP-@1du=}$m+RJg`m~y
zFF^CvAnl^hCxFU7aLj>%Xu|{s2Jpll>#_+T?}O&{I$i&O#`PwET@D)82N?u$T_cFu
z%~}Of+rgR%Hti20EJ0JE5+0qkFFd+gT|kPV)0P$>cDJY^h(ZKi>w!|E7e#EK!kzV9
zKZp|L2dU`h{Q=^Ek~s3T<poBN*O@)KSzm&rTMv{-d33Yh1+lwDkAWz-(a<dG(G6<(
zfg6Imm>3vdfO=CCJerS4AeH^#=<lrk@!}=8RnFQAG6-sRBZ%ECngyaT%(iy@!QZk9
z9I>nsAQg}%EvpZR-7RVgqTrf9t0h7_x>@b}LBT9)&<{;z@*q{+q8uO!p}1RA93;>g
z07{sD`oJOc6hy(5bc=rMgXNanAenB_BOnT_0F(`Wcyuzo0FB}wXT9DBnRk25h@9%X
zSr>yebc^<YD6l@zTynRAOegD9kWe>k6POas22pSY9^DQC9-XXZAi-|dd=S;iIsrs=
zvj&1GQ7aIIqyaR`%?A?eX0`7F`JbVKRj-eMVFF5#ssKtiouyCqgEoY`SjGv8Y}X$i
z&9y%mzzy^x;S3Bf>e)eo;rgRH^a-Tp|D)SM0#x|T0JZiDL7KWle}G#1pfU})u>vaR
zUpPRuA9qjyH4MS&16(nI)5tV%WV-%9q-R*-0K1~3475I>7qavPl=PB7>~2wS5C!)x
zEa_Rh{wS64=w`JA$##pXfhedVNHZAZKuAXjRPg=)yS4N9i!U4yAA<bzf&-jAQQQL#
zCXde22QOCN0X3q*+12$0NI9gG0hP$14?I94B(5)xJD5N`%DS}&;qa9pcDLvx5CwHp
zHv_`qFG|Ef1?h1I@Df-E(*V?T_h_ztz)&IwS_c5KFY509|DDHQ6yE_gpX=DcV@9u8
zcY#%QgL-Q!FW5nD4E@t7fSmL|i-<aFAyLcU(hLpt;|`$VXHdTk92VfV9H@8%m->uw
zZU6@;;5@*2!}Z5;2hh|eSkrL_3y96Er@9ed-3MZKi!KLISiJh9l;g$AKmY%u<_%Dd
zfN<a|1_p)~r$L2JH)}q~9B4*Q2C=(EeLxi4Xjn!M>jousQTJ|WMmGbg>K2s;Q3%D|
zqIw_!uxD6>LCkK^KV8VRUbiSmH!P!n0?D)<DAD)mW_<=?cZ;3}Q3&%|50nUbbhGXR
zi9(9(bs%Op>vk|Dx&TChmBY)3*T4V&KhC<j3ws$+57GeYp`HN85^Fw)-z^#eqQK^W
z$_x*Xg5?keejpiW@#zF&cZ+I+D7a!+GV474V%i^Ye@hx9-z~}lqM*uPIfV6nCnPFC
zzIqH|H@^T4u-yPLyICKCC}@CO1+lwD_kk#=Dd3ecB|<Maz+Sx23HKsOxdSR=XMl9I
z9w;sHIPUrbl3`qbcpQAd3`*vpk$I0!))J7KZq{571syX;3<j-R01t_}{_yA(0c~*r
zjXZjGGBAKwKZCR%xe4+mxaF@2(tDg$tP_+_85mxImRERmvkHNPdjtM^bhG~N0JXXg
z@wbDPRe2nD{Qw%P@aPtO4-yA8yTFaSAK)y2u<s^F7Sey~VF8t!tj9qj-K+;d6x6X>
zf*2TH*h3uq0m-p*Kx(>qdqEVa%4IwOcRDA+>3JOt4A{#dP@%wBrUNb%dISD}iVF|M
z3*cT;DX1KI-~slU>kF7@2^YA%@)ETC3R2kb1PwZY+CuQc-X7%GN#H!^`k?s*6S!&j
z16t&Ri|tNmLC_7Q!FdQ&Ab{8Yf&&Paid=tmgGY&ebOy+PB#t|PCLW-L22%N90*V%h
z0%%bJinZe}E`sLvyRp^_;L79piwW2N|A#seT$6yh_9&rc;L%xoqq7v$KZn*<pkf+Q
zZ0`oe38>}XT>Al1)fEOZFuVZmZ#wS!1mvdI%Al4zs9*1T13cFA#3T8XM|bE455`lV
zg+fftu1^@dU7uLHUa7eX8UmQ%(Hj72)qn6{1a*qLL$9D|00$u`JwZ~9%D?~rJy0S*
z9OMMhT17~BK&wmaVZf@`2CB0{e|Yqo{tW=7zvJK-e!+SD|Ns4<uy`^5I%3^iH|xPx
z1_q=&*v<L@UEn#2KsT#-8=4L|6oJm#Ki#f>I$1MXQCk(DLL3}LtbI6TYEWgmS&LEZ
zh8Z1;s?6g!Ydm=26$69EaaI=u(-Fb+gEEh^`oLLkP?pDW*6%H#xCQI~0%d}O4G}W0
zK~2U#Es!D*)Z+L6Vt0$)1X1up4yi<S0jE^flOXwS(M=!<stl4BUMPZ=Y<07)0Lehx
z=5s*oZqZf{1yu|#I7^#7x>@T%qMgTI#DPlp<E%MQcfR=g@Be=^$HLo6-~d1V!sqJ$
z|0sDtzylN=ouwbZDHp5?oLQW)D+DVz{$lIp|NoI251q9?I!nKJbcVhFH_A%6J$hL^
z!$677^#^i;vhhs-D+5D{M>mVA2FUT9u0IS99B)1G>p!R$z;L|v43y>3+X`Cl>(SZz
z030|Fs<ZV4h}YX1@EephT0ekz-4Lp?^#_P|yp`ei|No$h@p$VFsA0!j_rO@J?Vy$o
zXhfHFVKV~*XvOSn4v%KAxs2Ul9iSou%m?*2!KOjVN{AB}FL+pjW%-+KflER#$3q(;
z3$ET<K~<Ya<6e+M_|+L0`1`*|GB9{tTnZ9^iVLVSFw}8-KwJyrcyvQd=xh}L`K@~@
zSaIhCkAn}GK=WSB2f)={&t<U3B|vJL_kt(}{+1aa<GUf&cK3n=J-VlY!wpoB9P;Qq
z|H1^Mue%j22M<%Q6<~u~6+i}dL#W;WW{=hb9{e7MJP!U~f;a%86KY2<4>-SgbWa7F
z2aAB~9-XH=I*+|LaS2qnLUeROBBvV?jv&84?9+hQ2c~e_2TcT);4mrS_vi*QK=rrD
zMX(*<kOtRekkA8F#E=MqIu&GNZ@?c9s2joZ;B*3Y5vpEj%r=`yFfcUl1tlM5{uVI_
z28IcsDK1Fz01c^$vigD=k}LxJ`wn!r9{BbDfAd}t+0Wl%2p&E1Yy?dp{woy#XU7-u
zmqA0_CXJwhCA~(_Xh6LLBGq?;(|;$cNFxKoYpZTn9<YiE)oxa%Mg|63O-2TWdWmk<
zuMG?gV9Pzc;g-K<1&?QUf=z&!!-(V_2L6sE3=9m7V8?;hZS(hoDzI*_5|CLUptZp_
z{9yxhU}H*4(Bx<MLFJLX%23boeJ;q)uM3*@g0oi%d-GZlgAt;=6P%emn!(wUrCT%z
z<os?huT$VSt8xP*_r0wD1DaxFoPZR%={|4|qFBk_vPy)3VFJW_kn=@r1CdmM$`0_j
zuQs?C0V#kk!-ZH2s-zh@Td%;QE1kdHNtl5FY93<Eu5k!r&8~U~Y|XAmuW5ZC0|R*D
z(u*Vs28NeBpoyto(>%DS4@mTz5CcQEXn8$olD`$S2f(A(G$0UE7D6jvi3^~#E9!})
z0+dgWzv$NiB@o+s(8wcWC#wlW0cab-aR!&*u;8@g4lD``9=%f`rnZ7)pfdzp&V$w~
zKt+y0+_+Dif#GEaXzHL_^iCbvIY>G->mWpWO}9c?2rs%odQ8ARSc;^j*K{UC0VF+#
zfo$s*^{)fDw-%(X^IGTe7eA#L7&=*VLHu4+rx=TaRJzxJl0JXm1<*tkt7RS3p9Xad
z3@`Txg4R)}g7#lCFfhE_2vQ;{g=AE(sT{HsE}z5n@L4eihL`1nAb*+u^aoM4Jar5V
zFWAq4`og8s9^ImIYC#S;RLj5so`mW={=!g(f#J2CN3ZF5h>lye3=A)>o`vhk0_&In
z(gA8Tbsm55Uz&m8HE33CxjzHLi&LO*>}GYY1;_A<Zg~cVm!Abdw#3vzJs4cez;L|P
z;5Vd_>t^+?Wnk!RH31iaqFi9}bwJvi-*Eij>hSyj|NmPpz$8eEN9V=PLy*RQudOY}
zaUaA$qpL?0x>=cEHvFt%V0c*zw)I&J)YiK-sJ33ML9%s94akMtYCt9twDoum1H+3d
zxUD@f8=673vV&|D?Esn73rp^ae&E1>Bo@uHp!E*vFimk_m9QiX@gcayG4b^O|Hr|h
z0&0PI9B&1M0f^bn$_LZT3i1;xdksh!)VdWtQw{RRyK4OY0CygHZU0v@Fud3VntX0P
zqTtcZIvu19ymJ02NJc;tlyMh<1fj{d*OVLCC-G-MX>KYw6G8n7$+#gRAjh!UgS2)Y
zf6*?>!0_@tA4p8p7$gQY4x-pf6D%QwA@NTf6l$!JAc<~PkbJiT2WYJVsGrRY@~DGI
zXX}Mu|Np-RP4j-NVqgF(U@isqmLGw+Pz4^{td~Ii0G{q%kOmK^3wlkRd_k5#OQOEh
zAP=Et)ecah)-75L(hj!F1Dv;IB|v$5Vim~ktYILk^Z1K-G7Jna*+6?9MB70^&_L-m
zP4GdoMdLIm0i;zy(`77JC6)v*;Uta(aJ&_iDL`@F&B_cj=2s=C!1z-M5(YU+^k5|@
zDLk&kpA<kl**tn}zf>|XyjTwMDkLfNfV6>=!Yz;tt2!ttOa}?VLyiI2Pa&s3A%`U?
zc!JAYRuhoc&f_m?q!}1qJ^`<z_pF2rb-cXF19GTUC1iCFt6?Pr!^?wUC7&uFzInNc
z2kfP96`(>48b9Dn@>dNkakYYhp_}(OLb~%Ds8!@90hZm55QkO|reJNX^FR`v$6q{?
zVqkdb2exuE)XL+mdn=&sGX=R%Gz(+}>kN?Kg-+I(3Q%azf+~I~1lC&)<sN5kgtA`#
z<OT(t9#}6(595VSR)q=%hL;aO60DvT&_v(>G7nxPBC>rqt5pT4m;&W}k8aVo<)EPA
z2RR#0;Rq_1J$h|H_Pn?ZD*l^~D7?%E%|Ugut}X|qM9}US#tH_87qdV)wUc#gIRnE>
zUx<p8AQi0#N(DW7ZB4xx7+(BPV_<k`0FmqgIRKOknLyPCYb}^70m_s-$61rhAtCmf
z>o{w8IV9>lx>+N@ig-F%?Lj7YvwDE}BAu+lAX~3<fxM(s4r(AWmTGqM{w)Iq8AuM1
zOD}qYTn){oFOL8J|60A9_X=3yt1?8I=r!GptZ@HvP@;q;7ic43CqDzj%VaK4x?tT8
z(hA<q)@$49$-wY}PYu-K1no})84dC#BdC?lIt|8U291`B=7aQgvo?S!256Fc1lie^
zjZiA+(QE4E32Pxa@Pkr}LK!4jUOoWN0<hY^lrxqHdvvqv!nn-*t$QIVewBi~{=x~8
zmOq2I&~gP*e*OYmEP4q;Vjn2$b+X<BNp!P<<huhzx>*;NGB8*k;%@=9d_B5Zca=hm
zO~z82Zr&D%;-w(L01-q4^mu?>0ja^#k0FKY@fSB#7#LoAdUUhqgLHvHjk(mSo7WOz
zR1`=M*(gV3qhwHx>Qw>7y*@;z0*LA@5b%I_7qnF7lSi+qE3*DON5M`3Hvl`KQGAV;
zf#GF62Pld~kCY%%2PC*oD}f~zV@ULaa!M!bDv(4sD_FkUL84o<5G0U%39-Dh+kvGM
zDleJ>l7tqC5c6*-GBCVk;s7OT^Ac$8)++(UeNG89?w^1sctkZY^y)+0#*QHYYCw5(
zvhsl>x>>>UV7FZb?V!VO8$@381V|FaZFV5HrLlwDHoF+=wn@bxw_PZPy3GURwqDcM
zZm@LQ0WNx3i$R8gD}<B93=A)l1VHJ5wH74W%~}T9)aL=(*qQ@k1@Isej*=TlAvEXe
z9RbG{xWNF6Ee+5L&r6{B)n3yoxUHZ9_2nLjXbN2P4>tqD%ViMJV7TZrkmv-6s1scD
z0!Xw9B5DX1-31Z_o%H3=YpMVjT>=vIgQ(?)i}ry;Eg+)*Tw&o+0TNYW1BK!IB1oYH
zDk&ekGBCV22MS*{hz@SJIc^{wA6P*;a*=dw1nHOq(s2besoQIM4{nDDNXI^i=vlbv
zKQ7QRHHhdQxabRz=p>M6H|x1VP+)@!ca<Urh8KH5O|DMX8z9kc)}0^<9E0p2Nh46h
zJPNE&bRI|wC8aEt2j`Mn42evLnJplRZdR~7w64$t`R9xR1H(%euwNSs!J)(73Ytjp
z=w=Np1Q#@|2TDymx>=n;JaCe+1hJ5l%s&^9FQ7^0_rd@FUxM}sd33Y#gH(dc7yeez
zX*nL<tbYm^7`i=FK<iFGEM#N0BO9{?WDMvKFpqB56Cjl!W0*=EK=V*wF1QXe^yp><
z?dj|WJ8S_+0@=g@WD}DP{{R2F)}x!X5~R$5qxC>3NP9Mj2iBelVj*j{LDsGe(r)L`
z&1wZw267E^DQL<}8^i^BND;(B*8j&DDO?^Oz|2Z_IT#pTwljkg8cPAFYgwuS&xoQz
z;QgSchmZ}Kci{hjaL;Y4GXuj50Z^RxqE?q(AR|pcMv86)Z;XUU_nP)OA~_}u<d|;J
zb|e*$!tksN$T8LV(6XioNkOk^AjF6lY9Ko<Fo8<`K!^fxao%gH1yKO0bUy6|j}j;&
zsess#3ARHVW(OZc0jP`tj}o}y871fgnTh7(8SD%UFP%WM9o?eaz&j*c!OnqL)++<f
z7jq#JHQ*Tua6_~NBmprBY%OAN0;~uk18pjZW3g5dT<$`w>NPckZi43qIc6((Tvb#P
zVkgLBP;)?Aq2Lj0$^_MOosEIvWg}?VO_T|u1>yqJ+xAFNws;>nIIn>BGPZ(MKzt}A
z4T`c8xzH%v4^aTJ73?oWaDw%q_{$z-CQJlc8GC|CO3_M)Dd2$YH4Q>`h!jXux2QLg
z3W!4{N`V|=4|9lFE(60$$VwJbIf!Dg3m}TWN`d2r6(Rw)2O@C?BJl>i_Ym2iMj#1@
zW5FK77h!38F*92MsOW^WOgwr`TkXJM`vO#;zGk2Bnq|Uk&=4MI2+m^$c*yws4G%`}
zXkRyMG!85R8o);y=7$asdO$|#x~GB$=Q;(TBXXeg45V%0BYe#-v^!gG{QCdD8%%=6
z_eB3#z@#sDbc08JA!i{lUg&JS10LuDkqi}qje9{1&=_dFYd2U5q#rW=X$2YI<lm2K
zhUKABDKw?MmJp>gUP~Yx0XF0^$RXQVm}Wr6JzuVP{{KH@)R@&K8&om;D>3V4HOvMT
zQ=p+;^=zb}UC^dZkaI+HO<~?S@R|oawELQM2WXN4GQtZTX)TrRW<8t*O|ZKldk6*W
z85myJNrA?#L4&Z&rFIZCtq1D)yIFT;f$S~SdKm}GC*WaTk6zLJSqu!|3i5#+1H%jb
zXP`9)-C2-vS+Lt76DOc9b2nr(7Zf9$W^gwmkIwd&Bs7D^l^G#p;S3c4h;iq77ethT
zgDV9ZkZGW<lscNEIwCAVBg|0q>eHby>|qTa?B{O*O~)fS%m5UR+rWeJ9^F$xqx@jc
ziGn;A^z{FKkLI-?K^BkZwV+hU2sI9pV4%?^^8f$;35Y@KxuA`PkhBR)l~9Ezo<igI
zc<T}9<kD*`P$q!zK_gDDr9ga-UfV^s3=A(8Nq~mqKx#qV)oxa`Oh~E-?PitE1jP<0
zRS0Gxr3x01<)9D`H-?8emH~f{UeRwE(1`Q|*_8GKltqZkim#neLIIozUx0!iGaR`=
zW^+Bk8II6sDP0GfyR!sG6R1N8W`G7LYPW-&1_}g^Zr>j%9>zT2dB76Z7oWGIO-w3)
z7BqL3K4`9e!&t}GT>FNpPNCcN4LC}T?4VoUUYyzf|NjoqIX^GYf#wrICw4R+-~g?v
z?={tcmQfu$KyzlWRcm4%y|x0NBw+~GI+=liVZQ)qL6I(4DQg*Mzh5_NK8Wf({vwJI
z)MaQ*hjbZ^v$jK75IsM)gN$db0x9lhEe27bp)nDVo?H}_=OHQ;KuWq<B|%i@@fRha
zAqnujDr;RD1H+5+kD#--xaMhD*Ml|?wjL;z^5`{<wFPzfY$HICGaq991dud%(T0IX
zH)|7!2U?ZTYia>f+X-!GGJzC#vnGS2JCDC`-v0mpYa`IUPmn;jFK9j(v~++MS<ks`
zph}cgAEc!7_zV8+sI$P(6<Xb*RjHubiFH1h@&y@l-UeJ>K$<q~+y4LG4~n!GvfB|W
z5Wo}Bpm2c9ibIw-fL7WdFG&QgWwn4V+vp6v;L+)O!UMGBgTDn-TJ8reh<lL%a%CrY
zDaQ>^qU+cSO0%FnfX83>faO5ztX@DD<AKsjcjygh6N3k&w%heZcjy(!T9y~xp%*#>
zc$z^6$w+pGf>s5-=nN3(4i)hLuci}uDa6D8I{k%_zx6RB3BK@XJ|N)HTPgsueD{|B
z{}GD2T}8mvBX}<N0LU)TY%^%ZNr1$0*9V{k_Ob_N3aG~$`T(?<2($vAS4LnzC^TMl
zg0(Swbh}D`_M##6hQW^W0BQ4m0NQW^Svcg;&Co3bUU-PEo&mDpBuJtgN&P90ZXu86
zLoA?PKNIBW9T7{{2mC!5|NsAg3EDy1TziG7R2f@Xbccd>iFF1@y!^ue4i#qp)=x11
zAce}(%{W74)fP~8g2oUiRKSaE&_d-2MyM2nwLwD#E)6<~2`N;b;0P5I^+=(DP>&WW
zpoKjmmab1Aq0$|y07(oA-J#&!a-9Jn>V!u(#O}@j4G+-HE%3r;kkE;42M)+upc9<|
z9H6z{s2eFgn%}@zl!8`rF_c1Alb3=QbagX;mj!|HN;kx{khY)vX7H>P8z}3%_B!tR
z1zZamfVdvr4jR}sz1oDNNwnGZ3uuYbgKh^7OV=+oN5B~tsUQL^76BJ6PzSL?3`br#
z)cgikbc3A^I>-yOsT6!57Icx>Zb*`N0Lpuvu0M{uegUQY*LJAB150;<!w$M~_6I0O
zS#AUsLarbuf@kktA9MzAfZW~f`o-GyO)U@1l-2{K>!4ze-M(MCL%+c4k2nih{n4}W
z|Nqy@AWw9IyR;z9Ke`=6nh!9(2Bl@ts#i$Bfqi`qEj&7F-*lF~@aPPE0QM_?%RwZc
zffitH1ZRUc4E%kNrI?VAK=N}P!ft5@Q=s(#XhH|HoElWpfPD7a2O`A*+Bu3xnJQcv
zb18Ul6nH5!==3tEX$m0IK#Jh$0pzU`en>F!_vHTvuewDnb^?{R5gwhjJ333ZcyxxY
z@Mx}G!NA`#1>9eBT>*+fkT+YvW#ASD{yxyIbdT=P6&~HLJ3JuCQtdA&N4tWS2EAb5
zZ;6KJeF2`kVk`mW2MC*)zZJR?62fQXZv`C&1<G384kDn_+>}9`X4fr<BD8h`$Y^+B
z0ahBir859jID;M6>3XBvbqjcR?1|&9paBtvm!Pw}J-S_QfE~b8S_RStE;U0>U=%Ad
zU<*LS$_q3lprQqo`EGOv34lvi><W4VSRi&ubTaMu^Z);UZPzp4GXDm|l{cU<aicl+
z1Y@)78Afnz)?o|k12@;+VBl{J1eLqGAU>#Ga^PtG!OY(ZIynR6ZfL-O4u9%K4w#hn
z1Ow&)EMP7icfA72f3Sc7<t$J_LkgG+7y-i!wg4$$;7VWt^8hVi&=f!d=0UduB4Dn7
z1LgrFU>-mN=0S7r1;%FAD~!#x7Z@tIA^EH|^#A|=(BOpVdeIr6@|tS`yf5m}d?W&S
zLrLQs(3J}woqHwz{r``)0L`NrEXn|Gs)FPp$r?N(G~0xM;RV~;|NmcZ15Kjz+8zK2
zd|d<TAlse;v0sANpw;uetm&o<3;{m9yqu;C3_iWAAj+ecm)#W9L=$BLQ>Lt7%9h&{
zRs?ab1vO8O2zd0`)`85M2{Ny{73Pl4R*irE|G$(2+s?`d(%sn#IttRGmlbSeXR8Hh
zSmt<Z+Q0w*br~2K(vG+0{R6Ev@Hh@$L<bTBO{f0{iGfx&wt`O91jV?=@m3FnDCqo6
zsAvR26m&`_R20+#fHFa6c|w^LaJ8<W?lptQan}xrlq;x%2I9|v@)tm9(B5N^_y#B+
zT&j8;cLg8P?Qz@{w0sXFe*r3g14@G%NFK*sUqJbw+W;6my1^j?&dtpHEoWFj{VHbu
z{z?uIgNeW82Q!4xpUwg5XO-}Q4smD!jncjh1<jiDvK}x7wN4?S3NuZh`3GYOJ7~w3
z&}#*cUe@^#HK4G5E$`9GIvt76@6pTJkKj*$ISD)s1d5i<iypnAMaB#a`@kpA!P?+*
ztN;Ihc^^Cy#tQ1>dB9^<2Vok_Fb5HkyZc^&iqGS%pu<KXq0l-59NFNA1szEW6<vW4
z1sz-p6$K3@K$)N+E-3Q^LM`YJRH*0;ged5!RH*0+ged4hRjB9>geU_%J+yKln4ryW
zP_+_J(c`V46I?-pX~$btz=ANpf&&iZMR35`8!<5K1MdTZ1>Dn>prrz!15iQQUxtB8
zM{qI#m(o)~GO!{GTpoe;wKJBOL(Rvdh^ds*qnGufAp^r}0gqnRogfCgM=$FULvRuS
zozaTl5Rc{qEZq#P2f*e`f@$xCXpaEp)b3sgH5F`FZ!73rSkKNApuO?Eq8Ww^4Ew;x
zD#85va|NiZ0Y^Bf`Lk=q|Npx{*Mxu$Z|Lm>Y4+%a%7PaGfYrlNu}Jd^M$1-EaMbF;
zl^uUkied;vcdzLe1CSq&zu3Ow|NmyNCeRoOsQBr25P_J&-!lc|1(=1$Uua`BX${n*
zT#(x#Zt>_15b)^j1w|@!fB^321_K6$eV{z=0rNBKivRy#9s})~fM^C!P(b1rYz(+u
zbA*MNKZgFJ%m4p>*#^?z%jy7j3;xV~NFU^La6t;r+`EwYpv=7q!N-xgr|P3;ZpY=I
zb}HD>-3}7a1hGw@f#EeMJ#7Y=*t-|9$oZg0ujo3E0iZwt7ltpGK|VMF+Je!`x&WjW
zS~Nhz!$AS9cw&I4ffr9d^bkG*`QQVBkMIF#x&&T4UDiYQLH#l$A3#c<=OeH5IjD<X
z`lK%fl|G>D8Q4o7kPN}n2dg4T=@YCAEq$y(3{Yxu(*?&S=tO9g(g(v3l+s58rkx+6
z-2;?$yL%zjRIp)arOzuJ^wOt#2}<c>vxGqD16B`9q>$1F<Vcj#=lf!0Ltv#(8E7G8
z=kXVoOF*R$NE1rw0}{X}eb!<%Ne^n$`^E6|i>LHq0{Iz~@!+LT`{MuqUwcCX8h_Dq
zMH{{7@&ak*^XO$w)&|EJxTyvW5Dy-xp&s1~KE2=un@9IvP@eVZo(fh7Zbxnfl?q|L
zod-QTe?U(5U8)UhE#6)PZ7o8Kgfx=Dg^Wk@UQkiZz~6cWe5j?ZfffV93vZD6ZdcG)
zD`d|_3G0jYMJQvfpguilECJuR8^(x4Nik&f^Eb$R&?Y6&kwTrvUr2-a;B64cU)%?=
z!EO2<kioVepoTSg6a+knIDa81en4GfP$%$*2V}(Ufd_cAFh~g06M>AAfcp68+d)x>
zNJ_F0{r-|T7#rfUAD{yPz(U}j8pPQDAOVP#Kj0%ZV0W=Y+y!=R=kXUO7J!`z9(>rd
z0Ng=F8WDjF)il?>U;vMGya0I;x<)`16a^stFG1T*JbG<yKmyxA2KL%ofY__SY}0xz
zP#?jzRtpx-pTXj`A|N&GAT}s`Ap<|J)ge8221wfQgzMQ4Q3o2c03Edj*~?pc$)nfy
ztR@4)3x@@uXiwAQmxpW^0^J7yUN3(bAqLv#0J%@V^dV?<a}U@^)2sdr4EsS%*B2o7
z8Xf>&FaXjIQtue<(`)PO!@%Ge=Gl48G1Rm3t7C{`=buoIUR@I(28LiC&A%WsU--}e
z|KH=_U*-~d!`smF<9#|m`E<T>>3r_^U*x_=^I=90%e$qoK*mSMI>tE0I>tH1A5KGc
zALwQSki8%?K`KFfP(eJ3M?+vV1V%$(Gz3ONU^E0qLtr!nMnhmU1V%$(Gz3ONV7P_=
zBLiqPAtB%CFlaL{F)%XlGYBwfFsL!`GN?1~F=#UIFmN-dFeosnGH4NiAX_vUxEPce
z6d9C})JntI;$W5xm_(Qca+w@hOqM~5fgQ}!VvvW@S`4gU7BiTXWYA&|1GBUkI2a@t
zgurZJ1~vvQ20<`eih&bML(FGk5M|H;U&jKn1qWt?0w!iC1C?Tea#>i}*f}`47`fqq
zhnJ6EfRRxUCxGY_5*85^6PJ*b5)_n{k(HAdR8Uk>R#6pH6NJbQFv-Bk2=gK&0GP1?
z9DxTDu4brVs9>mJC}yZZg1HPC3^fcA3^kzZ5g2$F;u!=O1Q-GtLK&hN;u(S%{2BZh
z!WqOEq8P*(G8s}B;^2B27=jtx8T=R=85kIx8T=Sr8SEJt7<?IQ85kHG7`z$W7;G4<
z80;DB7y=n|7#J8_7_1o>80;7r80;BLz-$EuYX&0*(1B1!3|b7X3@TuCpz9%Y7!1Id
zPJrC5#{io9W?%rFHKW6z2NGgXV31&tV~_z~l>@nQq=vzO!3HdcjVNMZWGEsCiy834
zB8CzqGw`cLmMvi@Az(5{H8E;H>ab%5u*<Od9VEuWz{<eJz|O$Iz{$YHz|FwJz{|h~
zE=dF#gcyVwL>NRF#27>v#2F+QBpIX_L>QzQWEeykWEtcb<QWtgL>LqqL>QD9lo>=A
zG#E4)bQts*3>kD8j2H|UtQqVWf*Bkcv>Bop3K<F*>=~jN@)`0Nav5wG92jyK92l}0
zvKTTMG8obs(il=1QW%mMk{A*h92pWA;u+!?Vi{r>A{inW!WqICLK#9B92tTb0vQ6p
zDbJU|hrye{i@}q@gTbA_jlq?{g~6G@i9wCQkwJyQmcfd_lEH$(oWYF2l);3-m_d(0
zi$R@1jX{+`g`tRn85|~r<DEDapm4;685yVt1sMbxM8Pp3${@iY4lb)585|jk8GIND
z7;+hu8GIOWz+tM$P{NSOPy!CsWN>IkGej{&GK7P}F&G?<p#19#4M8_>=sAG%q%DID
zgEct(K%oZ;J0k`|27LxlZqtE=pb~=ugFJ&AgDis#gEWH_gCv6(gD?X>10MrB11pt7
zw}_#jC_lX@F;{^>wOBzxK|xtTwOE0Rp)9dTL4hGDH9a#=fgv?7ML~g~C^Zp8l^11}
zq$(&dC?u8?WhRwoCMV{Dcm*Z#Wtm0kr8$WpUP^vuu|h$9UP*qj0)qmQ1Xv8DA~C5b
zHNGIRC^fGnwK%mHB$Sq#oRNqu#*mYkl$xW!P*Pcts=$y~RFqh$0CI0~YD#HQssck=
zX<l+kW`3RmLwbHmz5+vLngWADNk(d(0)s+oPI0ONLwQDKPO1WfLQ1{@gF=20h?Q9e
za(iBi0)s+ceu)BuLS}ktVh+gul+3hLuzNt9+|<1MqIkGmZek`17bFW-1`>xdz@7l<
z12YnfOHzw6i<7~jlUJIXS_E=KW=d*aiGl(+L8m2_B<3ij<)l_96elO<<)s!WWagEm
z7Ud=8D5Mq@<rnGd=H)9SLcExkUz(S~z`)%5|G#GM|Nr}DL$Gb{|Nq^+|Nr0Y{r_LR
z@BjbOzW@IZ_x=Ab*#G~3eE<LdYy1EI|K0!pzvqPi|EEv*|NrTP|No6A{{P=N@&Etx
z6aW90o%H{I_N4#+cTW2MpMCQG|Dlur|6e@$|NoDZ|Npn2^8bJDl>h&4Px=2}bL#*9
z<x~IvKRWgQf8lBW|0hoS|9}0o|Ns9^`~Tm2`v3nkr~m)|eER?YrZfKkZ=Ui0|HT>q
z|I5$(|37r*|Nq`IA&aMo@GmH(<)<kmm8PYo7AfRr78j?cFhKNyLqtIrDX0ocOJFMV
z%TkNda`MX=GV?&9nR%$enwFTElbQk!bOr{7{L&JI{4|A>%Dlwf%w&b!)ZF}{N`=fk
zh04nK^wg60ywr-4c!(1;G(l^^kYlKzv^YaIDKR-)0d6Ng^OB2F6H8K&O~Y${YF=?^
z5lne}aY<rwHrNSZr{l8+lz>oe!D~-EM15sRYO#hULsDW2EFdAFfFi3}44S+Gy8w+~
z8rgu6i5c4T<pwu+1>x;kaBCLQm{n8P&;;Frf);cjZa)`yKZ}HRKf8&pUcZ^SMSp*P
zzokyUsdc|qziq#rO@Dtsqf0+)zmr#gfJ^_+{?M@gzz~q4@P5~R&;I`Yi2kU^{(g~P
zU;Cqf_Ot%``L92wKdwL4ORv8_zCWq|Cm8sE$bOlAxnKSL#{K=V5h?x2Y3cnx`}_NU
zfx*A8U;F#}qx*mMXY}`b#p-4KQvTWB|LdO@$g2MSU;X{rKl^`y9E^sUASZZ$?oH$n
zWnkc8XJ+AKkmP4zmEh(B-IXWKE5e{6Wyl7)08Yh<A)bN3l!3w6#KIEPa!3^x63~=m
zaEOUZ3yp|oV9+y2U`R-2P*+lAVBoN}VX$=uoth1^5!4v*(>G#B5oFM0&}GnJkY;dm
zjP(x)3JDBO2n&yj^kDE|NMuk`23_82&%luG>6^fyr7bVx<l>&B!N8#43Ns0b?(gqk
z4e?`tLVy1%D6_x6-?_iP|8IZ)g#JXe{!L(EF)-QR|FXYdeaqovP+osOl4+RC|NlWf
zOg;ut26+a4XnRiz+`<cHa9~gd_tO*@bQq>HNHVA}L@=ym&}MLCC}#*|2xBN^2xq8d
zsA4c;FlI1eFl8`faAAmIh-Qdkh-HXlsArhTu!><8gE>PELoR~_Lmq=Wg9n2rgBL?Q
zgC&C%gEhlE1{;PT23v+SOlQGG@)-&ls=@t|i43mbzO5z$GlMR;t;)in#*oRt%Am`j
z$I!^o#L&#p!qCdl#-PWL#lXg};D0(p27?<z4?{0QA45OGLIwi{Lxv>`OBp&CIvMoA
zye@`rh8YYA42cX$49N^B45<w4470(#W&s9Xh6N1b41x@c7-SjdGJN|l#-PUV@xK<s
z3I-(xRfY)+atzBD>=>4#=(cBYV(@10Ven({We8wc!{E;l$PmfU&QQV-!cfLg$8hL>
zHp66w3Wg~RQyFR*rZG4(%x754u$o~KLjgkr!yJYpu)jf95rP>E3=HZp1`gVX!Ji=l
zY)dHvF9RC`7x-deUT~Y9nSqNznt_*rmq8T8m7)x43@i*13@Qw&4C-K&pdP?faO)k!
z0)?A8n3u_r#ZU`v=PQES_`D4547?2N3~UVi3{x0{88{iHG4L|<Gw?9*FmN&OGO#er
z2iqvgAjB|>ftO((nr;pT76ujub_Q++35Hb+91P+N><nTI><l~%><land<-C$^D=NS
zuz_2WIt&~P><sJ-Wek1{@eI8T0id;~|E0hrXn)!N|DY=+aRd!SSVxzEnU{svnw5>6
zmtW72jnl~3M4w04#=+FgoL9)e){NK6k(bMtjf2I-j#pG&L(|vKKOitBJ}o^XD~FfY
z(v`y{h*v!^DLI9Og`1s2LOk1o$KAuri9I+ZG%P$-P99W*=BlVltMSIhB_#O;BnGg1
zvb*tm`&jDnu|$L=fq__Za!Lv-8!MZnw+AZ+8@qi{WOP7WQYMF`w;nqyTT+0fa};|L
z#Kowjwyuu8fu5nEk%_Ufsj0bznWdGLwY80njh(%%qm#3PtDB39ySt}{mxs5vkFTGf
zpTB<q7z70d2Zx4)hebq0MMg))#Ky+OCnO|7KvGgta&mHNN=jNrW_nh3c5V);rARy`
z(B05%pur_(2GF(QY>do|%#0uwIHhqjFt9Q(GBdC;urM<+GBYzVK!zb089@vNW(Fo^
z(9MZVAXye>M#$g<BQuBvQNh5*#KgeB>XMq1T9TQU&fw`65Wo=N805$hq-tQ4!r<rV
z;>h6Q>*}kZn!?}+r9n;5^wc7Tr2PDx)Wkdn28NK#f_#O%!;AA3ic*vF^D<JCGgI>Q
z6oT_}L5+6>b*K(?h5S+lb*MIVg<_C~g4Cki%#zHM{9-)@SHFNDkVQcuU|L5N)*uT@
zEXq8*uq-u4AthBICAGLDGY@KCN@{XWVo_pBB7<X)ucv})3P_V<kZ%-}8Bmm;oSKpe
zatE4@e29MxL80whRFrR}kau_&xDB3?s!)(vba+v2YDrOku|j5Ea(+=!YDvDHf@^U>
zYEfcJz7@!HkY7`iG9f%Y24@eDql-cI`?z|BFnIa~1Ti@Kdb%?>`?`P#UsncaUso{8
zk-^#5(Vc+-VsA-mUP)p}W?3T0cdiiuL9W5Uj{XX%xe5h|#l?x~AVz+XLXfMQYmlp-
zv!^2$L$JTEBSUbgQwW1^s80xki)WZ810s;XF@Xpf=O9-<kb_lI7@UK`V1eWu6y^gL
zbq-NbErz)VZfi=aLUMjyaY<rcNvc8tiWBs>7>X<NN)js|{SdHEimVh;GK-TFi&8*I
z3FNmTD}{pmf&vg1+J;W8$Ve<LE=f&ca0aEF(gI{X3OV`t*@+pciAb_A{S3eM{r?Zb
z_gDY_|8@2M|J-Z-{|9a6IJ*WS4wA!#9oPQ<AFvjpu50c8|9tEI|8H3b;bZ7o_y51p
z28i764gdekZu<XUXA^|)u<8GQe<&MS-{wvK|DW0P|Nr|<|NnDrhNuO}D<ZK$d}8n<
zG(B53|NpPG<^TVATmJu7+=?)}aohj@|F`}B58C8AdpklLWXDb@Uw_B{|E@d!|Bv4B
z|9|0*|Nq-}{Qp09$N&GEcl`f<atB1u{T=`R3+{xlop=8K9|>jW@BIIN`Og3Ut9C==
z&hGyI-*C_W|NHm+|L?OGA_lUnVekL{;rssoF9oGkh2;F)g3O%6l>8zEo5Z3*yF>-m
z6fTA$2JEs)4CM^It^tk=pm7BSP&Y!g*a|Yd07^azd5H=+nRyu?Llktu@}S(xz~ESx
zS)6aB5Q3a>ic)hy{Vj#u#LQxa%#zf+Vg(J=6iraazOXb^AyJ_qGbbZap&-AwxHJ<i
zrKb=C(gP}c6cP(k^Ad{{R8t^Y^&lOZ5YXrXI9moEUYnbgpOas#kXl@Fc%edBVpV1$
zs5k@XwamQC<jlmJ%&NqcL_G#BEZVHV4%ekRU~ow-&dE;(m%t2unPsUt49<xqsp$-!
zpkV~Cr3?%VH43V_h6cq7Ald?jf{DUtBakXC2A9;5#GH)OVg~=xlA?SDU52n=2G6{b
z)XbuM1}A8-?-%Uq$)K9T5D>(mno<oG2B~2P^9f=Ia&=>fRxQ?1EskZ-VW?$LE!I&8
zNGwXs1xGI`H-#a<jUg;CC%=dxC^ap$=<uq%<jh2d0BG3<N)HTfp?)C0fZPvrDa;=!
zU|+#RVKmeqAWaMm3<2P%CnDy+3auEZ9!<Ioo+YWdh<M;)U|^JHwtm3K03L5YQu_bD
z2onRtmh%7qZI~Dsj+FoZ|A&!*VQt0#{~=5a44Pg4|5q?EFqBXD|9=h>1H-b3|Nrj+
z(UboFzr)19P%`EJ|36F&3<swE|1ZPLz)(Ex|9=N&28OKZ|Nkd2Gcf#|{{MdiGXukf
z8UOz;U}j)YnEC(z0cHk<r!)Wmf56PZ&^GJ;e+Cu?hQ8VV|0}RCFci-D|KEXyfnmkm
z|Nj#}^t}K78(0_^uFd=Ze*p^v!<za3{~ussV0b$J|NlEI3=CiA|NsAog@J)>!T<j<
ztPBj|3;zGNVP#-YU-18b3@ZbJ#e)C;Ygic={1^QHKZlipA#=h1|9e;&7@8OS|9^*-
zfnoB3|NsB6GBB(H>1ShL;9vOvzYQA$!=8oz|HrT~Fx*=B|9=e|0|WD-|NrN(F)%1C
z`u`tvoSWC8|Nrl>F)$SG`~UwB8v{er{{R1F*cli!4*dUb!_L5ve&GNA7<LARo&*2?
z*RV4%6dnHme*rrK1NV{t{|~S;Fn~^wd%(`XAbs@ze^7(!&(Z(?6*w3ej-2@a--UyL
z;r`|S|5G>^7+9|S|KGyFz%cd7|Nl!k7#L)){{Mf3gMs16)&KvWa4;}@x%&VA9}Wfv
zm23b1i*Pb9Ou6>|e+(xBeD;j7Du{uxLV!`4hn-^rBSai@^Us0O|Nr$tY19RD&M)M0
zaL|n$D~kXB2W_Zi;1h7;lkno_F6U@qu$QvdGFDLnDHma2V2EL0U??d4{~vT}0Z0sl
zL8FGCV*vxp{{OE5-DKg)C(y>^%**E5%*>o8$ivP7xwsv)V{m2r|No#v>KKsKIIw}$
zfZVo+fq~(2@Bjb$pl$9jHOy*^AO#?K&<$~q`u_h19i0X@gXud+8g!Br!yg6)hC}`T
z|DQwAe-y4Cbk}{s#Q*<&P~@G#@*scMFfuUAne_kvW{}5V_PaJSGc5&M0k$K7k%2*b
z^8f$ek<~E011kWzv4N3+foaPB|KMIY%nYVBxcmY}28O~Z|Nl=%(ccG`KfnmOl;r<^
z@J>s({&u)LDE~%)#ynB<?}5vMrjP$l{r`U<iu???yaE#gL*2Ch|2dGufayP6-hqjM
zA#M8q|DdBU5Mg`^E}sA@8)p3fZ;q^=Sq~hBVE;2QFgSq5R*~hA;%EUA1B1e>|Np^r
zcQF5@f{h1<?*S$T2EAGT|6fCK|5>mC2?hp+2TTkMPiFo9Z;33=zyQ_@Dvuav|Nk$5
zEawi^3YG_zQy*vj{|`#0aKCvV<ZYN47#`t~k6~tDxI7ED`8CW842SXPpTo?+uw~Z&
z|KiB*^F!Fbhnaz4^{oH@rI6(V5%PDK85ox0k^jTYz%U<=`(#)c82a(pZ^Hs9ms64L
zXNmzk02H?|EDQ{%XZ`;Vx>5)peoRZ?@--|B3=y;c{|D`Mgv*D5rNQAphlPP5Z1(^E
zpz&+Cd;&s#4+{fB{A_3+AC@-45b~gMKW_H_{~E~di$}<V>Vq_p`5?!_^fN2SfK-5l
zK=nla_W%F+k<%tK8$9iT>W{b`|Nk#THlJxONITg5pnB!Wj{pDdk>x>bX!--yH_SW#
z|5pWx!R&_wALyED22ef3vGf1`XQ0IwFnLfpd4maV#{pIbhEu!$|DTC$2Gaz%`~y}7
z2IoEh|0^TQM}eimZe(C%U~t>>|NmQLd8Q{|1)wlcU}Inq-uwUmLlpTNV0lm(=)lIn
zaAoiR|0mGhxC`ON6gCEiiUa@uOLH?Yz~hlwh#O=G$c`3J{dgLCIDq7rfb^gK|9>Ki
z8#+MR!G1UbIsowWf6y&m2=kfh;qp(|7#IT2{QtibMgIn{JgA;xVP|0YapwPjHjq3N
zgTz7g^oKM5|AST_FnI6@B=d1FxG*p<n6NW2aGd@BADr&p_yqcyJozO0m|gi4dRbig
zG<sNF_zc?EJoqe{+1>dZ^7t$q`3xNSG@SSpocJW1_ynBzI2b@>4ye92IQ#!UE7Z<W
zYBU5!Ltr!nMnhmU1V%$(Gz3Ou2na)beLx68gPPtT7L4WraX=W<fMQ@^;03W67#MyO
zKp2t`is8Z@2tyh|frd`NEO1|mfq~%$R36m61WCZgD8BytpAY7P4!vanO<sX`pd+9l
zG^~vX8oL6CKt^F17;2#o<OT^cFff4no*<?uh(N+nV;L@hZ**b+b-%%~7eMW22FSPz
zNPrzgFfcHH`+guc)FPPp52%Bo6a%<_&cFbgj035L+YjzrF@RPSfQ3Of{(=3+2o?JG
zAL8E~P=o$M`B3jLe1P)Ppz=SVe3(BVrc#f50F4)P6V0IU?FOa8pmZ9PE`!o-P<k4a
zUIwMNLFr>q`Wlpe2Bp72X*O_YpMgOPN~=L>Gbrr_rNf|f8k8=B(rr+B8kAlJrME%p
zV^I1Ulzs-Kzd>m>Xu3!DKOsH`_~<OiVir)`xjQ>sDQJWymFAU{Dp=~7=o#o5mV$YP
zbw&ny1}1t&nh<e9CNnTFGcYo&fTmAm)yxb`3`ekvGc&xvD$c^dfhFO9W`|+<3DtZy
zh8M65ha|zwz|H_mk4VA{%nTe1uyl+n&dC7FFR0>N3=GhGg(}X?0Pdh63o?Mhfrmi>
znof|Vm>GB(1hB*#GXo!k0#<Q;czK0tjsOD#_y{#*QINfY3^AZX3sHp`m>Gl^9Oj@2
zg54<$FaMBbnHfaj<sPcIC<C^9$IKuGFQ-t|i!(4l(;KR|1cL%raagI0Pz_3>EDRsP
zx4t4o85lt2I}-yRLjYR1@iBnPN<M}LG;z>c7?65ceE~DeoB@;<Bp5uP?g7~cl5+!#
zV}?U6)O-eL{R2`9!l3KL7#T3b6Er@J&HbQpR7M5~h772^&|;HeE7)EMh5|J4lTh&r
zH1V5I@dl_k%>B=x;w?~d7LX$u7#Kc6#XF$lFnd8`+#vT%fQrM^voJ!!X9}7)=padu
z`Wa~Api4*@83Y&<py?Cj4v^KxU~>c*6dFN1up__>OPF{Qm<wO0<Omf{fQr9@NHciC
z#G4@kF!2DGcnd__4H^*PQ1Jucn`jvrVB(<j?LqFJgXaD+uzCrG1yFHV`1FFt-x>HA
z&YD5Y2ai)TFfc5JiXQ{7zF=SgkIyqOFo4cW0j0Og(Djhuxd#RY2GAS=NE~#S5ZENB
zJMTlyX$4<y&cFbk&tPC+_yiT_fK0nGfXAmn!N&wi=S+}|D`0a$=5a#BFMtQa85qEG
z5)2Fs{7~^4V~{Ea2JmI~3=9l%P;oZU#u)|%2Jl!F0|SE|6KJ^&X1)U*yb6k6hi-^D
zT2S|UgBM5&Ff@QprDkAY0FUJ|Ffar`#T|Mf>S5xb!(Bn<F!VvhogoxMGE{v6RJ;u;
zo(mO+1u%Hw5Ca24DO6kmJh8z5URngwQVSJ#01pNt+ygp*7Hsb%kSYd-3<$;0302>K
zCf)}PpE~HqAMhA40|UcM9O1JZhxi&C;-KKeRz7S2yGMxO%wnhmktl5H4}t4ZVT^M7
zGT0o<avL<)%7CT3dJi@SvmOC0zhcBv&RepB(jjI&D8bCYAjH7Oa2|BhIs*d(cwUQv
zfk6i<{sGz!hmC21=14&5twD>h7#QF?vwWfIWuWGO=g=4!7{bBgNPz-nW->D{2r@`8
z9DwFuSUFY*6+eO|4w_3wt17@I%>$dy$B+cgchF`R!wRrCSP2TT7c>`*A_C#ugxU+M
z?_lN0dsfi=C1(Bj7HmErLrWAyKX^`nfq~&CSR5jTOe(QJ!Z`sNZqVe;z{>&&hZRu&
z!t51*s_z2b3D3a503Oc=^&g<>6+j15Gl23w#1?s|`j1fa!6&vdFfeF=)r&KTK+T7R
zvmPtRJrKRfq%PPTWDyA45r=pvSe%dHUL-^vc<zLOfdMp!k1f86!S0b@Fo3!T=3mg+
zj-Yf^3GU4>Fo4JQ85kHQL)D*vs)xCME(@qhC(a-N6^Gc)z_0}Bo&adN1&{SJFfgov
ziZ6qf51P=9;ufg+0Z?;b?lA+!BNJx3ZYS6rm~9C9EDrIPU~xW%`_S|WYi@pp+PeYG
zUeFvCC>+dS?u1(5$c8<>*ue3~#}H}+Q3#$_2Bj0QI7AGY)Wsq0zzRx-;tT>%_rSv0
z6D%&lkboxslpUmAg5d&G92RcjILyz+A>IHM=VNGwh7T<Nc0<J_py2@P_fCe2$3w+o
z>w#xM#iu~cf%UVOgT;|U0K(n{7UyGN0c|-234scD1_p+cQ2*XQ^Vd1BdXPd?{FW7x
z4$<4szo6zkfSLmfPYxXMD8mK`&j_e`Sa^ai>I0<*7HES4+FW1&?O*_juZH>;HV$G1
zHlL5-Tr9+$;CV#QE?lrUL=2e>1&i}B7(vYk&$}})FeI~q$~|P25Oxt%y(83KSbDAp
zxt~d#0oHGYsAgd30jr1c5cDFjI3GhXnmKF1;s|vx)&a0MAHxf1dHW1p|1mI}0@(}d
z+(Fy1uyDQ!RsRUIxCJy`0*&9dVD%CVPoUupQ~w359%dVY=76Si6}0kJfE|<{`54OM
zA!@<%si1ZmRQwGzKSG;34Ej*<257kiYrok;&3}RB9v`rJh}p<w0uJ#Ks5u{?=D^ZV
zHCR0#!z)vWDd2S-p!O{jDBVghI6(ack!4`$gPOAgY7Q)XK7-RgqW=qCL&U(qFcoTk
zL;}PF@Vqet1H%%qI7AGY+{q5H7rop*3Rcg@a6ST}8azkOz`$?{Dt;Im@8G$0(0CtI
zoD<r=1Ft<|U|_fh6<0`xm;;`p2HgY%^_KzEzp!-s4l4cw&A-2)<~Tyr52zmqGLf4D
z6z?DwDwYF_^D(4D>ud1*JOcxRG6y7I|3Ncf2P)10bq_3@jlt%inhoN)gT?t60-^Z@
zR!#<h#X%}iaVie+avb87(Dn}tntQrI?qtHOXQxBgb)nkIz_1Z)J|BYvG@ZkSdqCqj
zpz`WH)cvsX8MLMiBz_bs4lBpbf$U|FVBmnd2bP{MaWF7|7o?$C{0?j{njnbF2?>7z
zs5!83=H>*&BOgOHv_A#w??^(`i=e4jfQman;}PZ_hUB7>;*!#|G`(bol+>cs^i0qe
z+xU{)_~e}YywqZb`1q9k`1G9oq{N)~l#=|S;`qeU3I@=k<($-#)D%4n12aSHisI8U
z^D^VXJB;H~^Gb>;8PbXpb5r9}N^^578RFxSc=4HenI$Mnb5bkxDl7Gp87eEGTQK8`
zOA?c_<4f`jFvM~bE6~M2{EYmZl=$R~#3B$U56mhCF_S?i#)FLk*$WaXE=epZ0WnfC
zQ$Vt5sYUU{<(VbP8S(jf@u~S~Ai2ck<kSMNs#LJMa#KqZLE=e?#i<}VB^9hJuL7(l
zIU^e+n3Gss5)aXtnU@aoL<v|ins{<SKFDoY_Nsyn$xlQ$t0WO(0%%)pK~ZX1W`1cg
z!rYRg%6Pv}pZJoZ#5|CR=(}%0#(_8g#;1a|Lo-xXmV&nTLN@t=Btby}4FWh9692{E
zXosv-*DFa(0>=*6o*ami3KEk+UQbC)gD?s}TgVwID^pU_psbR_q#Tg<lQUA2LBUg8
zk`HoZks(86WswnBX>mzWX>tjYRc?C83?;>S$qe8GpqI=LAMY0A=<6Eq>gN(4&k&EA
zcv2YRT_XJ)eLbB~WgsyeAMfrL8t>`>HNnFrh#}tH$KT1(C*I%9E!Z_AKE%<<$2A`0
zb7=gR<ikQEK0YTiDLFp5xD=eU84zpOLBS99Pf;qwp0uLWR0julA5SOecq2U{JyV9t
z%DmK~qGAT<UYz(8$SU-BP&DM_$LHiHCxW)!qiX_1a(-zELvcw_UUESts&u?(h;KY1
z*M|5ygYs+$IE;%+Qu0enP}OJV78GUXrh+yKfDFViFRg%~D77TBD3PHkH77ASF(2gG
zRM7T>j6{aK9ELP-l0h@GII*Mz&0XoKMTyS&DVgc{3~8Vf4p4Ozm!xFop$g^Z7nc+z
zLPIgHG#7MWL1HdLd}>M}IE#VpWvHwyNGt+pwah$_`*Tv!jERSs5TBfp9S_=`j<Cdp
zp|TPblqso6rRfZnl_ja*Oj?whm;>4iP+1v|vZ<V*IIo~6Gp{5KVFD-)(+WyUicy6s
zD|0gQQuFdb2?liPKs>~T+|=CSRJ70sM`0qGAjDZv=fE5TN<9pfmBpzg@lex2HYcOo
z4Bc=J-q#O4!hr#rLcwV;J~t6PnB(I?;Ry<)q7qQlf;NT4=Yh9C6qghw=N6#b07`k4
zl@NQ1ONv0dk|55?%wtF@Ely5kNW&IRFfB=-z3>e2@#(qwc@SIUK{*Q)5m0}{$EOtM
z$7dwwrR1bCB<G|i7Nr&yp}PXCJ~c0$AvZM_CCwU|Fl6QxrxvBgmlQL^d-}(NlU95w
z=zxRDO3<kS(5wrx99(FEYlF1RoYcI0R9lKO!JAbW5=%<KyHesyG7G?wngZJBmkKop
z7Qmn)08~ygB$gD#XXd43f;PJ`<bvZ5)!ekSoYLY9RI!}+)ST2@P;$;MfEo;UU=GNi
zi7A=MnfZC(b2}1qL5GBZQYoq-@$pH;;9|e1gaH)O$fZ#Us7%dCtzdxWtCC`dlKkw{
zJO*%F$LFM0WF~_>2X-9P2@GlZ1?U;7B)=e^0hAxh5{tlQmL=wZa$Yj_WDLrd*wRC4
zMJ8IZPXnKLg6^XbUuRgM4l3DTtr3)Rt+KMbC=pb5gK`HXvq6$1D6JOdmoUV~Cs!nb
z3TRL~q7}mFsU>K+s4OujKEE`+2wZjNq*j2+<&vWON`|8RlK9LNhT@VGj1<YBS6rD}
zl9<GxS6osAp)+7C(7w&00tUUj{E}3?^t@8Nq|(fs6y3}esF0(Rr*27NIs;fPBe6Jx
zK`*5;uedT7LYEXlWXe*DiZk=`P&n~L40@n)8KeQqD#$5e&;ut#y@H$)z4ZJN20d_D
zq6cbwG3XWLgEBmWUTOxkwUv=lgy2E6LYiF+U>z_v^cW8YJ&5+C;$jB9<osOFo={Mm
zlnNNM4g%Drg?5AC^SQ8jUFh%@+$NA(I0w`(VPIeYtv!J0ht2!KXz26?Tnnt-3=;rN
zuORD(%@4z9&{|@cS`dw{AGGfF+yDRhF#BQi$S@k(?P7q9JHy-CAj23K7(kn|Kx;E#
z`eF0UFd8)e3sMT|e}McB(+^w65eA-D1&xV=R3X-bz~-l6>pvi}pt&^|3qpgsd7!lw
zF#BQi*DxC7K9EY7`(f%}bT$L{T4uQaLH#3;dKe8mXae2+AT=Od1s(f^nFpH>htaV0
zBQX2X{STUc1I39G$S@Fw&6`7M*!mTaelgJa2}ljnIvCKj4=7wg?gLA~I@C}als>`Y
zPy%EZlnJIlw{;=wht0#oXz*Snuu2F4H5N3|0~VM9np<OF04;Y1^I`M#FdF7xuq2ZE
zVd8Vq^uy-$Vf0l{1j95lfW|D4IH37NH2tvkN-!F>jtQm<-Ty10`eE@0Unc+^$BKq^
zgrNqY=O@rTl%Vi~>4&W+fYDDtl2E-M3f=zwX!gU_9l+=bpv(=@2*t2)gK`-_^W300
zeAx02*!rvsYalAn)x-EO`YLFy6PgD>I$-O!ZV;&-G~NbEdocT9>m43I^~2H+NDat*
zn7y!c1e)&$1rbdD1?c*%3+q6t85j&ek`N}Cgz1OTp!sZ&5}1Al=(qp__zFD4dNHtO
zr1S^lgKoM5nFZ4in|G3c>Q?|64pYp4ITrgB8h_B~Hn>Wder>o2gaI=SnTDkuhzbbl
z0kuB^I<5xF$Kgoshn1h4NO1?z2_ZK?FYhn`DS!xpNtnH04g+XR2DA<a#zW9gz*l-Q
MF#JOZfm!JK0iZb5ivR!s
diff --git a/compilador.o b/compilador.o
deleted file mode 100644
index 5d54ba2ec447c88f824aa9d112807c77cff6b70d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 2736
zcmb<-^>JfjWMqH=Mg}_u1P><4z+k|RU^{@B4h(z@ybPcD<$i^FbUyWHek0(~S^LAI
zv-E>UH!DbmN9%!7DUV)LFuT_lM7;nJ9-R>B=Gq?&r3Ns?-Ju^~YCDhb0I7p0hMLuR
z9L#-f1Xu6-!J|9$2N8NEoIH%~%5G7R1qh?C8ngfZ|NsBNwlXj<lr#9c1~@V(fPiW-
z7lUfCm4a%q0vCg8QBl4^UZO%yW?n|3f@+F_t^!D&!QI)}N<kwusWh*oRKZfuM9)Ci
zuoTQQtTQsuGceIJ(u9bEoWj7uz`!8Dz`y_s8h5`?1||lE10XSGuq*?E2$W{53SwZa
z5MY$%Vdt2@$iN`O0Kp*XWgx<pPoRy-nU{@eE)P2gM9u~z&cMK6529i6AT}NhN&_qm
zAOB-h!i+VAFfcGPz+8)}iy7=YR51{b8SGmS3l%dnASE^=DP{%^Bp!mv%)p7@AhDPk
z*pPS-CO-oMgCN7F|Ddo1iNI)a9OCj&aZucV)Wc|1usBRN1KedA3=9lHNZ|vH69xtb
zV`%(>%s|GTIK=&Nh==14kAvC^vkx5C3=9leIMnCj5HG<Y&XAm+TacNPn37-QrkBi6
zoSB=HpOeo}l$w*6oS4s0lAoQL$B<UQke*tU=$xODnV!!O@9yL8<meOc@8%Zl8WJDk
z=;Y%X&ybd109IL)nOBm=kd~HHTAaa<nOjhlnVSmAOAL8A48<iWsYOK$sTG+Z=YWF?
z6h9ya69WSSF9QR^A5iA}|Np--NRWX6lwZK92_~+ECjJkqULPtBiaAhR!ql5V#nH`o
z!66QcACMGCJt)t@Qhp3bkbwc5;suf1nG6*NsYiByHdGws9w8+4Fps0FZ-%M|iG%Fr
zf$}FnX^=U{_D+Y2gVZD2J0B_zQjcsexa5U~C#cMUh0lJddXPDw!V@Nb3P~K~9*`VJ
z=sJkN5)KcM#Kn;Os{j=TnGeEHE(4^lfy6IJ9G1Qr^olEUOA?b9^omQ0Aan+d1xl29
zC8-r940<VvC5a4rNyWtsdPVsVPI7*3Zfaf$gI->KNvfW^U#M<zNn&y~l%Jkgs#j2y
zUyxc<QpunPHYqhDKCLJ*Hx=e2ifE8OL1im?$prJ~Q#8{-YLSJcp<xPB50hH~ibw_q
zh6hj$+zbrhQV3RJN<bB=LB(O|6)Mc23e^YW!)SD29R^5Qhpt}(st{%$Og}o`5Nbat
zE@5gwG)%t%h=YWo#==D`q59F)ML-pT+y_?-RSV)nr5T)%#6aRO+yYYo6M)j_!a)oS
z;Mxh@{T)z+p!kJq1ykt$2bISlrRe%sfCL#B7$U&B5Cpn@P$~pPHG2GaKob-!TtM*;
zsuf}SVet>L2HkG3ZBRiCC=DuCxS(+jl85OBnTa0vAbAatqZk+%DnT4146+Z2%K$2y
Ru<73cbw8}!gXuxn4**=#WG?^!
diff --git a/compilador.tab.c b/compilador.tab.c
deleted file mode 100644
index 3febb65..0000000
--- a/compilador.tab.c
+++ /dev/null
@@ -1,2425 +0,0 @@
-/* A Bison parser, made by GNU Bison 3.5.1. */
-
-/* Bison implementation for Yacc-like parsers in C
-
- Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
- Inc.
-
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-/* As a special exception, you may create a larger work that contains
- part or all of the Bison parser skeleton and distribute that work
- under terms of your choice, so long as that work isn't itself a
- parser generator using the skeleton or a modified version thereof
- as a parser skeleton. Alternatively, if you modify or redistribute
- the parser skeleton itself, you may (at your option) remove this
- special exception, which will cause the skeleton and the resulting
- Bison output files to be licensed under the GNU General Public
- License without this special exception.
-
- This special exception was added by the Free Software Foundation in
- version 2.2 of Bison. */
-
-/* C LALR(1) parser skeleton written by Richard Stallman, by
- simplifying the original so-called "semantic" parser. */
-
-/* All symbols defined below should begin with yy or YY, to avoid
- infringing on user name space. This should be done even for local
- variables, as they might otherwise be expanded by user macros.
- There are some unavoidable exceptions within include files to
- define necessary library symbols; they are noted "INFRINGES ON
- USER NAME SPACE" below. */
-
-/* Undocumented macros, especially those whose name start with YY_,
- are private implementation details. Do not rely on them. */
-
-/* Identify Bison output. */
-#define YYBISON 1
-
-/* Bison version. */
-#define YYBISON_VERSION "3.5.1"
-
-/* Skeleton name. */
-#define YYSKELETON_NAME "yacc.c"
-
-/* Pure parsers. */
-#define YYPURE 0
-
-/* Push parsers. */
-#define YYPUSH 0
-
-/* Pull parsers. */
-#define YYPULL 1
-
-
-
-
-/* First part of user prologue. */
-#line 6 "compilador.y"
-
-#include <stdio.h>
-#include <ctype.h>
-#include <stdlib.h>
-#include <string.h>
-#include "compilador.h"
-#include "ts/ts.h"
-#include "stack/stack.h"
-
-int num_vars;
-int num_param;
-ts_t *ts;
-int nivel_lexico;
-int desloc;
-int destino_nivel;
-int destino_desloc;
-simb_t *l_elem;
-int rot_id;
-custom_stack_t *rot;
-custom_stack_t *proc;
-
-int val_ou_ref;
-int atr_indireto;
-
-
-#line 96 "compilador.tab.c"
-
-# ifndef YY_CAST
-# ifdef __cplusplus
-# define YY_CAST(Type, Val) static_cast<Type> (Val)
-# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
-# else
-# define YY_CAST(Type, Val) ((Type) (Val))
-# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
-# endif
-# endif
-# ifndef YY_NULLPTR
-# if defined __cplusplus
-# if 201103L <= __cplusplus
-# define YY_NULLPTR nullptr
-# else
-# define YY_NULLPTR 0
-# endif
-# else
-# define YY_NULLPTR ((void*)0)
-# endif
-# endif
-
-/* Enabling verbose error messages. */
-#ifdef YYERROR_VERBOSE
-# undef YYERROR_VERBOSE
-# define YYERROR_VERBOSE 1
-#else
-# define YYERROR_VERBOSE 0
-#endif
-
-/* Use api.header.include to #include this header
- instead of duplicating it here. */
-#ifndef YY_YY_COMPILADOR_TAB_H_INCLUDED
-# define YY_YY_COMPILADOR_TAB_H_INCLUDED
-/* Debug traces. */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int yydebug;
-#endif
-
-/* Token type. */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
- enum yytokentype
- {
- PROGRAM = 258,
- ABRE_PARENTESES = 259,
- FECHA_PARENTESES = 260,
- VIRGULA = 261,
- PONTO_E_VIRGULA = 262,
- DOIS_PONTOS = 263,
- PONTO = 264,
- T_BEGIN = 265,
- T_END = 266,
- VAR = 267,
- IDENT = 268,
- ATRIBUICAO = 269,
- LABEL = 270,
- TYPE = 271,
- ARRAY = 272,
- PROCEDURE = 273,
- FUNCTION = 274,
- GOTO = 275,
- IF = 276,
- THEN = 277,
- ELSE = 278,
- WHILE = 279,
- DO = 280,
- OR = 281,
- DIV = 282,
- AND = 283,
- NOT = 284,
- IGUAL = 285,
- DIFERENTE = 286,
- MENOR_IGUAL = 287,
- MAIOR_IGUAL = 288,
- MENOR = 289,
- MAIOR = 290,
- MAIS = 291,
- MENOS = 292,
- ASTERISCO = 293,
- NUMERO = 294,
- READ = 295,
- WRITE = 296,
- LOWER_THAN_ELSE = 297
- };
-#endif
-
-/* Value type. */
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef int YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define YYSTYPE_IS_DECLARED 1
-#endif
-
-
-extern YYSTYPE yylval;
-
-int yyparse (void);
-
-#endif /* !YY_YY_COMPILADOR_TAB_H_INCLUDED */
-
-
-
-#ifdef short
-# undef short
-#endif
-
-/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
- <limits.h> and (if available) <stdint.h> are included
- so that the code can choose integer types of a good width. */
-
-#ifndef __PTRDIFF_MAX__
-# include <limits.h> /* INFRINGES ON USER NAME SPACE */
-# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
-# include <stdint.h> /* INFRINGES ON USER NAME SPACE */
-# define YY_STDINT_H
-# endif
-#endif
-
-/* Narrow types that promote to a signed type and that can represent a
- signed or unsigned integer of at least N bits. In tables they can
- save space and decrease cache pressure. Promoting to a signed type
- helps avoid bugs in integer arithmetic. */
-
-#ifdef __INT_LEAST8_MAX__
-typedef __INT_LEAST8_TYPE__ yytype_int8;
-#elif defined YY_STDINT_H
-typedef int_least8_t yytype_int8;
-#else
-typedef signed char yytype_int8;
-#endif
-
-#ifdef __INT_LEAST16_MAX__
-typedef __INT_LEAST16_TYPE__ yytype_int16;
-#elif defined YY_STDINT_H
-typedef int_least16_t yytype_int16;
-#else
-typedef short yytype_int16;
-#endif
-
-#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
-typedef __UINT_LEAST8_TYPE__ yytype_uint8;
-#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
- && UINT_LEAST8_MAX <= INT_MAX)
-typedef uint_least8_t yytype_uint8;
-#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
-typedef unsigned char yytype_uint8;
-#else
-typedef short yytype_uint8;
-#endif
-
-#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
-typedef __UINT_LEAST16_TYPE__ yytype_uint16;
-#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
- && UINT_LEAST16_MAX <= INT_MAX)
-typedef uint_least16_t yytype_uint16;
-#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
-typedef unsigned short yytype_uint16;
-#else
-typedef int yytype_uint16;
-#endif
-
-#ifndef YYPTRDIFF_T
-# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
-# define YYPTRDIFF_T __PTRDIFF_TYPE__
-# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
-# elif defined PTRDIFF_MAX
-# ifndef ptrdiff_t
-# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-# endif
-# define YYPTRDIFF_T ptrdiff_t
-# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
-# else
-# define YYPTRDIFF_T long
-# define YYPTRDIFF_MAXIMUM LONG_MAX
-# endif
-#endif
-
-#ifndef YYSIZE_T
-# ifdef __SIZE_TYPE__
-# define YYSIZE_T __SIZE_TYPE__
-# elif defined size_t
-# define YYSIZE_T size_t
-# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
-# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-# define YYSIZE_T size_t
-# else
-# define YYSIZE_T unsigned
-# endif
-#endif
-
-#define YYSIZE_MAXIMUM \
- YY_CAST (YYPTRDIFF_T, \
- (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
- ? YYPTRDIFF_MAXIMUM \
- : YY_CAST (YYSIZE_T, -1)))
-
-#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
-
-/* Stored state numbers (used for stacks). */
-typedef yytype_uint8 yy_state_t;
-
-/* State numbers in computations. */
-typedef int yy_state_fast_t;
-
-#ifndef YY_
-# if defined YYENABLE_NLS && YYENABLE_NLS
-# if ENABLE_NLS
-# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
-# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
-# endif
-# endif
-# ifndef YY_
-# define YY_(Msgid) Msgid
-# endif
-#endif
-
-#ifndef YY_ATTRIBUTE_PURE
-# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
-# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
-# else
-# define YY_ATTRIBUTE_PURE
-# endif
-#endif
-
-#ifndef YY_ATTRIBUTE_UNUSED
-# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
-# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
-# else
-# define YY_ATTRIBUTE_UNUSED
-# endif
-#endif
-
-/* Suppress unused-variable warnings by "using" E. */
-#if ! defined lint || defined __GNUC__
-# define YYUSE(E) ((void) (E))
-#else
-# define YYUSE(E) /* empty */
-#endif
-
-#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
-/* Suppress an incorrect diagnostic about yylval being uninitialized. */
-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
- _Pragma ("GCC diagnostic push") \
- _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
- _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
-# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
- _Pragma ("GCC diagnostic pop")
-#else
-# define YY_INITIAL_VALUE(Value) Value
-#endif
-#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-# define YY_IGNORE_MAYBE_UNINITIALIZED_END
-#endif
-#ifndef YY_INITIAL_VALUE
-# define YY_INITIAL_VALUE(Value) /* Nothing. */
-#endif
-
-#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
-# define YY_IGNORE_USELESS_CAST_BEGIN \
- _Pragma ("GCC diagnostic push") \
- _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
-# define YY_IGNORE_USELESS_CAST_END \
- _Pragma ("GCC diagnostic pop")
-#endif
-#ifndef YY_IGNORE_USELESS_CAST_BEGIN
-# define YY_IGNORE_USELESS_CAST_BEGIN
-# define YY_IGNORE_USELESS_CAST_END
-#endif
-
-
-#define YY_ASSERT(E) ((void) (0 && (E)))
-
-#if ! defined yyoverflow || YYERROR_VERBOSE
-
-/* The parser invokes alloca or malloc; define the necessary symbols. */
-
-# ifdef YYSTACK_USE_ALLOCA
-# if YYSTACK_USE_ALLOCA
-# ifdef __GNUC__
-# define YYSTACK_ALLOC __builtin_alloca
-# elif defined __BUILTIN_VA_ARG_INCR
-# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
-# elif defined _AIX
-# define YYSTACK_ALLOC __alloca
-# elif defined _MSC_VER
-# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
-# define alloca _alloca
-# else
-# define YYSTACK_ALLOC alloca
-# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
-# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
- /* Use EXIT_SUCCESS as a witness for stdlib.h. */
-# ifndef EXIT_SUCCESS
-# define EXIT_SUCCESS 0
-# endif
-# endif
-# endif
-# endif
-# endif
-
-# ifdef YYSTACK_ALLOC
- /* Pacify GCC's 'empty if-body' warning. */
-# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
-# ifndef YYSTACK_ALLOC_MAXIMUM
- /* The OS might guarantee only one guard page at the bottom of the stack,
- and a page size can be as small as 4096 bytes. So we cannot safely
- invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
- to allow for a few compiler-allocated temporary stack slots. */
-# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
-# endif
-# else
-# define YYSTACK_ALLOC YYMALLOC
-# define YYSTACK_FREE YYFREE
-# ifndef YYSTACK_ALLOC_MAXIMUM
-# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
-# endif
-# if (defined __cplusplus && ! defined EXIT_SUCCESS \
- && ! ((defined YYMALLOC || defined malloc) \
- && (defined YYFREE || defined free)))
-# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-# ifndef EXIT_SUCCESS
-# define EXIT_SUCCESS 0
-# endif
-# endif
-# ifndef YYMALLOC
-# define YYMALLOC malloc
-# if ! defined malloc && ! defined EXIT_SUCCESS
-void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
-# endif
-# endif
-# ifndef YYFREE
-# define YYFREE free
-# if ! defined free && ! defined EXIT_SUCCESS
-void free (void *); /* INFRINGES ON USER NAME SPACE */
-# endif
-# endif
-# endif
-#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
-
-
-#if (! defined yyoverflow \
- && (! defined __cplusplus \
- || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
-
-/* A type that is properly aligned for any stack member. */
-union yyalloc
-{
- yy_state_t yyss_alloc;
- YYSTYPE yyvs_alloc;
-};
-
-/* The size of the maximum gap between one aligned stack and the next. */
-# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
-
-/* The size of an array large to enough to hold all stacks, each with
- N elements. */
-# define YYSTACK_BYTES(N) \
- ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
- + YYSTACK_GAP_MAXIMUM)
-
-# define YYCOPY_NEEDED 1
-
-/* Relocate STACK from its old location to the new one. The
- local variables YYSIZE and YYSTACKSIZE give the old and new number of
- elements in the stack, and YYPTR gives the new location of the
- stack. Advance YYPTR to a properly aligned location for the next
- stack. */
-# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
- do \
- { \
- YYPTRDIFF_T yynewbytes; \
- YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
- Stack = &yyptr->Stack_alloc; \
- yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
- yyptr += yynewbytes / YYSIZEOF (*yyptr); \
- } \
- while (0)
-
-#endif
-
-#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
-/* Copy COUNT objects from SRC to DST. The source and destination do
- not overlap. */
-# ifndef YYCOPY
-# if defined __GNUC__ && 1 < __GNUC__
-# define YYCOPY(Dst, Src, Count) \
- __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
-# else
-# define YYCOPY(Dst, Src, Count) \
- do \
- { \
- YYPTRDIFF_T yyi; \
- for (yyi = 0; yyi < (Count); yyi++) \
- (Dst)[yyi] = (Src)[yyi]; \
- } \
- while (0)
-# endif
-# endif
-#endif /* !YYCOPY_NEEDED */
-
-/* YYFINAL -- State number of the termination state. */
-#define YYFINAL 3
-/* YYLAST -- Last index in YYTABLE. */
-#define YYLAST 128
-
-/* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS 43
-/* YYNNTS -- Number of nonterminals. */
-#define YYNNTS 67
-/* YYNRULES -- Number of rules. */
-#define YYNRULES 103
-/* YYNSTATES -- Number of states. */
-#define YYNSTATES 173
-
-#define YYUNDEFTOK 2
-#define YYMAXUTOK 297
-
-
-/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
- as returned by yylex, with out-of-bounds checking. */
-#define YYTRANSLATE(YYX) \
- (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
-
-/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
- as returned by yylex. */
-static const yytype_int8 yytranslate[] =
-{
- 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
- 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
- 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
- 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
- 35, 36, 37, 38, 39, 40, 41, 42
-};
-
-#if YYDEBUG
- /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
-static const yytype_int16 yyrline[] =
-{
- 0, 47, 47, 47, 63, 74, 60, 91, 92, 95,
- 99, 99, 100, 103, 104, 108, 111, 108, 119, 132,
- 141, 152, 153, 157, 159, 160, 165, 189, 165, 208,
- 232, 236, 208, 244, 245, 243, 253, 256, 257, 261,
- 260, 270, 270, 278, 279, 282, 292, 295, 296, 297,
- 300, 301, 304, 305, 306, 307, 308, 309, 312, 312,
- 316, 317, 320, 320, 343, 343, 386, 389, 393, 392,
- 405, 405, 419, 422, 423, 426, 435, 438, 441, 446,
- 449, 452, 455, 458, 461, 464, 467, 473, 479, 482,
- 485, 488, 491, 491, 522, 533, 535, 542, 535, 568,
- 575, 577, 580, 580
-};
-#endif
-
-#if YYDEBUG || YYERROR_VERBOSE || 0
-/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
- First, the terminals, then, starting at YYNTOKENS, nonterminals. */
-static const char *const yytname[] =
-{
- "$end", "error", "$undefined", "PROGRAM", "ABRE_PARENTESES",
- "FECHA_PARENTESES", "VIRGULA", "PONTO_E_VIRGULA", "DOIS_PONTOS", "PONTO",
- "T_BEGIN", "T_END", "VAR", "IDENT", "ATRIBUICAO", "LABEL", "TYPE",
- "ARRAY", "PROCEDURE", "FUNCTION", "GOTO", "IF", "THEN", "ELSE", "WHILE",
- "DO", "OR", "DIV", "AND", "NOT", "IGUAL", "DIFERENTE", "MENOR_IGUAL",
- "MAIOR_IGUAL", "MENOR", "MAIOR", "MAIS", "MENOS", "ASTERISCO", "NUMERO",
- "READ", "WRITE", "LOWER_THAN_ELSE", "$accept", "programa", "$@1",
- "bloco", "$@2", "$@3", "parte_declara_rotulos", "parte_declara_vars",
- "var", "$@4", "declara_vars", "declara_var", "$@5", "$@6", "tipo",
- "lista_id_var", "lista_idents", "parte_declara_subrotinas",
- "declaracao_procedimento", "$@7", "$@8", "declaracao_funcao", "$@9",
- "$@10", "$@11", "parametros_ou_nada", "$@12", "$@13",
- "paramentros_formais", "secao_pfs", "$@14", "$@15", "lista_id_pf",
- "parametro", "comando_composto", "comandos", "comando",
- "comando_sem_rotulo", "atribuicao_ou_procedimento", "$@16",
- "atribuicao_ou_procedimento_token", "atribuicao", "$@17",
- "chamada_procedimento", "$@18", "lista_parametros",
- "lista_parametros_parenteses", "$@19", "$@20", "leitura",
- "lista_leituras", "simb_leitura", "escrita", "lista_escritas",
- "expressao", "expressao_simples", "termo", "fator", "$@21", "numero",
- "comando_repetitivo", "$@22", "$@23", "comando_condicional", "cond_else",
- "if_then", "$@24", YY_NULLPTR
-};
-#endif
-
-# ifdef YYPRINT
-/* YYTOKNUM[NUM] -- (External) token number corresponding to the
- (internal) symbol number NUM (which must be that of a token). */
-static const yytype_int16 yytoknum[] =
-{
- 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
- 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
- 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
- 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
- 295, 296, 297
-};
-# endif
-
-#define YYPACT_NINF (-113)
-
-#define yypact_value_is_default(Yyn) \
- ((Yyn) == YYPACT_NINF)
-
-#define YYTABLE_NINF (-97)
-
-#define yytable_value_is_error(Yyn) \
- 0
-
- /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
- STATE-NUM. */
-static const yytype_int8 yypact[] =
-{
- -113, 10, 11, -113, 4, 24, 43, -113, 7, 52,
- 45, 46, -113, 54, 55, 56, -113, -113, -113, -113,
- 57, 44, -113, 53, 59, -113, 58, -113, 61, -113,
- 62, 60, -113, -113, -113, 1, 68, -113, 5, -113,
- 66, 74, -113, 80, 68, -113, -7, -113, 85, 86,
- -113, 81, 84, -113, -113, -113, -113, 87, -113, 69,
- -113, 73, -113, -113, -113, 88, -113, 90, 89, -113,
- -113, 20, -6, -11, -113, 91, -7, -113, 5, -2,
- -7, -2, -113, 92, -113, 94, -113, 93, 74, 46,
- -113, -113, 95, -113, 98, -113, -7, -7, -7, -7,
- -7, -7, 76, -7, -7, -7, -7, -113, 28, -113,
- 30, -6, -113, -113, 51, -113, -113, 93, 88, 100,
- -113, 99, 102, 103, -113, -7, -113, -113, -113, -6,
- -6, -6, -6, -6, -6, -2, -11, -11, -113, -113,
- -113, 91, -113, -7, -113, 104, -113, -113, 74, 93,
- 46, 106, -6, 35, -7, -113, -113, -6, -2, 74,
- -113, -113, -113, -113, -113, -113, -6, -113, -113, 107,
- -7, -113, -6
-};
-
- /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
- Performed when YYTABLE does not specify something else to do. Zero
- means the default is an error. */
-static const yytype_int8 yydefact[] =
-{
- 2, 0, 0, 1, 0, 0, 0, 22, 0, 0,
- 0, 8, 21, 0, 0, 12, 7, 3, 4, 9,
- 0, 25, 15, 0, 5, 24, 11, 14, 0, 29,
- 0, 0, 23, 13, 20, 0, 36, 26, 49, 6,
- 0, 0, 33, 0, 36, 58, 0, 95, 0, 0,
- 53, 0, 0, 51, 52, 56, 57, 0, 55, 0,
- 54, 101, 19, 18, 16, 41, 30, 0, 64, 92,
- 94, 102, 85, 88, 91, 0, 0, 46, 48, 96,
- 0, 96, 99, 0, 39, 34, 37, 0, 0, 8,
- 59, 60, 0, 61, 67, 64, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 75, 0, 74,
- 0, 78, 47, 50, 0, 100, 17, 0, 41, 0,
- 45, 0, 44, 0, 27, 0, 70, 65, 93, 79,
- 80, 82, 84, 81, 83, 96, 86, 87, 90, 89,
- 72, 0, 76, 0, 97, 0, 38, 35, 0, 0,
- 8, 0, 63, 0, 0, 103, 73, 77, 96, 0,
- 42, 43, 31, 28, 66, 68, 71, 98, 40, 0,
- 0, 32, 69
-};
-
- /* YYPGOTO[NTERM-NUM]. */
-static const yytype_int8 yypgoto[] =
-{
- -113, -113, -113, -85, -113, -113, -113, -113, -113, -113,
- -113, 96, -113, -113, -86, -113, -113, -113, -113, -113,
- -113, -113, -113, -113, -113, 67, -113, -113, -113, -3,
- -113, -113, -112, -113, 97, 38, -113, -78, -113, -113,
- -113, -113, -113, 22, -113, -113, -113, -113, -113, -113,
- -113, -23, -113, -113, 39, -76, -61, -58, -113, -113,
- -113, -113, -113, -113, -113, -113, -113
-};
-
- /* YYDEFGOTO[NTERM-NUM]. */
-static const yytype_int16 yydefgoto[] =
-{
- -1, 1, 2, 14, 21, 31, 15, 18, 19, 20,
- 26, 27, 28, 83, 64, 35, 8, 24, 32, 44,
- 151, 25, 36, 88, 169, 43, 65, 119, 85, 86,
- 117, 87, 121, 122, 50, 51, 52, 53, 54, 68,
- 90, 91, 92, 93, 94, 127, 153, 170, 154, 55,
- 108, 109, 56, 110, 71, 72, 73, 74, 95, 57,
- 58, 59, 158, 60, 82, 61, 102
-};
-
- /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
- positive, shift that token. If negative, reduce the rule whose
- number is the opposite. If YYTABLE_NINF, syntax error. */
-static const yytype_int16 yytable[] =
-{
- 111, 113, 123, 115, 124, 145, 69, 40, 38, 41,
- 3, 45, 9, 10, 4, 38, 105, 5, 45, 46,
- 129, 130, 131, 132, 133, 134, 46, 106, 6, -96,
- 103, 104, 70, 140, 141, 142, 143, 161, 48, 49,
- 164, 165, 136, 137, 47, 48, 49, 138, 139, 152,
- 96, 97, 98, 99, 100, 101, 7, 155, 12, 11,
- 16, 13, 160, 23, 17, 162, 29, 157, -10, 22,
- 38, -15, 42, 168, 34, 37, 144, 30, 166, 62,
- 167, 96, 97, 98, 99, 100, 101, 63, 66, 75,
- 76, 78, 77, 80, 172, 79, 81, 89, 135, 116,
- 84, 118, 126, -62, 107, 147, 120, 148, 149, 125,
- 150, 67, 159, 163, 171, 146, 112, 128, 156, 114,
- 0, 0, 33, 0, 0, 0, 0, 0, 39
-};
-
-static const yytype_int16 yycheck[] =
-{
- 76, 79, 88, 81, 89, 117, 13, 6, 10, 8,
- 0, 13, 5, 6, 3, 10, 27, 13, 13, 21,
- 96, 97, 98, 99, 100, 101, 21, 38, 4, 24,
- 36, 37, 39, 5, 6, 5, 6, 149, 40, 41,
- 5, 6, 103, 104, 39, 40, 41, 105, 106, 125,
- 30, 31, 32, 33, 34, 35, 13, 135, 13, 7,
- 6, 15, 148, 19, 9, 150, 13, 143, 12, 12,
- 10, 13, 4, 159, 13, 13, 25, 18, 154, 13,
- 158, 30, 31, 32, 33, 34, 35, 13, 8, 4,
- 4, 7, 11, 24, 170, 8, 23, 7, 22, 7,
- 12, 7, 4, 14, 13, 5, 13, 8, 6, 14,
- 7, 44, 8, 7, 7, 118, 78, 95, 141, 80,
- -1, -1, 26, -1, -1, -1, -1, -1, 31
-};
-
- /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
- symbol of state STATE-NUM. */
-static const yytype_int8 yystos[] =
-{
- 0, 44, 45, 0, 3, 13, 4, 13, 59, 5,
- 6, 7, 13, 15, 46, 49, 6, 9, 50, 51,
- 52, 47, 12, 19, 60, 64, 53, 54, 55, 13,
- 18, 48, 61, 54, 13, 58, 65, 13, 10, 77,
- 6, 8, 4, 68, 62, 13, 21, 39, 40, 41,
- 77, 78, 79, 80, 81, 92, 95, 102, 103, 104,
- 106, 108, 13, 13, 57, 69, 8, 68, 82, 13,
- 39, 97, 98, 99, 100, 4, 4, 11, 7, 8,
- 24, 23, 107, 56, 12, 71, 72, 74, 66, 7,
- 83, 84, 85, 86, 87, 101, 30, 31, 32, 33,
- 34, 35, 109, 36, 37, 27, 38, 13, 93, 94,
- 96, 98, 78, 80, 97, 80, 7, 73, 7, 70,
- 13, 75, 76, 57, 46, 14, 4, 88, 86, 98,
- 98, 98, 98, 98, 98, 22, 99, 99, 100, 100,
- 5, 6, 5, 6, 25, 75, 72, 5, 8, 6,
- 7, 63, 98, 89, 91, 80, 94, 98, 105, 8,
- 57, 75, 46, 7, 5, 6, 98, 80, 57, 67,
- 90, 7, 98
-};
-
- /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
-static const yytype_int8 yyr1[] =
-{
- 0, 43, 45, 44, 47, 48, 46, 49, 49, 50,
- 52, 51, 51, 53, 53, 55, 56, 54, 57, 58,
- 58, 59, 59, 60, 60, 60, 62, 63, 61, 65,
- 66, 67, 64, 69, 70, 68, 68, 71, 71, 73,
- 72, 74, 72, 75, 75, 76, 77, 78, 78, 78,
- 79, 79, 80, 80, 80, 80, 80, 80, 82, 81,
- 83, 83, 85, 84, 87, 86, 88, 88, 90, 89,
- 91, 89, 92, 93, 93, 94, 95, 96, 96, 97,
- 97, 97, 97, 97, 97, 97, 98, 98, 98, 99,
- 99, 99, 101, 100, 100, 102, 104, 105, 103, 106,
- 107, 107, 109, 108
-};
-
- /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
-static const yytype_int8 yyr2[] =
-{
- 0, 2, 0, 9, 0, 0, 6, 2, 0, 1,
- 0, 3, 0, 2, 1, 0, 0, 6, 1, 3,
- 1, 3, 1, 2, 1, 0, 0, 0, 8, 0,
- 0, 0, 11, 0, 0, 5, 0, 1, 3, 0,
- 5, 0, 4, 3, 1, 1, 3, 3, 2, 0,
- 3, 1, 1, 1, 1, 1, 1, 1, 0, 3,
- 1, 1, 0, 3, 0, 2, 3, 0, 0, 4,
- 0, 2, 4, 3, 1, 1, 4, 3, 1, 3,
- 3, 3, 3, 3, 3, 1, 3, 3, 1, 3,
- 3, 1, 0, 3, 1, 1, 0, 0, 6, 2,
- 2, 0, 0, 5
-};
-
-
-#define yyerrok (yyerrstatus = 0)
-#define yyclearin (yychar = YYEMPTY)
-#define YYEMPTY (-2)
-#define YYEOF 0
-
-#define YYACCEPT goto yyacceptlab
-#define YYABORT goto yyabortlab
-#define YYERROR goto yyerrorlab
-
-
-#define YYRECOVERING() (!!yyerrstatus)
-
-#define YYBACKUP(Token, Value) \
- do \
- if (yychar == YYEMPTY) \
- { \
- yychar = (Token); \
- yylval = (Value); \
- YYPOPSTACK (yylen); \
- yystate = *yyssp; \
- goto yybackup; \
- } \
- else \
- { \
- yyerror (YY_("syntax error: cannot back up")); \
- YYERROR; \
- } \
- while (0)
-
-/* Error token number */
-#define YYTERROR 1
-#define YYERRCODE 256
-
-
-
-/* Enable debugging if requested. */
-#if YYDEBUG
-
-# ifndef YYFPRINTF
-# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
-# define YYFPRINTF fprintf
-# endif
-
-# define YYDPRINTF(Args) \
-do { \
- if (yydebug) \
- YYFPRINTF Args; \
-} while (0)
-
-/* This macro is provided for backward compatibility. */
-#ifndef YY_LOCATION_PRINT
-# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
-#endif
-
-
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
-do { \
- if (yydebug) \
- { \
- YYFPRINTF (stderr, "%s ", Title); \
- yy_symbol_print (stderr, \
- Type, Value); \
- YYFPRINTF (stderr, "\n"); \
- } \
-} while (0)
-
-
-/*-----------------------------------.
-| Print this symbol's value on YYO. |
-`-----------------------------------*/
-
-static void
-yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
-{
- FILE *yyoutput = yyo;
- YYUSE (yyoutput);
- if (!yyvaluep)
- return;
-# ifdef YYPRINT
- if (yytype < YYNTOKENS)
- YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
-# endif
- YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
- YYUSE (yytype);
- YY_IGNORE_MAYBE_UNINITIALIZED_END
-}
-
-
-/*---------------------------.
-| Print this symbol on YYO. |
-`---------------------------*/
-
-static void
-yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
-{
- YYFPRINTF (yyo, "%s %s (",
- yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
-
- yy_symbol_value_print (yyo, yytype, yyvaluep);
- YYFPRINTF (yyo, ")");
-}
-
-/*------------------------------------------------------------------.
-| yy_stack_print -- Print the state stack from its BOTTOM up to its |
-| TOP (included). |
-`------------------------------------------------------------------*/
-
-static void
-yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
-{
- YYFPRINTF (stderr, "Stack now");
- for (; yybottom <= yytop; yybottom++)
- {
- int yybot = *yybottom;
- YYFPRINTF (stderr, " %d", yybot);
- }
- YYFPRINTF (stderr, "\n");
-}
-
-# define YY_STACK_PRINT(Bottom, Top) \
-do { \
- if (yydebug) \
- yy_stack_print ((Bottom), (Top)); \
-} while (0)
-
-
-/*------------------------------------------------.
-| Report that the YYRULE is going to be reduced. |
-`------------------------------------------------*/
-
-static void
-yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule)
-{
- int yylno = yyrline[yyrule];
- int yynrhs = yyr2[yyrule];
- int yyi;
- YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
- yyrule - 1, yylno);
- /* The symbols being reduced. */
- for (yyi = 0; yyi < yynrhs; yyi++)
- {
- YYFPRINTF (stderr, " $%d = ", yyi + 1);
- yy_symbol_print (stderr,
- yystos[+yyssp[yyi + 1 - yynrhs]],
- &yyvsp[(yyi + 1) - (yynrhs)]
- );
- YYFPRINTF (stderr, "\n");
- }
-}
-
-# define YY_REDUCE_PRINT(Rule) \
-do { \
- if (yydebug) \
- yy_reduce_print (yyssp, yyvsp, Rule); \
-} while (0)
-
-/* Nonzero means print parse trace. It is left uninitialized so that
- multiple parsers can coexist. */
-int yydebug;
-#else /* !YYDEBUG */
-# define YYDPRINTF(Args)
-# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
-# define YY_STACK_PRINT(Bottom, Top)
-# define YY_REDUCE_PRINT(Rule)
-#endif /* !YYDEBUG */
-
-
-/* YYINITDEPTH -- initial size of the parser's stacks. */
-#ifndef YYINITDEPTH
-# define YYINITDEPTH 200
-#endif
-
-/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
- if the built-in stack extension method is used).
-
- Do not make this value too large; the results are undefined if
- YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
- evaluated with infinite-precision integer arithmetic. */
-
-#ifndef YYMAXDEPTH
-# define YYMAXDEPTH 10000
-#endif
-
-
-#if YYERROR_VERBOSE
-
-# ifndef yystrlen
-# if defined __GLIBC__ && defined _STRING_H
-# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
-# else
-/* Return the length of YYSTR. */
-static YYPTRDIFF_T
-yystrlen (const char *yystr)
-{
- YYPTRDIFF_T yylen;
- for (yylen = 0; yystr[yylen]; yylen++)
- continue;
- return yylen;
-}
-# endif
-# endif
-
-# ifndef yystpcpy
-# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
-# define yystpcpy stpcpy
-# else
-/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
- YYDEST. */
-static char *
-yystpcpy (char *yydest, const char *yysrc)
-{
- char *yyd = yydest;
- const char *yys = yysrc;
-
- while ((*yyd++ = *yys++) != '\0')
- continue;
-
- return yyd - 1;
-}
-# endif
-# endif
-
-# ifndef yytnamerr
-/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
- quotes and backslashes, so that it's suitable for yyerror. The
- heuristic is that double-quoting is unnecessary unless the string
- contains an apostrophe, a comma, or backslash (other than
- backslash-backslash). YYSTR is taken from yytname. If YYRES is
- null, do not copy; instead, return the length of what the result
- would have been. */
-static YYPTRDIFF_T
-yytnamerr (char *yyres, const char *yystr)
-{
- if (*yystr == '"')
- {
- YYPTRDIFF_T yyn = 0;
- char const *yyp = yystr;
-
- for (;;)
- switch (*++yyp)
- {
- case '\'':
- case ',':
- goto do_not_strip_quotes;
-
- case '\\':
- if (*++yyp != '\\')
- goto do_not_strip_quotes;
- else
- goto append;
-
- append:
- default:
- if (yyres)
- yyres[yyn] = *yyp;
- yyn++;
- break;
-
- case '"':
- if (yyres)
- yyres[yyn] = '\0';
- return yyn;
- }
- do_not_strip_quotes: ;
- }
-
- if (yyres)
- return yystpcpy (yyres, yystr) - yyres;
- else
- return yystrlen (yystr);
-}
-# endif
-
-/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
- about the unexpected token YYTOKEN for the state stack whose top is
- YYSSP.
-
- Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
- not large enough to hold the message. In that case, also set
- *YYMSG_ALLOC to the required number of bytes. Return 2 if the
- required number of bytes is too large to store. */
-static int
-yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
- yy_state_t *yyssp, int yytoken)
-{
- enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
- /* Internationalized format string. */
- const char *yyformat = YY_NULLPTR;
- /* Arguments of yyformat: reported tokens (one for the "unexpected",
- one per "expected"). */
- char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
- /* Actual size of YYARG. */
- int yycount = 0;
- /* Cumulated lengths of YYARG. */
- YYPTRDIFF_T yysize = 0;
-
- /* There are many possibilities here to consider:
- - If this state is a consistent state with a default action, then
- the only way this function was invoked is if the default action
- is an error action. In that case, don't check for expected
- tokens because there are none.
- - The only way there can be no lookahead present (in yychar) is if
- this state is a consistent state with a default action. Thus,
- detecting the absence of a lookahead is sufficient to determine
- that there is no unexpected or expected token to report. In that
- case, just report a simple "syntax error".
- - Don't assume there isn't a lookahead just because this state is a
- consistent state with a default action. There might have been a
- previous inconsistent state, consistent state with a non-default
- action, or user semantic action that manipulated yychar.
- - Of course, the expected token list depends on states to have
- correct lookahead information, and it depends on the parser not
- to perform extra reductions after fetching a lookahead from the
- scanner and before detecting a syntax error. Thus, state merging
- (from LALR or IELR) and default reductions corrupt the expected
- token list. However, the list is correct for canonical LR with
- one exception: it will still contain any token that will not be
- accepted due to an error action in a later state.
- */
- if (yytoken != YYEMPTY)
- {
- int yyn = yypact[+*yyssp];
- YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
- yysize = yysize0;
- yyarg[yycount++] = yytname[yytoken];
- if (!yypact_value_is_default (yyn))
- {
- /* Start YYX at -YYN if negative to avoid negative indexes in
- YYCHECK. In other words, skip the first -YYN actions for
- this state because they are default actions. */
- int yyxbegin = yyn < 0 ? -yyn : 0;
- /* Stay within bounds of both yycheck and yytname. */
- int yychecklim = YYLAST - yyn + 1;
- int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
- int yyx;
-
- for (yyx = yyxbegin; yyx < yyxend; ++yyx)
- if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
- && !yytable_value_is_error (yytable[yyx + yyn]))
- {
- if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
- {
- yycount = 1;
- yysize = yysize0;
- break;
- }
- yyarg[yycount++] = yytname[yyx];
- {
- YYPTRDIFF_T yysize1
- = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
- if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
- yysize = yysize1;
- else
- return 2;
- }
- }
- }
- }
-
- switch (yycount)
- {
-# define YYCASE_(N, S) \
- case N: \
- yyformat = S; \
- break
- default: /* Avoid compiler warnings. */
- YYCASE_(0, YY_("syntax error"));
- YYCASE_(1, YY_("syntax error, unexpected %s"));
- YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
- YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
- YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
- YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
-# undef YYCASE_
- }
-
- {
- /* Don't count the "%s"s in the final size, but reserve room for
- the terminator. */
- YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
- if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
- yysize = yysize1;
- else
- return 2;
- }
-
- if (*yymsg_alloc < yysize)
- {
- *yymsg_alloc = 2 * yysize;
- if (! (yysize <= *yymsg_alloc
- && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
- *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
- return 1;
- }
-
- /* Avoid sprintf, as that infringes on the user's name space.
- Don't have undefined behavior even if the translation
- produced a string with the wrong number of "%s"s. */
- {
- char *yyp = *yymsg;
- int yyi = 0;
- while ((*yyp = *yyformat) != '\0')
- if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
- {
- yyp += yytnamerr (yyp, yyarg[yyi++]);
- yyformat += 2;
- }
- else
- {
- ++yyp;
- ++yyformat;
- }
- }
- return 0;
-}
-#endif /* YYERROR_VERBOSE */
-
-/*-----------------------------------------------.
-| Release the memory associated to this symbol. |
-`-----------------------------------------------*/
-
-static void
-yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
-{
- YYUSE (yyvaluep);
- if (!yymsg)
- yymsg = "Deleting";
- YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
-
- YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
- YYUSE (yytype);
- YY_IGNORE_MAYBE_UNINITIALIZED_END
-}
-
-
-
-
-/* The lookahead symbol. */
-int yychar;
-
-/* The semantic value of the lookahead symbol. */
-YYSTYPE yylval;
-/* Number of syntax errors so far. */
-int yynerrs;
-
-
-/*----------.
-| yyparse. |
-`----------*/
-
-int
-yyparse (void)
-{
- yy_state_fast_t yystate;
- /* Number of tokens to shift before error messages enabled. */
- int yyerrstatus;
-
- /* The stacks and their tools:
- 'yyss': related to states.
- 'yyvs': related to semantic values.
-
- Refer to the stacks through separate pointers, to allow yyoverflow
- to reallocate them elsewhere. */
-
- /* The state stack. */
- yy_state_t yyssa[YYINITDEPTH];
- yy_state_t *yyss;
- yy_state_t *yyssp;
-
- /* The semantic value stack. */
- YYSTYPE yyvsa[YYINITDEPTH];
- YYSTYPE *yyvs;
- YYSTYPE *yyvsp;
-
- YYPTRDIFF_T yystacksize;
-
- int yyn;
- int yyresult;
- /* Lookahead token as an internal (translated) token number. */
- int yytoken = 0;
- /* The variables used to return semantic value and location from the
- action routines. */
- YYSTYPE yyval;
-
-#if YYERROR_VERBOSE
- /* Buffer for error messages, and its allocated size. */
- char yymsgbuf[128];
- char *yymsg = yymsgbuf;
- YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
-#endif
-
-#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
-
- /* The number of symbols on the RHS of the reduced rule.
- Keep to zero when no symbol should be popped. */
- int yylen = 0;
-
- yyssp = yyss = yyssa;
- yyvsp = yyvs = yyvsa;
- yystacksize = YYINITDEPTH;
-
- YYDPRINTF ((stderr, "Starting parse\n"));
-
- yystate = 0;
- yyerrstatus = 0;
- yynerrs = 0;
- yychar = YYEMPTY; /* Cause a token to be read. */
- goto yysetstate;
-
-
-/*------------------------------------------------------------.
-| yynewstate -- push a new state, which is found in yystate. |
-`------------------------------------------------------------*/
-yynewstate:
- /* In all cases, when you get here, the value and location stacks
- have just been pushed. So pushing a state here evens the stacks. */
- yyssp++;
-
-
-/*--------------------------------------------------------------------.
-| yysetstate -- set current state (the top of the stack) to yystate. |
-`--------------------------------------------------------------------*/
-yysetstate:
- YYDPRINTF ((stderr, "Entering state %d\n", yystate));
- YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
- YY_IGNORE_USELESS_CAST_BEGIN
- *yyssp = YY_CAST (yy_state_t, yystate);
- YY_IGNORE_USELESS_CAST_END
-
- if (yyss + yystacksize - 1 <= yyssp)
-#if !defined yyoverflow && !defined YYSTACK_RELOCATE
- goto yyexhaustedlab;
-#else
- {
- /* Get the current used size of the three stacks, in elements. */
- YYPTRDIFF_T yysize = yyssp - yyss + 1;
-
-# if defined yyoverflow
- {
- /* Give user a chance to reallocate the stack. Use copies of
- these so that the &'s don't force the real ones into
- memory. */
- yy_state_t *yyss1 = yyss;
- YYSTYPE *yyvs1 = yyvs;
-
- /* Each stack pointer address is followed by the size of the
- data in use in that stack, in bytes. This used to be a
- conditional around just the two extra args, but that might
- be undefined if yyoverflow is a macro. */
- yyoverflow (YY_("memory exhausted"),
- &yyss1, yysize * YYSIZEOF (*yyssp),
- &yyvs1, yysize * YYSIZEOF (*yyvsp),
- &yystacksize);
- yyss = yyss1;
- yyvs = yyvs1;
- }
-# else /* defined YYSTACK_RELOCATE */
- /* Extend the stack our own way. */
- if (YYMAXDEPTH <= yystacksize)
- goto yyexhaustedlab;
- yystacksize *= 2;
- if (YYMAXDEPTH < yystacksize)
- yystacksize = YYMAXDEPTH;
-
- {
- yy_state_t *yyss1 = yyss;
- union yyalloc *yyptr =
- YY_CAST (union yyalloc *,
- YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
- if (! yyptr)
- goto yyexhaustedlab;
- YYSTACK_RELOCATE (yyss_alloc, yyss);
- YYSTACK_RELOCATE (yyvs_alloc, yyvs);
-# undef YYSTACK_RELOCATE
- if (yyss1 != yyssa)
- YYSTACK_FREE (yyss1);
- }
-# endif
-
- yyssp = yyss + yysize - 1;
- yyvsp = yyvs + yysize - 1;
-
- YY_IGNORE_USELESS_CAST_BEGIN
- YYDPRINTF ((stderr, "Stack size increased to %ld\n",
- YY_CAST (long, yystacksize)));
- YY_IGNORE_USELESS_CAST_END
-
- if (yyss + yystacksize - 1 <= yyssp)
- YYABORT;
- }
-#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
-
- if (yystate == YYFINAL)
- YYACCEPT;
-
- goto yybackup;
-
-
-/*-----------.
-| yybackup. |
-`-----------*/
-yybackup:
- /* Do appropriate processing given the current state. Read a
- lookahead token if we need one and don't already have one. */
-
- /* First try to decide what to do without reference to lookahead token. */
- yyn = yypact[yystate];
- if (yypact_value_is_default (yyn))
- goto yydefault;
-
- /* Not known => get a lookahead token if don't already have one. */
-
- /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
- if (yychar == YYEMPTY)
- {
- YYDPRINTF ((stderr, "Reading a token: "));
- yychar = yylex ();
- }
-
- if (yychar <= YYEOF)
- {
- yychar = yytoken = YYEOF;
- YYDPRINTF ((stderr, "Now at end of input.\n"));
- }
- else
- {
- yytoken = YYTRANSLATE (yychar);
- YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
- }
-
- /* If the proper action on seeing token YYTOKEN is to reduce or to
- detect an error, take that action. */
- yyn += yytoken;
- if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
- goto yydefault;
- yyn = yytable[yyn];
- if (yyn <= 0)
- {
- if (yytable_value_is_error (yyn))
- goto yyerrlab;
- yyn = -yyn;
- goto yyreduce;
- }
-
- /* Count tokens shifted since error; after three, turn off error
- status. */
- if (yyerrstatus)
- yyerrstatus--;
-
- /* Shift the lookahead token. */
- YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
- yystate = yyn;
- YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
- *++yyvsp = yylval;
- YY_IGNORE_MAYBE_UNINITIALIZED_END
-
- /* Discard the shifted token. */
- yychar = YYEMPTY;
- goto yynewstate;
-
-
-/*-----------------------------------------------------------.
-| yydefault -- do the default action for the current state. |
-`-----------------------------------------------------------*/
-yydefault:
- yyn = yydefact[yystate];
- if (yyn == 0)
- goto yyerrlab;
- goto yyreduce;
-
-
-/*-----------------------------.
-| yyreduce -- do a reduction. |
-`-----------------------------*/
-yyreduce:
- /* yyn is the number of a rule to reduce with. */
- yylen = yyr2[yyn];
-
- /* If YYLEN is nonzero, implement the default value of the action:
- '$$ = $1'.
-
- Otherwise, the following line sets YYVAL to garbage.
- This behavior is undocumented and Bison
- users should not rely upon it. Assigning to YYVAL
- unconditionally makes the parser a bit smaller, and it avoids a
- GCC warning that YYVAL may be used uninitialized. */
- yyval = yyvsp[1-yylen];
-
-
- YY_REDUCE_PRINT (yyn);
- switch (yyn)
- {
- case 2:
-#line 47 "compilador.y"
- {
- geraCodigo (NULL, "INPP");
- }
-#line 1495 "compilador.tab.c"
- break;
-
- case 3:
-#line 53 "compilador.y"
- {
- geraCodigo (NULL, "PARA");
- }
-#line 1503 "compilador.tab.c"
- break;
-
- case 4:
-#line 63 "compilador.y"
- {
- char r_main[4];
- sprintf(r_main, "R%02d", rot_id);
- empilha(r_main, rot);
- rot_id += 1;
- char buffer[50];
- strcpy(buffer,"DSVS ");
- strcat(buffer,r_main);
- geraCodigo(NULL,buffer);
- }
-#line 1518 "compilador.tab.c"
- break;
-
- case 5:
-#line 74 "compilador.y"
- {
- char r_main[4];
- desempilha(r_main,rot);
- geraCodigo(r_main,"NADA");
- }
-#line 1528 "compilador.tab.c"
- break;
-
- case 6:
-#line 80 "compilador.y"
- {
- char buffer[50];
- sprintf(buffer,"DMEM %d",desloc);
- desloc = retira(desloc,ts);
- geraCodigo(NULL,buffer);
- if (nivel_lexico > 0)
- nivel_lexico += 1;
- }
-#line 1541 "compilador.tab.c"
- break;
-
- case 10:
-#line 99 "compilador.y"
- { }
-#line 1547 "compilador.tab.c"
- break;
-
- case 15:
-#line 108 "compilador.y"
- { num_vars = 0; }
-#line 1553 "compilador.tab.c"
- break;
-
- case 16:
-#line 111 "compilador.y"
- {
- char buffer[50];
- sprintf(buffer, "AMEM %d", num_vars);
- geraCodigo(NULL, buffer);
- }
-#line 1563 "compilador.tab.c"
- break;
-
- case 18:
-#line 120 "compilador.y"
- {
- if (strcmp(token, "integer") == 0) {
- atualiza_tipo(num_vars, INTEIRO, ts);
- } else if (strcmp(token, "boolean") == 0) {
- atualiza_tipo(num_vars, BOOLEAN, ts);
- } else {
- yyerror("Tipo não reconhecido. Somente 'integer' ou 'boolean' são permitidos.");
- }
- mostra_ts(ts); // Mostra a tabela após a inserção
- }
-#line 1578 "compilador.tab.c"
- break;
-
- case 19:
-#line 133 "compilador.y"
- { /* insere �ltima vars na tabela de s�mbolos */
- num_vars += 1;
- info_t info;
- info.vs.tipo = NSEI;
- info.vs.desloc = desloc;
- insere_ts(token,VS,nivel_lexico,info,ts);
- desloc += 1;
- }
-#line 1591 "compilador.tab.c"
- break;
-
- case 20:
-#line 141 "compilador.y"
- {
- num_vars += 1;
- info_t info;
- info.vs.tipo = NSEI;
- info.vs.desloc = desloc;
- insere_ts(token,VS,nivel_lexico,info,ts);
- desloc += 1;
- /* insere vars na tabela de s�mbolos */
- }
-#line 1605 "compilador.tab.c"
- break;
-
- case 26:
-#line 165 "compilador.y"
- {
- // Insere o procedimento na tabela de símbolos
- info_t info;
- char r_proc[4];
- sprintf(r_proc, "R%02d", rot_id);
- rot_id += 1;
- strcpy(info.pr.rot,r_proc);
- info.pr.quant = 0;
- info.pr.param = NULL;
-
- // Incrementa o nível léxico
- nivel_lexico += 1;
- desloc = 0; // Reinicia deslocamento para variáveis locais do novo nível
-
- insere_ts(token, PR, nivel_lexico, info, ts);
- empilha(token,proc);
-
- char buffer[50];
- sprintf(buffer,"ENPR %d",nivel_lexico);
- geraCodigo(r_proc,buffer);
- mostra_ts(ts);
- }
-#line 1632 "compilador.tab.c"
- break;
-
- case 27:
-#line 189 "compilador.y"
- {
- char buffer[50];
- desempilha(buffer,proc);
- l_elem = busca(buffer,ts);
- int n;
- if(l_elem->categ == PR)
- n = l_elem->info.pr.quant;
- else if (l_elem->categ == FUN)
- n = l_elem->info.pr.quant;
- sprintf(buffer,"RTPR %d,%d",l_elem->nivel,n);
- geraCodigo(NULL,buffer);
- desloc = retira(n,ts);
- mostra_ts(ts);
- }
-#line 1651 "compilador.tab.c"
- break;
-
- case 29:
-#line 208 "compilador.y"
- {
- // Insere o funcao na tabela de símbolos
- info_t info;
- char r_func[4];
- sprintf(r_func, "R%02d", rot_id);
- rot_id += 1;
- strcpy(info.fun.rot,r_func);
- info.fun.quant = 0;
- info.fun.param = NULL;
- info.fun.tipo = NSEI;
-
- // Incrementa o nível léxico
- nivel_lexico += 1;
- desloc = 0; // Reinicia deslocamento para variáveis locais do novo nível
-
- insere_ts(token, FUN, nivel_lexico, info, ts);
- empilha(token,proc);
-
- char buffer[50];
- sprintf(buffer,"ENPR %d",nivel_lexico);
- geraCodigo(r_func,buffer);
- mostra_ts(ts);
- }
-#line 1679 "compilador.tab.c"
- break;
-
- case 30:
-#line 232 "compilador.y"
- {
- num_vars = 1;
- }
-#line 1687 "compilador.tab.c"
- break;
-
- case 31:
-#line 236 "compilador.y"
- {
- // Retorna ao nível léxico anterior e mantém o deslocamento atualizado
- nivel_lexico -= 1;
- }
-#line 1696 "compilador.tab.c"
- break;
-
- case 33:
-#line 244 "compilador.y"
- {num_param = 0;}
-#line 1702 "compilador.tab.c"
- break;
-
- case 34:
-#line 245 "compilador.y"
- {
- char proc_ident[50];
- desempilha(proc_ident,proc);
- adiciona_param(proc_ident,num_param,ts);
- empilha(proc_ident,proc);
- mostra_ts(ts);
- }
-#line 1714 "compilador.tab.c"
- break;
-
- case 39:
-#line 261 "compilador.y"
- {
- num_vars = 0;
- val_ou_ref = REF;
- }
-#line 1723 "compilador.tab.c"
- break;
-
- case 40:
-#line 266 "compilador.y"
- {
- num_param += num_vars;
- val_ou_ref = VLR;
- }
-#line 1732 "compilador.tab.c"
- break;
-
- case 41:
-#line 270 "compilador.y"
- {
- num_vars = 0;
- val_ou_ref = VLR;
- }
-#line 1741 "compilador.tab.c"
- break;
-
- case 42:
-#line 275 "compilador.y"
- {num_param += num_vars;}
-#line 1747 "compilador.tab.c"
- break;
-
- case 45:
-#line 282 "compilador.y"
- {
- num_vars += 1;
- info_t info;
- info.pf.tipo = NSEI;
- info.pf.desloc = NSEI;
- info.pf.passagem = val_ou_ref;
- insere_ts(token,PF,nivel_lexico,info,ts);
- }
-#line 1760 "compilador.tab.c"
- break;
-
- case 58:
-#line 312 "compilador.y"
- {l_elem = busca(token, ts);}
-#line 1766 "compilador.tab.c"
- break;
-
- case 62:
-#line 320 "compilador.y"
- {
- if (l_elem == NULL) {
- yyerror("Variável de destino não declarada");
- } else {
- if (l_elem->categ == PF && l_elem->info.pf.passagem == REF)
- atr_indireto = REF;
- else atr_indireto = VLR;
- destino_nivel = l_elem->nivel;
- destino_desloc = l_elem->info.vs.desloc;
- }
-}
-#line 1782 "compilador.tab.c"
- break;
-
- case 63:
-#line 330 "compilador.y"
- {
- // Gera código ARMZ para armazenar valor
- char buffer[50];
- if (atr_indireto == REF) {
- sprintf(buffer, "ARMI %d,%d", destino_nivel, destino_desloc);
- } else {
- sprintf(buffer, "ARMZ %d,%d", destino_nivel, destino_desloc);
- }
- geraCodigo(NULL, buffer);
-}
-#line 1797 "compilador.tab.c"
- break;
-
- case 64:
-#line 343 "compilador.y"
- {
- if (l_elem == NULL){
- yyerror("Procedimento não declarado");
- } else if (l_elem->categ == PR || l_elem->categ == FUN) {
- // Gera código para chamar o procedimento
- empilha(l_elem->ident, proc);
- }
- if (l_elem->categ == FUN)
- geraCodigo(NULL, "AMEM 1");
- num_param = 0; // Reinicia a contagem de parâmetros reais
- }
-#line 1813 "compilador.tab.c"
- break;
-
- case 65:
-#line 357 "compilador.y"
- {
- if (l_elem->categ == PR || l_elem->categ ==FUN) {
- char buffer[50];
- mostra_ts(ts);
- desempilha(buffer, proc);
- l_elem = busca(buffer, ts);
-
- // Verifica se o número de parâmetros reais bate com os formais
- if (num_param != l_elem->info.pr.quant) {
- char error_msg[100];
- if(l_elem->categ == PR){
- sprintf(error_msg, "Erro: número de parâmetros incorreto. Esperado: %d, recebido: %d.",
- l_elem->info.pr.quant, num_param);
- yyerror(error_msg);
- } else if(l_elem->categ == FUN){
- sprintf(error_msg, "Erro: número de parâmetros incorreto. Esperado: %d, recebido: %d.",
- l_elem->info.fun.quant, num_param);
- yyerror(error_msg);
- }
- }
-
- // Gera o código de chamada do procedimento
-
- sprintf(buffer, "CHPR %s,%d", l_elem->info.pr.rot, nivel_lexico);
- geraCodigo(NULL, buffer);
- }
- }
-#line 1845 "compilador.tab.c"
- break;
-
- case 68:
-#line 393 "compilador.y"
- {
- char buffer[50];
- desempilha(buffer,proc);
- l_elem = busca(buffer,ts);
- val_ou_ref = l_elem->info.pr.param[num_param][1];
- empilha(buffer,proc);
- }
-#line 1857 "compilador.tab.c"
- break;
-
- case 69:
-#line 401 "compilador.y"
- {
- num_param++; // Incrementa para cada parâmetro real
- val_ou_ref = VLR;
- }
-#line 1866 "compilador.tab.c"
- break;
-
- case 70:
-#line 405 "compilador.y"
- {
- char buffer[50];
- desempilha(buffer,proc);
- l_elem = busca(buffer,ts);
- val_ou_ref = l_elem->info.pr.param[num_param][1];
- empilha(buffer,proc);
- }
-#line 1878 "compilador.tab.c"
- break;
-
- case 71:
-#line 413 "compilador.y"
- {
- num_param++; // Conta o primeiro parâmetro real
- val_ou_ref = VLR;
- }
-#line 1887 "compilador.tab.c"
- break;
-
- case 75:
-#line 426 "compilador.y"
- {
- geraCodigo(NULL, "LEIT");
- l_elem = busca(token,ts);
- char buffer[50];
- sprintf(buffer,"ARMZ %d,%d",l_elem->nivel,l_elem->info.vs.desloc);
- geraCodigo(NULL,buffer);
- }
-#line 1899 "compilador.tab.c"
- break;
-
- case 77:
-#line 438 "compilador.y"
- {
- geraCodigo(NULL,"IMPR");
- }
-#line 1907 "compilador.tab.c"
- break;
-
- case 78:
-#line 441 "compilador.y"
- {
- geraCodigo(NULL,"IMPR");
- }
-#line 1915 "compilador.tab.c"
- break;
-
- case 79:
-#line 446 "compilador.y"
- {
- geraCodigo(NULL, "CMIG"); // Adiciona operação de cmig
- }
-#line 1923 "compilador.tab.c"
- break;
-
- case 80:
-#line 449 "compilador.y"
- {
- geraCodigo(NULL, "CMDG"); // Adiciona operação de cmdg
- }
-#line 1931 "compilador.tab.c"
- break;
-
- case 81:
-#line 452 "compilador.y"
- {
- geraCodigo(NULL, "CMME"); // Adiciona operação de cmme
- }
-#line 1939 "compilador.tab.c"
- break;
-
- case 82:
-#line 455 "compilador.y"
- {
- geraCodigo(NULL, "CMEG"); // Adiciona operação de cmeg
- }
-#line 1947 "compilador.tab.c"
- break;
-
- case 83:
-#line 458 "compilador.y"
- {
- geraCodigo(NULL, "CMMA"); // Adiciona operação de cmma
- }
-#line 1955 "compilador.tab.c"
- break;
-
- case 84:
-#line 461 "compilador.y"
- {
- geraCodigo(NULL, "CMAG"); // Adiciona operação de cmag
- }
-#line 1963 "compilador.tab.c"
- break;
-
- case 86:
-#line 467 "compilador.y"
- {
- if (val_ou_ref == REF)
- yyerror("Erro: tentativa de EXPRESSAO em passagem por REFERENCIA\n");
- else
- geraCodigo(NULL, "SOMA"); // Adiciona operação de soma
- }
-#line 1974 "compilador.tab.c"
- break;
-
- case 87:
-#line 473 "compilador.y"
- {
- if (val_ou_ref == REF)
- yyerror("Erro: tentativa de EXPRESSAO em passagem por REFERENCIA\n");
- else
- geraCodigo(NULL, "SUBT"); // Adiciona operação de subt
- }
-#line 1985 "compilador.tab.c"
- break;
-
- case 89:
-#line 482 "compilador.y"
- {
- geraCodigo(NULL, "MULT"); // Adiciona operação de mult
- }
-#line 1993 "compilador.tab.c"
- break;
-
- case 90:
-#line 485 "compilador.y"
- {
- geraCodigo(NULL, "DIVI"); // Adiciona operação de divi
- }
-#line 2001 "compilador.tab.c"
- break;
-
- case 92:
-#line 491 "compilador.y"
- {
- // Carrega variável
- l_elem = busca(token, ts);
- empilha(token, proc);
- }
-#line 2011 "compilador.tab.c"
- break;
-
- case 93:
-#line 497 "compilador.y"
- {
- char buffer[50];
- desempilha(buffer, proc);
- l_elem = busca(buffer, ts);
- if (l_elem == NULL) {
- yyerror("Variável não declarada");
- } else {
- if (val_ou_ref == REF) {
- if (l_elem->categ == VS)
- sprintf(buffer, "CREN %d,%d", l_elem->nivel, l_elem->info.vs.desloc);
- else if (l_elem->categ == FUN)
- sprintf(buffer, "CREN %d,%d", l_elem->nivel, l_elem->info.fun.desloc);
- }
- else if (l_elem->categ == PF && l_elem->info.pf.passagem == REF) {
- sprintf(buffer, "CRVI %d,%d", l_elem->nivel, l_elem->info.pf.desloc);
- }
- else {
- if (l_elem->categ == VS)
- sprintf(buffer, "CRVL %d,%d", l_elem->nivel, l_elem->info.vs.desloc);
- else if (l_elem->categ == FUN)
- sprintf(buffer, "CRVL %d,%d", l_elem->nivel, l_elem->info.fun.desloc);
- }
- geraCodigo(NULL, buffer);
- }
- }
-#line 2041 "compilador.tab.c"
- break;
-
- case 94:
-#line 522 "compilador.y"
- {
- // Empilha constante
- char buffer[50];
- if (val_ou_ref == VLR)
- sprintf(buffer, "CRCT %s", token);
- else {
- yyerror("Erro: passagem de constante por REFERENCIA.\n");
- }
- geraCodigo(NULL, buffer);
-}
-#line 2056 "compilador.tab.c"
- break;
-
- case 96:
-#line 535 "compilador.y"
- {
- char r_ini[4];
- sprintf(r_ini, "R%02d", rot_id);
- empilha(r_ini, rot);
- rot_id += 1;
- geraCodigo(r_ini,"NADA");
- }
-#line 2068 "compilador.tab.c"
- break;
-
- case 97:
-#line 542 "compilador.y"
- {
- char r_fim[4];
- sprintf(r_fim, "R%02d", rot_id);
- empilha(r_fim, rot);
- rot_id += 1;
- char buffer[50];
- strcpy(buffer, "DSVF ");
- strcat(buffer,r_fim);
- geraCodigo(NULL,buffer);
- }
-#line 2083 "compilador.tab.c"
- break;
-
- case 98:
-#line 552 "compilador.y"
- {
- char r_ini[4];
- char r_fim[4];
-
- desempilha(r_fim,rot);
- desempilha(r_ini,rot);
-
- char buffer[50];
- strcpy(buffer,"DSVS ");
- strcat(buffer,r_ini);
- geraCodigo(NULL,buffer);
-
- geraCodigo(r_fim,"NADA");
- }
-#line 2102 "compilador.tab.c"
- break;
-
- case 99:
-#line 568 "compilador.y"
- {
- char r_fim[4];
- desempilha(r_fim,rot);
- geraCodigo(r_fim,"NADA");
- }
-#line 2112 "compilador.tab.c"
- break;
-
- case 102:
-#line 580 "compilador.y"
- {
- char r_else[4];
- sprintf(r_else,"R%02d",rot_id);
- empilha(r_else,rot);
- rot_id += 1;
- char buffer[50];
- strcpy(buffer, "DSVF ");
- strcat(buffer,r_else);
- geraCodigo(NULL,buffer);
-
- char r_fim[4];
- sprintf(r_fim, "R%02d", rot_id);
- empilha(r_fim, rot);
- rot_id += 1;
- }
-#line 2132 "compilador.tab.c"
- break;
-
- case 103:
-#line 595 "compilador.y"
- {
- char r_fim[4];
- desempilha(r_fim,rot);
- char r_else[4];
- desempilha(r_else,rot);
-
- empilha(r_fim,rot);
- char buffer[50];
- strcpy(buffer, "DSVS ");
- strcat(buffer,r_fim);
- geraCodigo(NULL,buffer);
-
- geraCodigo(r_else,"NADA");
- }
-#line 2151 "compilador.tab.c"
- break;
-
-
-#line 2155 "compilador.tab.c"
-
- default: break;
- }
- /* User semantic actions sometimes alter yychar, and that requires
- that yytoken be updated with the new translation. We take the
- approach of translating immediately before every use of yytoken.
- One alternative is translating here after every semantic action,
- but that translation would be missed if the semantic action invokes
- YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
- if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
- incorrect destructor might then be invoked immediately. In the
- case of YYERROR or YYBACKUP, subsequent parser actions might lead
- to an incorrect destructor call or verbose syntax error message
- before the lookahead is translated. */
- YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
-
- YYPOPSTACK (yylen);
- yylen = 0;
- YY_STACK_PRINT (yyss, yyssp);
-
- *++yyvsp = yyval;
-
- /* Now 'shift' the result of the reduction. Determine what state
- that goes to, based on the state we popped back to and the rule
- number reduced by. */
- {
- const int yylhs = yyr1[yyn] - YYNTOKENS;
- const int yyi = yypgoto[yylhs] + *yyssp;
- yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
- ? yytable[yyi]
- : yydefgoto[yylhs]);
- }
-
- goto yynewstate;
-
-
-/*--------------------------------------.
-| yyerrlab -- here on detecting error. |
-`--------------------------------------*/
-yyerrlab:
- /* Make sure we have latest lookahead translation. See comments at
- user semantic actions for why this is necessary. */
- yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
-
- /* If not already recovering from an error, report this error. */
- if (!yyerrstatus)
- {
- ++yynerrs;
-#if ! YYERROR_VERBOSE
- yyerror (YY_("syntax error"));
-#else
-# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
- yyssp, yytoken)
- {
- char const *yymsgp = YY_("syntax error");
- int yysyntax_error_status;
- yysyntax_error_status = YYSYNTAX_ERROR;
- if (yysyntax_error_status == 0)
- yymsgp = yymsg;
- else if (yysyntax_error_status == 1)
- {
- if (yymsg != yymsgbuf)
- YYSTACK_FREE (yymsg);
- yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
- if (!yymsg)
- {
- yymsg = yymsgbuf;
- yymsg_alloc = sizeof yymsgbuf;
- yysyntax_error_status = 2;
- }
- else
- {
- yysyntax_error_status = YYSYNTAX_ERROR;
- yymsgp = yymsg;
- }
- }
- yyerror (yymsgp);
- if (yysyntax_error_status == 2)
- goto yyexhaustedlab;
- }
-# undef YYSYNTAX_ERROR
-#endif
- }
-
-
-
- if (yyerrstatus == 3)
- {
- /* If just tried and failed to reuse lookahead token after an
- error, discard it. */
-
- if (yychar <= YYEOF)
- {
- /* Return failure if at end of input. */
- if (yychar == YYEOF)
- YYABORT;
- }
- else
- {
- yydestruct ("Error: discarding",
- yytoken, &yylval);
- yychar = YYEMPTY;
- }
- }
-
- /* Else will try to reuse lookahead token after shifting the error
- token. */
- goto yyerrlab1;
-
-
-/*---------------------------------------------------.
-| yyerrorlab -- error raised explicitly by YYERROR. |
-`---------------------------------------------------*/
-yyerrorlab:
- /* Pacify compilers when the user code never invokes YYERROR and the
- label yyerrorlab therefore never appears in user code. */
- if (0)
- YYERROR;
-
- /* Do not reclaim the symbols of the rule whose action triggered
- this YYERROR. */
- YYPOPSTACK (yylen);
- yylen = 0;
- YY_STACK_PRINT (yyss, yyssp);
- yystate = *yyssp;
- goto yyerrlab1;
-
-
-/*-------------------------------------------------------------.
-| yyerrlab1 -- common code for both syntax error and YYERROR. |
-`-------------------------------------------------------------*/
-yyerrlab1:
- yyerrstatus = 3; /* Each real token shifted decrements this. */
-
- for (;;)
- {
- yyn = yypact[yystate];
- if (!yypact_value_is_default (yyn))
- {
- yyn += YYTERROR;
- if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
- {
- yyn = yytable[yyn];
- if (0 < yyn)
- break;
- }
- }
-
- /* Pop the current state because it cannot handle the error token. */
- if (yyssp == yyss)
- YYABORT;
-
-
- yydestruct ("Error: popping",
- yystos[yystate], yyvsp);
- YYPOPSTACK (1);
- yystate = *yyssp;
- YY_STACK_PRINT (yyss, yyssp);
- }
-
- YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
- *++yyvsp = yylval;
- YY_IGNORE_MAYBE_UNINITIALIZED_END
-
-
- /* Shift the error token. */
- YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
-
- yystate = yyn;
- goto yynewstate;
-
-
-/*-------------------------------------.
-| yyacceptlab -- YYACCEPT comes here. |
-`-------------------------------------*/
-yyacceptlab:
- yyresult = 0;
- goto yyreturn;
-
-
-/*-----------------------------------.
-| yyabortlab -- YYABORT comes here. |
-`-----------------------------------*/
-yyabortlab:
- yyresult = 1;
- goto yyreturn;
-
-
-#if !defined yyoverflow || YYERROR_VERBOSE
-/*-------------------------------------------------.
-| yyexhaustedlab -- memory exhaustion comes here. |
-`-------------------------------------------------*/
-yyexhaustedlab:
- yyerror (YY_("memory exhausted"));
- yyresult = 2;
- /* Fall through. */
-#endif
-
-
-/*-----------------------------------------------------.
-| yyreturn -- parsing is finished, return the result. |
-`-----------------------------------------------------*/
-yyreturn:
- if (yychar != YYEMPTY)
- {
- /* Make sure we have latest lookahead translation. See comments at
- user semantic actions for why this is necessary. */
- yytoken = YYTRANSLATE (yychar);
- yydestruct ("Cleanup: discarding lookahead",
- yytoken, &yylval);
- }
- /* Do not reclaim the symbols of the rule whose action triggered
- this YYABORT or YYACCEPT. */
- YYPOPSTACK (yylen);
- YY_STACK_PRINT (yyss, yyssp);
- while (yyssp != yyss)
- {
- yydestruct ("Cleanup: popping",
- yystos[+*yyssp], yyvsp);
- YYPOPSTACK (1);
- }
-#ifndef yyoverflow
- if (yyss != yyssa)
- YYSTACK_FREE (yyss);
-#endif
-#if YYERROR_VERBOSE
- if (yymsg != yymsgbuf)
- YYSTACK_FREE (yymsg);
-#endif
- return yyresult;
-}
-#line 612 "compilador.y"
-
-
-int main (int argc, char** argv) {
- FILE* fp;
- extern FILE* yyin;
-
- if (argc<2 || argc>2) {
- printf("usage compilador <arq>a %d\n", argc);
- return(-1);
- }
-
- fp=fopen (argv[1], "r");
- if (fp == NULL) {
- printf("usage compilador <arq>b\n");
- return(-1);
- }
-
-
-/* -------------------------------------------------------------------
- * Inicia a Tabela de S�mbolos
- * ------------------------------------------------------------------- */
- ts = (ts_t *)malloc(sizeof(ts_t));
- inicializa_ts(ts);
- nivel_lexico = 0;
- desloc = 0;
-
- // Inicializa Rotulos
- rot = (custom_stack_t *)malloc(sizeof(custom_stack_t));
- inicializa_stack(rot);
- rot_id = 0;
-
- proc = (custom_stack_t *)malloc(sizeof(custom_stack_t));
- inicializa_stack(proc);
-
- yyin=fp;
- yyparse();
-
- return 0;
-}
diff --git a/compilador.tab.h b/compilador.tab.h
deleted file mode 100644
index 2be6c98..0000000
--- a/compilador.tab.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/* A Bison parser, made by GNU Bison 3.5.1. */
-
-/* Bison interface for Yacc-like parsers in C
-
- Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
- Inc.
-
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-/* As a special exception, you may create a larger work that contains
- part or all of the Bison parser skeleton and distribute that work
- under terms of your choice, so long as that work isn't itself a
- parser generator using the skeleton or a modified version thereof
- as a parser skeleton. Alternatively, if you modify or redistribute
- the parser skeleton itself, you may (at your option) remove this
- special exception, which will cause the skeleton and the resulting
- Bison output files to be licensed under the GNU General Public
- License without this special exception.
-
- This special exception was added by the Free Software Foundation in
- version 2.2 of Bison. */
-
-/* Undocumented macros, especially those whose name start with YY_,
- are private implementation details. Do not rely on them. */
-
-#ifndef YY_YY_COMPILADOR_TAB_H_INCLUDED
-# define YY_YY_COMPILADOR_TAB_H_INCLUDED
-/* Debug traces. */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int yydebug;
-#endif
-
-/* Token type. */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
- enum yytokentype
- {
- PROGRAM = 258,
- ABRE_PARENTESES = 259,
- FECHA_PARENTESES = 260,
- VIRGULA = 261,
- PONTO_E_VIRGULA = 262,
- DOIS_PONTOS = 263,
- PONTO = 264,
- T_BEGIN = 265,
- T_END = 266,
- VAR = 267,
- IDENT = 268,
- ATRIBUICAO = 269,
- LABEL = 270,
- TYPE = 271,
- ARRAY = 272,
- PROCEDURE = 273,
- FUNCTION = 274,
- GOTO = 275,
- IF = 276,
- THEN = 277,
- ELSE = 278,
- WHILE = 279,
- DO = 280,
- OR = 281,
- DIV = 282,
- AND = 283,
- NOT = 284,
- IGUAL = 285,
- DIFERENTE = 286,
- MENOR_IGUAL = 287,
- MAIOR_IGUAL = 288,
- MENOR = 289,
- MAIOR = 290,
- MAIS = 291,
- MENOS = 292,
- ASTERISCO = 293,
- NUMERO = 294,
- READ = 295,
- WRITE = 296,
- LOWER_THAN_ELSE = 297
- };
-#endif
-
-/* Value type. */
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef int YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define YYSTYPE_IS_DECLARED 1
-#endif
-
-
-extern YYSTYPE yylval;
-
-int yyparse (void);
-
-#endif /* !YY_YY_COMPILADOR_TAB_H_INCLUDED */
diff --git a/lex.yy.c b/lex.yy.c
deleted file mode 100644
index ef6ad0e..0000000
--- a/lex.yy.c
+++ /dev/null
@@ -1,2196 +0,0 @@
-
-#line 3 "lex.yy.c"
-
-#define YY_INT_ALIGNED short int
-
-/* A lexical scanner generated by flex */
-
-#define FLEX_SCANNER
-#define YY_FLEX_MAJOR_VERSION 2
-#define YY_FLEX_MINOR_VERSION 6
-#define YY_FLEX_SUBMINOR_VERSION 4
-#if YY_FLEX_SUBMINOR_VERSION > 0
-#define FLEX_BETA
-#endif
-
-/* First, we deal with platform-specific or compiler-specific issues. */
-
-/* begin standard C headers. */
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <stdlib.h>
-
-/* end standard C headers. */
-
-/* flex integer type definitions */
-
-#ifndef FLEXINT_H
-#define FLEXINT_H
-
-/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
-
-#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-
-/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
- * if you want the limit (max/min) macros for int types.
- */
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS 1
-#endif
-
-#include <inttypes.h>
-typedef int8_t flex_int8_t;
-typedef uint8_t flex_uint8_t;
-typedef int16_t flex_int16_t;
-typedef uint16_t flex_uint16_t;
-typedef int32_t flex_int32_t;
-typedef uint32_t flex_uint32_t;
-#else
-typedef signed char flex_int8_t;
-typedef short int flex_int16_t;
-typedef int flex_int32_t;
-typedef unsigned char flex_uint8_t;
-typedef unsigned short int flex_uint16_t;
-typedef unsigned int flex_uint32_t;
-
-/* Limits of integral types. */
-#ifndef INT8_MIN
-#define INT8_MIN (-128)
-#endif
-#ifndef INT16_MIN
-#define INT16_MIN (-32767-1)
-#endif
-#ifndef INT32_MIN
-#define INT32_MIN (-2147483647-1)
-#endif
-#ifndef INT8_MAX
-#define INT8_MAX (127)
-#endif
-#ifndef INT16_MAX
-#define INT16_MAX (32767)
-#endif
-#ifndef INT32_MAX
-#define INT32_MAX (2147483647)
-#endif
-#ifndef UINT8_MAX
-#define UINT8_MAX (255U)
-#endif
-#ifndef UINT16_MAX
-#define UINT16_MAX (65535U)
-#endif
-#ifndef UINT32_MAX
-#define UINT32_MAX (4294967295U)
-#endif
-
-#ifndef SIZE_MAX
-#define SIZE_MAX (~(size_t)0)
-#endif
-
-#endif /* ! C99 */
-
-#endif /* ! FLEXINT_H */
-
-/* begin standard C++ headers. */
-
-/* TODO: this is always defined, so inline it */
-#define yyconst const
-
-#if defined(__GNUC__) && __GNUC__ >= 3
-#define yynoreturn __attribute__((__noreturn__))
-#else
-#define yynoreturn
-#endif
-
-/* Returned upon end-of-file. */
-#define YY_NULL 0
-
-/* Promotes a possibly negative, possibly signed char to an
- * integer in range [0..255] for use as an array index.
- */
-#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
-
-/* Enter a start condition. This macro really ought to take a parameter,
- * but we do it the disgusting crufty way forced on us by the ()-less
- * definition of BEGIN.
- */
-#define BEGIN (yy_start) = 1 + 2 *
-/* Translate the current start state into a value that can be later handed
- * to BEGIN to return to the state. The YYSTATE alias is for lex
- * compatibility.
- */
-#define YY_START (((yy_start) - 1) / 2)
-#define YYSTATE YY_START
-/* Action number for EOF rule of a given start state. */
-#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
-/* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE yyrestart( yyin )
-#define YY_END_OF_BUFFER_CHAR 0
-
-/* Size of default input buffer. */
-#ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
-#define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
-#endif
-
-/* The state buf must be large enough to hold one state per character in the main buffer.
- */
-#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
-
-#ifndef YY_TYPEDEF_YY_BUFFER_STATE
-#define YY_TYPEDEF_YY_BUFFER_STATE
-typedef struct yy_buffer_state *YY_BUFFER_STATE;
-#endif
-
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
-extern int yyleng;
-
-extern FILE *yyin, *yyout;
-
-#define EOB_ACT_CONTINUE_SCAN 0
-#define EOB_ACT_END_OF_FILE 1
-#define EOB_ACT_LAST_MATCH 2
-
- #define YY_LESS_LINENO(n)
- #define YY_LINENO_REWIND_TO(ptr)
-
-/* Return all but the first "n" matched characters back to the input stream. */
-#define yyless(n) \
- do \
- { \
- /* Undo effects of setting up yytext. */ \
- int yyless_macro_arg = (n); \
- YY_LESS_LINENO(yyless_macro_arg);\
- *yy_cp = (yy_hold_char); \
- YY_RESTORE_YY_MORE_OFFSET \
- (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
- YY_DO_BEFORE_ACTION; /* set up yytext again */ \
- } \
- while ( 0 )
-#define unput(c) yyunput( c, (yytext_ptr) )
-
-#ifndef YY_STRUCT_YY_BUFFER_STATE
-#define YY_STRUCT_YY_BUFFER_STATE
-struct yy_buffer_state
- {
- FILE *yy_input_file;
-
- char *yy_ch_buf; /* input buffer */
- char *yy_buf_pos; /* current position in input buffer */
-
- /* Size of input buffer in bytes, not including room for EOB
- * characters.
- */
- int yy_buf_size;
-
- /* Number of characters read into yy_ch_buf, not including EOB
- * characters.
- */
- int yy_n_chars;
-
- /* Whether we "own" the buffer - i.e., we know we created it,
- * and can realloc() it to grow it, and should free() it to
- * delete it.
- */
- int yy_is_our_buffer;
-
- /* Whether this is an "interactive" input source; if so, and
- * if we're using stdio for input, then we want to use getc()
- * instead of fread(), to make sure we stop fetching input after
- * each newline.
- */
- int yy_is_interactive;
-
- /* Whether we're considered to be at the beginning of a line.
- * If so, '^' rules will be active on the next match, otherwise
- * not.
- */
- int yy_at_bol;
-
- int yy_bs_lineno; /**< The line count. */
- int yy_bs_column; /**< The column count. */
-
- /* Whether to try to fill the input buffer when we reach the
- * end of it.
- */
- int yy_fill_buffer;
-
- int yy_buffer_status;
-
-#define YY_BUFFER_NEW 0
-#define YY_BUFFER_NORMAL 1
- /* When an EOF's been seen but there's still some text to process
- * then we mark the buffer as YY_EOF_PENDING, to indicate that we
- * shouldn't try reading from the input source any more. We might
- * still have a bunch of tokens to match, though, because of
- * possible backing-up.
- *
- * When we actually see the EOF, we change the status to "new"
- * (via yyrestart()), so that the user can continue scanning by
- * just pointing yyin at a new input file.
- */
-#define YY_BUFFER_EOF_PENDING 2
-
- };
-#endif /* !YY_STRUCT_YY_BUFFER_STATE */
-
-/* Stack of input buffers. */
-static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
-static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
-static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
-
-/* We provide macros for accessing buffer states in case in the
- * future we want to put the buffer states in a more general
- * "scanner state".
- *
- * Returns the top of the stack, or NULL.
- */
-#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
- ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
- : NULL)
-/* Same as previous macro, but useful when we know that the buffer stack is not
- * NULL or when we need an lvalue. For internal use only.
- */
-#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
-
-/* yy_hold_char holds the character lost when yytext is formed. */
-static char yy_hold_char;
-static int yy_n_chars; /* number of characters read into yy_ch_buf */
-int yyleng;
-
-/* Points to current character in buffer. */
-static char *yy_c_buf_p = NULL;
-static int yy_init = 0; /* whether we need to initialize */
-static int yy_start = 0; /* start state number */
-
-/* Flag which is used to allow yywrap()'s to do buffer switches
- * instead of setting up a fresh yyin. A bit of a hack ...
- */
-static int yy_did_buffer_switch_on_eof;
-
-void yyrestart ( FILE *input_file );
-void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
-YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
-void yy_delete_buffer ( YY_BUFFER_STATE b );
-void yy_flush_buffer ( YY_BUFFER_STATE b );
-void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
-void yypop_buffer_state ( void );
-
-static void yyensure_buffer_stack ( void );
-static void yy_load_buffer_state ( void );
-static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
-#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
-
-YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );
-YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
-YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
-
-void *yyalloc ( yy_size_t );
-void *yyrealloc ( void *, yy_size_t );
-void yyfree ( void * );
-
-#define yy_new_buffer yy_create_buffer
-#define yy_set_interactive(is_interactive) \
- { \
- if ( ! YY_CURRENT_BUFFER ){ \
- yyensure_buffer_stack (); \
- YY_CURRENT_BUFFER_LVALUE = \
- yy_create_buffer( yyin, YY_BUF_SIZE ); \
- } \
- YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
- }
-#define yy_set_bol(at_bol) \
- { \
- if ( ! YY_CURRENT_BUFFER ){\
- yyensure_buffer_stack (); \
- YY_CURRENT_BUFFER_LVALUE = \
- yy_create_buffer( yyin, YY_BUF_SIZE ); \
- } \
- YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
- }
-#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
-
-/* Begin user sect3 */
-typedef flex_uint8_t YY_CHAR;
-
-FILE *yyin = NULL, *yyout = NULL;
-
-typedef int yy_state_type;
-
-extern int yylineno;
-int yylineno = 1;
-
-extern char *yytext;
-#ifdef yytext_ptr
-#undef yytext_ptr
-#endif
-#define yytext_ptr yytext
-
-static yy_state_type yy_get_previous_state ( void );
-static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
-static int yy_get_next_buffer ( void );
-static void yynoreturn yy_fatal_error ( const char* msg );
-
-/* Done after the current pattern has been matched and before the
- * corresponding action - sets up yytext.
- */
-#define YY_DO_BEFORE_ACTION \
- (yytext_ptr) = yy_bp; \
- yyleng = (int) (yy_cp - yy_bp); \
- (yy_hold_char) = *yy_cp; \
- *yy_cp = '\0'; \
- (yy_c_buf_p) = yy_cp;
-#define YY_NUM_RULES 43
-#define YY_END_OF_BUFFER 44
-/* This struct is not used in this scanner,
- but its presence is necessary. */
-struct yy_trans_info
- {
- flex_int32_t yy_verify;
- flex_int32_t yy_nxt;
- };
-static const flex_int16_t yy_accept[115] =
- { 0,
- 0, 0, 44, 43, 2, 1, 15, 16, 40, 38,
- 13, 39, 14, 41, 12, 11, 36, 32, 37, 42,
- 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
- 42, 42, 42, 42, 42, 2, 0, 41, 10, 34,
- 33, 35, 42, 42, 42, 42, 42, 27, 42, 42,
- 42, 42, 23, 42, 42, 28, 42, 42, 42, 42,
- 42, 42, 42, 0, 0, 30, 42, 42, 29, 42,
- 7, 42, 42, 42, 31, 42, 42, 42, 42, 5,
- 42, 42, 3, 42, 42, 25, 42, 22, 42, 42,
- 42, 8, 24, 18, 42, 42, 19, 6, 42, 17,
-
- 42, 42, 26, 9, 42, 42, 42, 42, 42, 4,
- 21, 42, 20, 0
- } ;
-
-static const YY_CHAR yy_ec[256] =
- { 0,
- 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 2, 1, 1, 1, 1, 1, 1, 1, 4,
- 5, 6, 7, 8, 9, 10, 1, 11, 11, 11,
- 11, 11, 11, 11, 11, 11, 11, 12, 13, 14,
- 15, 16, 1, 1, 17, 17, 17, 17, 17, 17,
- 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
- 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
- 1, 1, 1, 1, 1, 1, 18, 19, 20, 21,
-
- 22, 23, 24, 25, 26, 17, 17, 27, 28, 29,
- 30, 31, 17, 32, 33, 34, 35, 36, 37, 17,
- 38, 17, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1
- } ;
-
-static const YY_CHAR yy_meta[39] =
- { 0,
- 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
- 3, 1, 1, 1, 1, 1, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3
- } ;
-
-static const flex_int16_t yy_base[117] =
- { 0,
- 0, 0, 123, 124, 120, 124, 115, 124, 124, 124,
- 124, 124, 124, 109, 104, 124, 24, 124, 103, 0,
- 12, 95, 16, 16, 81, 85, 91, 95, 82, 79,
- 78, 87, 22, 90, 23, 105, 100, 94, 124, 124,
- 124, 124, 0, 83, 71, 78, 65, 0, 67, 78,
- 69, 63, 0, 77, 61, 0, 64, 75, 70, 60,
- 58, 63, 62, 81, 44, 0, 68, 59, 0, 62,
- 0, 63, 52, 59, 0, 32, 59, 50, 56, 0,
- 50, 42, 69, 36, 44, 0, 38, 0, 44, 48,
- 37, 0, 0, 0, 46, 45, 0, 0, 40, 0,
-
- 44, 46, 0, 0, 32, 24, 30, 28, 22, 0,
- 0, 31, 0, 124, 48, 60
- } ;
-
-static const flex_int16_t yy_def[117] =
- { 0,
- 114, 1, 114, 114, 114, 114, 114, 114, 114, 114,
- 114, 114, 114, 114, 114, 114, 114, 114, 114, 115,
- 115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
- 115, 115, 115, 115, 115, 114, 116, 114, 114, 114,
- 114, 114, 115, 115, 115, 115, 115, 115, 115, 115,
- 115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
- 115, 115, 115, 116, 116, 115, 115, 115, 115, 115,
- 115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
- 115, 115, 116, 115, 115, 115, 115, 115, 115, 115,
- 115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
-
- 115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
- 115, 115, 115, 0, 114, 114
- } ;
-
-static const flex_int16_t yy_nxt[163] =
- { 0,
- 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 20,
- 23, 24, 25, 26, 20, 27, 28, 20, 29, 30,
- 31, 32, 20, 33, 20, 34, 35, 20, 40, 41,
- 44, 47, 49, 45, 50, 48, 59, 62, 83, 65,
- 43, 90, 113, 112, 63, 91, 111, 110, 109, 60,
- 64, 108, 64, 107, 106, 105, 104, 103, 102, 101,
- 100, 99, 98, 97, 65, 96, 95, 94, 93, 92,
- 89, 88, 87, 86, 85, 84, 65, 82, 81, 80,
- 79, 78, 77, 76, 75, 74, 73, 72, 71, 70,
-
- 69, 68, 67, 66, 38, 65, 36, 61, 58, 57,
- 56, 55, 54, 53, 52, 51, 46, 42, 39, 38,
- 37, 36, 114, 3, 114, 114, 114, 114, 114, 114,
- 114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
- 114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
- 114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
- 114, 114
- } ;
-
-static const flex_int16_t yy_chk[163] =
- { 0,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 17, 17,
- 21, 23, 24, 21, 24, 23, 33, 35, 65, 65,
- 115, 76, 112, 109, 35, 76, 108, 107, 106, 33,
- 116, 105, 116, 102, 101, 99, 96, 95, 91, 90,
- 89, 87, 85, 84, 83, 82, 81, 79, 78, 77,
- 74, 73, 72, 70, 68, 67, 64, 63, 62, 61,
- 60, 59, 58, 57, 55, 54, 52, 51, 50, 49,
-
- 47, 46, 45, 44, 38, 37, 36, 34, 32, 31,
- 30, 29, 28, 27, 26, 25, 22, 19, 15, 14,
- 7, 5, 3, 114, 114, 114, 114, 114, 114, 114,
- 114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
- 114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
- 114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
- 114, 114
- } ;
-
-static yy_state_type yy_last_accepting_state;
-static char *yy_last_accepting_cpos;
-
-extern int yy_flex_debug;
-int yy_flex_debug = 0;
-
-/* The intent behind this definition is that it'll catch
- * any uses of REJECT which flex missed.
- */
-#define REJECT reject_used_but_not_detected
-#define yymore() yymore_used_but_not_detected
-#define YY_MORE_ADJ 0
-#define YY_RESTORE_YY_MORE_OFFSET
-char *yytext;
-#line 1 "compilador.l"
-/* -------------------------------------------------------------------
- * Arquivo: compilador.l
- * -------------------------------------------------------------------
- * Autor: Bruno Muller Junior
- * Data: 08/2007
- * Atualizado em: [09/08/2020, 19h:01m]
- *
- * -------------------------------------------------------------------
- *
- * Tipos, protótipos e variáveis globais do compilador (via extern)
- *
- * ------------------------------------------------------------------- */
-#line 16 "compilador.l"
-
-
-#include<stdio.h>
-#include<string.h>
-
-#include "compilador.h"
-#include "compilador.tab.h"
-
-//#define IMPRIME(STR) {};
-#define IMPRIME(STR) printf("%s # %s \n", STR, token);
-
-int nl = 1;
-
-#line 540 "lex.yy.c"
-#line 541 "lex.yy.c"
-
-#define INITIAL 0
-
-#ifndef YY_NO_UNISTD_H
-/* Special case for "unistd.h", since it is non-ANSI. We include it way
- * down here because we want the user's section 1 to have been scanned first.
- * The user has a chance to override it with an option.
- */
-#include <unistd.h>
-#endif
-
-#ifndef YY_EXTRA_TYPE
-#define YY_EXTRA_TYPE void *
-#endif
-
-static int yy_init_globals ( void );
-
-/* Accessor methods to globals.
- These are made visible to non-reentrant scanners for convenience. */
-
-int yylex_destroy ( void );
-
-int yyget_debug ( void );
-
-void yyset_debug ( int debug_flag );
-
-YY_EXTRA_TYPE yyget_extra ( void );
-
-void yyset_extra ( YY_EXTRA_TYPE user_defined );
-
-FILE *yyget_in ( void );
-
-void yyset_in ( FILE * _in_str );
-
-FILE *yyget_out ( void );
-
-void yyset_out ( FILE * _out_str );
-
- int yyget_leng ( void );
-
-char *yyget_text ( void );
-
-int yyget_lineno ( void );
-
-void yyset_lineno ( int _line_number );
-
-/* Macros after this point can all be overridden by user definitions in
- * section 1.
- */
-
-#ifndef YY_SKIP_YYWRAP
-#ifdef __cplusplus
-extern "C" int yywrap ( void );
-#else
-extern int yywrap ( void );
-#endif
-#endif
-
-#ifndef YY_NO_UNPUT
-
- static void yyunput ( int c, char *buf_ptr );
-
-#endif
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy ( char *, const char *, int );
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen ( const char * );
-#endif
-
-#ifndef YY_NO_INPUT
-#ifdef __cplusplus
-static int yyinput ( void );
-#else
-static int input ( void );
-#endif
-
-#endif
-
-/* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
-#define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
-#endif
-
-/* Copy whatever the last rule matched to the standard output. */
-#ifndef ECHO
-/* This used to be an fputs(), but since the string might contain NUL's,
- * we now use fwrite().
- */
-#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
-#endif
-
-/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
- * is returned in "result".
- */
-#ifndef YY_INPUT
-#define YY_INPUT(buf,result,max_size) \
- if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
- { \
- int c = '*'; \
- int n; \
- for ( n = 0; n < max_size && \
- (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
- buf[n] = (char) c; \
- if ( c == '\n' ) \
- buf[n++] = (char) c; \
- if ( c == EOF && ferror( yyin ) ) \
- YY_FATAL_ERROR( "input in flex scanner failed" ); \
- result = n; \
- } \
- else \
- { \
- errno=0; \
- while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
- { \
- if( errno != EINTR) \
- { \
- YY_FATAL_ERROR( "input in flex scanner failed" ); \
- break; \
- } \
- errno=0; \
- clearerr(yyin); \
- } \
- }\
-\
-
-#endif
-
-/* No semi-colon after return; correct usage is to write "yyterminate();" -
- * we don't want an extra ';' after the "return" because that will cause
- * some compilers to complain about unreachable statements.
- */
-#ifndef yyterminate
-#define yyterminate() return YY_NULL
-#endif
-
-/* Number of entries by which start-condition stack grows. */
-#ifndef YY_START_STACK_INCR
-#define YY_START_STACK_INCR 25
-#endif
-
-/* Report a fatal error. */
-#ifndef YY_FATAL_ERROR
-#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
-#endif
-
-/* end tables serialization structures and prototypes */
-
-/* Default declaration of generated scanner - a define so the user can
- * easily add parameters.
- */
-#ifndef YY_DECL
-#define YY_DECL_IS_OURS 1
-
-extern int yylex (void);
-
-#define YY_DECL int yylex (void)
-#endif /* !YY_DECL */
-
-/* Code executed at the beginning of each rule, after yytext and yyleng
- * have been set up.
- */
-#ifndef YY_USER_ACTION
-#define YY_USER_ACTION
-#endif
-
-/* Code executed at the end of each rule. */
-#ifndef YY_BREAK
-#define YY_BREAK /*LINTED*/break;
-#endif
-
-#define YY_RULE_SETUP \
- YY_USER_ACTION
-
-/** The main scanner function which does all the work.
- */
-YY_DECL
-{
- yy_state_type yy_current_state;
- char *yy_cp, *yy_bp;
- int yy_act;
-
- if ( !(yy_init) )
- {
- (yy_init) = 1;
-
-#ifdef YY_USER_INIT
- YY_USER_INIT;
-#endif
-
- if ( ! (yy_start) )
- (yy_start) = 1; /* first start state */
-
- if ( ! yyin )
- yyin = stdin;
-
- if ( ! yyout )
- yyout = stdout;
-
- if ( ! YY_CURRENT_BUFFER ) {
- yyensure_buffer_stack ();
- YY_CURRENT_BUFFER_LVALUE =
- yy_create_buffer( yyin, YY_BUF_SIZE );
- }
-
- yy_load_buffer_state( );
- }
-
- {
-#line 41 "compilador.l"
-
-
-#line 761 "lex.yy.c"
-
- while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
- {
- yy_cp = (yy_c_buf_p);
-
- /* Support of yytext. */
- *yy_cp = (yy_hold_char);
-
- /* yy_bp points to the position in yy_ch_buf of the start of
- * the current run.
- */
- yy_bp = yy_cp;
-
- yy_current_state = (yy_start);
-yy_match:
- do
- {
- YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
- if ( yy_accept[yy_current_state] )
- {
- (yy_last_accepting_state) = yy_current_state;
- (yy_last_accepting_cpos) = yy_cp;
- }
- while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
- {
- yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 115 )
- yy_c = yy_meta[yy_c];
- }
- yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
- ++yy_cp;
- }
- while ( yy_base[yy_current_state] != 124 );
-
-yy_find_action:
- yy_act = yy_accept[yy_current_state];
- if ( yy_act == 0 )
- { /* have to back up */
- yy_cp = (yy_last_accepting_cpos);
- yy_current_state = (yy_last_accepting_state);
- yy_act = yy_accept[yy_current_state];
- }
-
- YY_DO_BEFORE_ACTION;
-
-do_action: /* This label is used only to access EOF actions. */
-
- switch ( yy_act )
- { /* beginning of action switch */
- case 0: /* must back up */
- /* undo the effects of YY_DO_BEFORE_ACTION */
- *yy_cp = (yy_hold_char);
- yy_cp = (yy_last_accepting_cpos);
- yy_current_state = (yy_last_accepting_state);
- goto yy_find_action;
-
-case 1:
-/* rule 1 can match eol */
-YY_RULE_SETUP
-#line 43 "compilador.l"
-{nl++;}
- YY_BREAK
-case 2:
-YY_RULE_SETUP
-#line 45 "compilador.l"
-
- YY_BREAK
-case 3:
-YY_RULE_SETUP
-#line 47 "compilador.l"
-
- YY_BREAK
-case 4:
-YY_RULE_SETUP
-#line 49 "compilador.l"
-{ simbolo = simb_program;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME("program ");
- return PROGRAM;
- }
- YY_BREAK
-case 5:
-YY_RULE_SETUP
-#line 55 "compilador.l"
-{ simbolo = simb_var;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME("var ");
- return VAR;
- }
- YY_BREAK
-case 6:
-YY_RULE_SETUP
-#line 61 "compilador.l"
-{ simbolo = simb_begin;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME("begin ");
- return T_BEGIN;
- }
- YY_BREAK
-case 7:
-YY_RULE_SETUP
-#line 67 "compilador.l"
-{ simbolo = simb_end;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME("end ");
- return T_END;
- }
- YY_BREAK
-case 8:
-YY_RULE_SETUP
-#line 73 "compilador.l"
-{ simbolo = simb_read;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME("read ");
- return READ;
-}
- YY_BREAK
-case 9:
-YY_RULE_SETUP
-#line 79 "compilador.l"
-{ simbolo = simb_write;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME("write ");
- return WRITE;
-}
- YY_BREAK
-case 10:
-YY_RULE_SETUP
-#line 85 "compilador.l"
-{ simbolo = simb_atribuicao;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" atribuicao ");
- return ATRIBUICAO;
- }
- YY_BREAK
-case 11:
-YY_RULE_SETUP
-#line 91 "compilador.l"
-{ simbolo = simb_ponto_e_virgula;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" pt_virgula ");
- return PONTO_E_VIRGULA;
- }
- YY_BREAK
-case 12:
-YY_RULE_SETUP
-#line 97 "compilador.l"
-{ simbolo = simb_dois_pontos;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" dois pontos ");
- return DOIS_PONTOS;
- }
- YY_BREAK
-case 13:
-YY_RULE_SETUP
-#line 103 "compilador.l"
-{ simbolo = simb_virgula;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" virgula ");
- return VIRGULA;
- }
- YY_BREAK
-case 14:
-YY_RULE_SETUP
-#line 110 "compilador.l"
-{ simbolo = simb_ponto;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" ponto ");
- return PONTO;
- }
- YY_BREAK
-case 15:
-YY_RULE_SETUP
-#line 116 "compilador.l"
-{ simbolo = simb_abre_parenteses;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" abre_parenteses ");
- return ABRE_PARENTESES;
- }
- YY_BREAK
-case 16:
-YY_RULE_SETUP
-#line 122 "compilador.l"
-{ simbolo = simb_fecha_parenteses;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" fecha_parenteses ");
- return FECHA_PARENTESES;
- }
- YY_BREAK
-case 17:
-YY_RULE_SETUP
-#line 128 "compilador.l"
-{ simbolo = simb_label;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME("label ");
- return LABEL;
- }
- YY_BREAK
-case 18:
-YY_RULE_SETUP
-#line 134 "compilador.l"
-{ simbolo = simb_type;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME("type ");
- return TYPE;
- }
- YY_BREAK
-case 19:
-YY_RULE_SETUP
-#line 140 "compilador.l"
-{ simbolo = simb_array;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME("array ");
- return ARRAY;
- }
- YY_BREAK
-case 20:
-YY_RULE_SETUP
-#line 146 "compilador.l"
-{ simbolo = simb_procedure;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME("procedure ");
- return PROCEDURE;
- }
- YY_BREAK
-case 21:
-YY_RULE_SETUP
-#line 152 "compilador.l"
-{ simbolo = simb_function;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME("function ");
- return FUNCTION;
- }
- YY_BREAK
-case 22:
-YY_RULE_SETUP
-#line 158 "compilador.l"
-{ simbolo = simb_goto;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME("goto ");
- return GOTO;
- }
- YY_BREAK
-case 23:
-YY_RULE_SETUP
-#line 164 "compilador.l"
-{ simbolo = simb_if;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME("if ");
- return IF;
- }
- YY_BREAK
-case 24:
-YY_RULE_SETUP
-#line 170 "compilador.l"
-{ simbolo = simb_then;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" then ");
- return THEN;
- }
- YY_BREAK
-case 25:
-YY_RULE_SETUP
-#line 176 "compilador.l"
-{ simbolo = simb_else;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" else ");
- return ELSE;
- }
- YY_BREAK
-case 26:
-YY_RULE_SETUP
-#line 182 "compilador.l"
-{ simbolo = simb_while;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME("while ");
- return WHILE;
- }
- YY_BREAK
-case 27:
-YY_RULE_SETUP
-#line 188 "compilador.l"
-{ simbolo = simb_do;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" do ");
- return DO;
- }
- YY_BREAK
-case 28:
-YY_RULE_SETUP
-#line 194 "compilador.l"
-{ simbolo = simb_or;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" or ");
- return OR;
- }
- YY_BREAK
-case 29:
-YY_RULE_SETUP
-#line 200 "compilador.l"
-{ simbolo = simb_div;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" div ");
- return DIV;
- }
- YY_BREAK
-case 30:
-YY_RULE_SETUP
-#line 206 "compilador.l"
-{ simbolo = simb_and;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" and ");
- return AND;
- }
- YY_BREAK
-case 31:
-YY_RULE_SETUP
-#line 212 "compilador.l"
-{ simbolo = simb_not;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" not ");
- return NOT;
- }
- YY_BREAK
-case 32:
-YY_RULE_SETUP
-#line 218 "compilador.l"
-{ simbolo = simb_igual;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" igual ");
- return IGUAL;
- }
- YY_BREAK
-case 33:
-YY_RULE_SETUP
-#line 224 "compilador.l"
-{ simbolo = simb_diferente;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" diferente ");
- return DIFERENTE;
- }
- YY_BREAK
-case 34:
-YY_RULE_SETUP
-#line 230 "compilador.l"
-{ simbolo = simb_menor_igual;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" menor_igual ");
- return MENOR_IGUAL;
- }
- YY_BREAK
-case 35:
-YY_RULE_SETUP
-#line 236 "compilador.l"
-{ simbolo = simb_maior_igual;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" maior_igual ");
- return MAIOR_IGUAL;
- }
- YY_BREAK
-case 36:
-YY_RULE_SETUP
-#line 242 "compilador.l"
-{ simbolo = simb_menor;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" menor ");
- return MENOR;
- }
- YY_BREAK
-case 37:
-YY_RULE_SETUP
-#line 248 "compilador.l"
-{ simbolo = simb_maior;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" maior ");
- return MAIOR;
- }
- YY_BREAK
-case 38:
-YY_RULE_SETUP
-#line 254 "compilador.l"
-{ simbolo = simb_mais;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" mais ");
- return MAIS;
- }
- YY_BREAK
-case 39:
-YY_RULE_SETUP
-#line 260 "compilador.l"
-{ simbolo = simb_menos;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" menos ");
- return MENOS;
- }
- YY_BREAK
-case 40:
-YY_RULE_SETUP
-#line 266 "compilador.l"
-{ simbolo = simb_asterisco;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" asterisco ");
- return ASTERISCO;
- }
- YY_BREAK
-case 41:
-YY_RULE_SETUP
-#line 272 "compilador.l"
-{ simbolo = simb_numero;
- strncpy (token, yytext,TAM_TOKEN);
- IMPRIME(" numero ");
- return NUMERO;
- }
- YY_BREAK
-case 42:
-YY_RULE_SETUP
-#line 278 "compilador.l"
-{ simbolo = simb_identificador;
- strncpy (token, yytext, TAM_TOKEN);
- IMPRIME(" ident ");
- return IDENT;
- }
- YY_BREAK
-case 43:
-YY_RULE_SETUP
-#line 284 "compilador.l"
-ECHO;
- YY_BREAK
-#line 1190 "lex.yy.c"
-case YY_STATE_EOF(INITIAL):
- yyterminate();
-
- case YY_END_OF_BUFFER:
- {
- /* Amount of text matched not including the EOB char. */
- int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
-
- /* Undo the effects of YY_DO_BEFORE_ACTION. */
- *yy_cp = (yy_hold_char);
- YY_RESTORE_YY_MORE_OFFSET
-
- if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
- {
- /* We're scanning a new file or input source. It's
- * possible that this happened because the user
- * just pointed yyin at a new source and called
- * yylex(). If so, then we have to assure
- * consistency between YY_CURRENT_BUFFER and our
- * globals. Here is the right place to do so, because
- * this is the first action (other than possibly a
- * back-up) that will match for the new input source.
- */
- (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
- YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
- YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
- }
-
- /* Note that here we test for yy_c_buf_p "<=" to the position
- * of the first EOB in the buffer, since yy_c_buf_p will
- * already have been incremented past the NUL character
- * (since all states make transitions on EOB to the
- * end-of-buffer state). Contrast this with the test
- * in input().
- */
- if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
- { /* This was really a NUL. */
- yy_state_type yy_next_state;
-
- (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
-
- yy_current_state = yy_get_previous_state( );
-
- /* Okay, we're now positioned to make the NUL
- * transition. We couldn't have
- * yy_get_previous_state() go ahead and do it
- * for us because it doesn't know how to deal
- * with the possibility of jamming (and we don't
- * want to build jamming into it because then it
- * will run more slowly).
- */
-
- yy_next_state = yy_try_NUL_trans( yy_current_state );
-
- yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-
- if ( yy_next_state )
- {
- /* Consume the NUL. */
- yy_cp = ++(yy_c_buf_p);
- yy_current_state = yy_next_state;
- goto yy_match;
- }
-
- else
- {
- yy_cp = (yy_c_buf_p);
- goto yy_find_action;
- }
- }
-
- else switch ( yy_get_next_buffer( ) )
- {
- case EOB_ACT_END_OF_FILE:
- {
- (yy_did_buffer_switch_on_eof) = 0;
-
- if ( yywrap( ) )
- {
- /* Note: because we've taken care in
- * yy_get_next_buffer() to have set up
- * yytext, we can now set up
- * yy_c_buf_p so that if some total
- * hoser (like flex itself) wants to
- * call the scanner after we return the
- * YY_NULL, it'll still work - another
- * YY_NULL will get returned.
- */
- (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
-
- yy_act = YY_STATE_EOF(YY_START);
- goto do_action;
- }
-
- else
- {
- if ( ! (yy_did_buffer_switch_on_eof) )
- YY_NEW_FILE;
- }
- break;
- }
-
- case EOB_ACT_CONTINUE_SCAN:
- (yy_c_buf_p) =
- (yytext_ptr) + yy_amount_of_matched_text;
-
- yy_current_state = yy_get_previous_state( );
-
- yy_cp = (yy_c_buf_p);
- yy_bp = (yytext_ptr) + YY_MORE_ADJ;
- goto yy_match;
-
- case EOB_ACT_LAST_MATCH:
- (yy_c_buf_p) =
- &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
-
- yy_current_state = yy_get_previous_state( );
-
- yy_cp = (yy_c_buf_p);
- yy_bp = (yytext_ptr) + YY_MORE_ADJ;
- goto yy_find_action;
- }
- break;
- }
-
- default:
- YY_FATAL_ERROR(
- "fatal flex scanner internal error--no action found" );
- } /* end of action switch */
- } /* end of scanning one token */
- } /* end of user's declarations */
-} /* end of yylex */
-
-/* yy_get_next_buffer - try to read in a new buffer
- *
- * Returns a code representing an action:
- * EOB_ACT_LAST_MATCH -
- * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
- * EOB_ACT_END_OF_FILE - end of file
- */
-static int yy_get_next_buffer (void)
-{
- char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
- char *source = (yytext_ptr);
- int number_to_move, i;
- int ret_val;
-
- if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
- YY_FATAL_ERROR(
- "fatal flex scanner internal error--end of buffer missed" );
-
- if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
- { /* Don't try to fill the buffer, so this is an EOF. */
- if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
- {
- /* We matched a single character, the EOB, so
- * treat this as a final EOF.
- */
- return EOB_ACT_END_OF_FILE;
- }
-
- else
- {
- /* We matched some text prior to the EOB, first
- * process it.
- */
- return EOB_ACT_LAST_MATCH;
- }
- }
-
- /* Try to read more data. */
-
- /* First move last chars to start of buffer. */
- number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
-
- for ( i = 0; i < number_to_move; ++i )
- *(dest++) = *(source++);
-
- if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
- /* don't do the read, it's not guaranteed to return an EOF,
- * just force an EOF
- */
- YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
-
- else
- {
- int num_to_read =
- YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
-
- while ( num_to_read <= 0 )
- { /* Not enough room in the buffer - grow it. */
-
- /* just a shorter name for the current buffer */
- YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
-
- int yy_c_buf_p_offset =
- (int) ((yy_c_buf_p) - b->yy_ch_buf);
-
- if ( b->yy_is_our_buffer )
- {
- int new_size = b->yy_buf_size * 2;
-
- if ( new_size <= 0 )
- b->yy_buf_size += b->yy_buf_size / 8;
- else
- b->yy_buf_size *= 2;
-
- b->yy_ch_buf = (char *)
- /* Include room in for 2 EOB chars. */
- yyrealloc( (void *) b->yy_ch_buf,
- (yy_size_t) (b->yy_buf_size + 2) );
- }
- else
- /* Can't grow it, we don't own it. */
- b->yy_ch_buf = NULL;
-
- if ( ! b->yy_ch_buf )
- YY_FATAL_ERROR(
- "fatal error - scanner input buffer overflow" );
-
- (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
-
- num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
- number_to_move - 1;
-
- }
-
- if ( num_to_read > YY_READ_BUF_SIZE )
- num_to_read = YY_READ_BUF_SIZE;
-
- /* Read in more data. */
- YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
- (yy_n_chars), num_to_read );
-
- YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
- }
-
- if ( (yy_n_chars) == 0 )
- {
- if ( number_to_move == YY_MORE_ADJ )
- {
- ret_val = EOB_ACT_END_OF_FILE;
- yyrestart( yyin );
- }
-
- else
- {
- ret_val = EOB_ACT_LAST_MATCH;
- YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
- YY_BUFFER_EOF_PENDING;
- }
- }
-
- else
- ret_val = EOB_ACT_CONTINUE_SCAN;
-
- if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
- /* Extend the array by 50%, plus the number we really need. */
- int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
- YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
- (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
- if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
- YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
- /* "- 2" to take care of EOB's */
- YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
- }
-
- (yy_n_chars) += number_to_move;
- YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
- YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
-
- (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
-
- return ret_val;
-}
-
-/* yy_get_previous_state - get the state just before the EOB char was reached */
-
- static yy_state_type yy_get_previous_state (void)
-{
- yy_state_type yy_current_state;
- char *yy_cp;
-
- yy_current_state = (yy_start);
-
- for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
- {
- YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
- if ( yy_accept[yy_current_state] )
- {
- (yy_last_accepting_state) = yy_current_state;
- (yy_last_accepting_cpos) = yy_cp;
- }
- while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
- {
- yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 115 )
- yy_c = yy_meta[yy_c];
- }
- yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
- }
-
- return yy_current_state;
-}
-
-/* yy_try_NUL_trans - try to make a transition on the NUL character
- *
- * synopsis
- * next_state = yy_try_NUL_trans( current_state );
- */
- static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
-{
- int yy_is_jam;
- char *yy_cp = (yy_c_buf_p);
-
- YY_CHAR yy_c = 1;
- if ( yy_accept[yy_current_state] )
- {
- (yy_last_accepting_state) = yy_current_state;
- (yy_last_accepting_cpos) = yy_cp;
- }
- while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
- {
- yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 115 )
- yy_c = yy_meta[yy_c];
- }
- yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
- yy_is_jam = (yy_current_state == 114);
-
- return yy_is_jam ? 0 : yy_current_state;
-}
-
-#ifndef YY_NO_UNPUT
-
- static void yyunput (int c, char * yy_bp )
-{
- char *yy_cp;
-
- yy_cp = (yy_c_buf_p);
-
- /* undo effects of setting up yytext */
- *yy_cp = (yy_hold_char);
-
- if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
- { /* need to shift things up to make room */
- /* +2 for EOB chars. */
- int number_to_move = (yy_n_chars) + 2;
- char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
- YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
- char *source =
- &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
-
- while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
- *--dest = *--source;
-
- yy_cp += (int) (dest - source);
- yy_bp += (int) (dest - source);
- YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
- (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
-
- if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
- YY_FATAL_ERROR( "flex scanner push-back overflow" );
- }
-
- *--yy_cp = (char) c;
-
- (yytext_ptr) = yy_bp;
- (yy_hold_char) = *yy_cp;
- (yy_c_buf_p) = yy_cp;
-}
-
-#endif
-
-#ifndef YY_NO_INPUT
-#ifdef __cplusplus
- static int yyinput (void)
-#else
- static int input (void)
-#endif
-
-{
- int c;
-
- *(yy_c_buf_p) = (yy_hold_char);
-
- if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
- {
- /* yy_c_buf_p now points to the character we want to return.
- * If this occurs *before* the EOB characters, then it's a
- * valid NUL; if not, then we've hit the end of the buffer.
- */
- if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
- /* This was really a NUL. */
- *(yy_c_buf_p) = '\0';
-
- else
- { /* need more input */
- int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
- ++(yy_c_buf_p);
-
- switch ( yy_get_next_buffer( ) )
- {
- case EOB_ACT_LAST_MATCH:
- /* This happens because yy_g_n_b()
- * sees that we've accumulated a
- * token and flags that we need to
- * try matching the token before
- * proceeding. But for input(),
- * there's no matching to consider.
- * So convert the EOB_ACT_LAST_MATCH
- * to EOB_ACT_END_OF_FILE.
- */
-
- /* Reset buffer status. */
- yyrestart( yyin );
-
- /*FALLTHROUGH*/
-
- case EOB_ACT_END_OF_FILE:
- {
- if ( yywrap( ) )
- return 0;
-
- if ( ! (yy_did_buffer_switch_on_eof) )
- YY_NEW_FILE;
-#ifdef __cplusplus
- return yyinput();
-#else
- return input();
-#endif
- }
-
- case EOB_ACT_CONTINUE_SCAN:
- (yy_c_buf_p) = (yytext_ptr) + offset;
- break;
- }
- }
- }
-
- c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
- *(yy_c_buf_p) = '\0'; /* preserve yytext */
- (yy_hold_char) = *++(yy_c_buf_p);
-
- return c;
-}
-#endif /* ifndef YY_NO_INPUT */
-
-/** Immediately switch to a different input stream.
- * @param input_file A readable stream.
- *
- * @note This function does not reset the start condition to @c INITIAL .
- */
- void yyrestart (FILE * input_file )
-{
-
- if ( ! YY_CURRENT_BUFFER ){
- yyensure_buffer_stack ();
- YY_CURRENT_BUFFER_LVALUE =
- yy_create_buffer( yyin, YY_BUF_SIZE );
- }
-
- yy_init_buffer( YY_CURRENT_BUFFER, input_file );
- yy_load_buffer_state( );
-}
-
-/** Switch to a different input buffer.
- * @param new_buffer The new input buffer.
- *
- */
- void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
-{
-
- /* TODO. We should be able to replace this entire function body
- * with
- * yypop_buffer_state();
- * yypush_buffer_state(new_buffer);
- */
- yyensure_buffer_stack ();
- if ( YY_CURRENT_BUFFER == new_buffer )
- return;
-
- if ( YY_CURRENT_BUFFER )
- {
- /* Flush out information for old buffer. */
- *(yy_c_buf_p) = (yy_hold_char);
- YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
- YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
- }
-
- YY_CURRENT_BUFFER_LVALUE = new_buffer;
- yy_load_buffer_state( );
-
- /* We don't actually know whether we did this switch during
- * EOF (yywrap()) processing, but the only time this flag
- * is looked at is after yywrap() is called, so it's safe
- * to go ahead and always set it.
- */
- (yy_did_buffer_switch_on_eof) = 1;
-}
-
-static void yy_load_buffer_state (void)
-{
- (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
- (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
- yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
- (yy_hold_char) = *(yy_c_buf_p);
-}
-
-/** Allocate and initialize an input buffer state.
- * @param file A readable stream.
- * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
- *
- * @return the allocated buffer state.
- */
- YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
-{
- YY_BUFFER_STATE b;
-
- b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
- if ( ! b )
- YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
-
- b->yy_buf_size = size;
-
- /* yy_ch_buf has to be 2 characters longer than the size given because
- * we need to put in 2 end-of-buffer characters.
- */
- b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
- if ( ! b->yy_ch_buf )
- YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
-
- b->yy_is_our_buffer = 1;
-
- yy_init_buffer( b, file );
-
- return b;
-}
-
-/** Destroy the buffer.
- * @param b a buffer created with yy_create_buffer()
- *
- */
- void yy_delete_buffer (YY_BUFFER_STATE b )
-{
-
- if ( ! b )
- return;
-
- if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
- YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
-
- if ( b->yy_is_our_buffer )
- yyfree( (void *) b->yy_ch_buf );
-
- yyfree( (void *) b );
-}
-
-/* Initializes or reinitializes a buffer.
- * This function is sometimes called more than once on the same buffer,
- * such as during a yyrestart() or at EOF.
- */
- static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
-
-{
- int oerrno = errno;
-
- yy_flush_buffer( b );
-
- b->yy_input_file = file;
- b->yy_fill_buffer = 1;
-
- /* If b is the current buffer, then yy_init_buffer was _probably_
- * called from yyrestart() or through yy_get_next_buffer.
- * In that case, we don't want to reset the lineno or column.
- */
- if (b != YY_CURRENT_BUFFER){
- b->yy_bs_lineno = 1;
- b->yy_bs_column = 0;
- }
-
- b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
-
- errno = oerrno;
-}
-
-/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
- * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
- *
- */
- void yy_flush_buffer (YY_BUFFER_STATE b )
-{
- if ( ! b )
- return;
-
- b->yy_n_chars = 0;
-
- /* We always need two end-of-buffer characters. The first causes
- * a transition to the end-of-buffer state. The second causes
- * a jam in that state.
- */
- b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
- b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
-
- b->yy_buf_pos = &b->yy_ch_buf[0];
-
- b->yy_at_bol = 1;
- b->yy_buffer_status = YY_BUFFER_NEW;
-
- if ( b == YY_CURRENT_BUFFER )
- yy_load_buffer_state( );
-}
-
-/** Pushes the new state onto the stack. The new state becomes
- * the current state. This function will allocate the stack
- * if necessary.
- * @param new_buffer The new state.
- *
- */
-void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
-{
- if (new_buffer == NULL)
- return;
-
- yyensure_buffer_stack();
-
- /* This block is copied from yy_switch_to_buffer. */
- if ( YY_CURRENT_BUFFER )
- {
- /* Flush out information for old buffer. */
- *(yy_c_buf_p) = (yy_hold_char);
- YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
- YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
- }
-
- /* Only push if top exists. Otherwise, replace top. */
- if (YY_CURRENT_BUFFER)
- (yy_buffer_stack_top)++;
- YY_CURRENT_BUFFER_LVALUE = new_buffer;
-
- /* copied from yy_switch_to_buffer. */
- yy_load_buffer_state( );
- (yy_did_buffer_switch_on_eof) = 1;
-}
-
-/** Removes and deletes the top of the stack, if present.
- * The next element becomes the new top.
- *
- */
-void yypop_buffer_state (void)
-{
- if (!YY_CURRENT_BUFFER)
- return;
-
- yy_delete_buffer(YY_CURRENT_BUFFER );
- YY_CURRENT_BUFFER_LVALUE = NULL;
- if ((yy_buffer_stack_top) > 0)
- --(yy_buffer_stack_top);
-
- if (YY_CURRENT_BUFFER) {
- yy_load_buffer_state( );
- (yy_did_buffer_switch_on_eof) = 1;
- }
-}
-
-/* Allocates the stack if it does not exist.
- * Guarantees space for at least one push.
- */
-static void yyensure_buffer_stack (void)
-{
- yy_size_t num_to_alloc;
-
- if (!(yy_buffer_stack)) {
-
- /* First allocation is just for 2 elements, since we don't know if this
- * scanner will even need a stack. We use 2 instead of 1 to avoid an
- * immediate realloc on the next call.
- */
- num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
- (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
- (num_to_alloc * sizeof(struct yy_buffer_state*)
- );
- if ( ! (yy_buffer_stack) )
- YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-
- memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-
- (yy_buffer_stack_max) = num_to_alloc;
- (yy_buffer_stack_top) = 0;
- return;
- }
-
- if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
-
- /* Increase the buffer to prepare for a possible push. */
- yy_size_t grow_size = 8 /* arbitrary grow size */;
-
- num_to_alloc = (yy_buffer_stack_max) + grow_size;
- (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
- ((yy_buffer_stack),
- num_to_alloc * sizeof(struct yy_buffer_state*)
- );
- if ( ! (yy_buffer_stack) )
- YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-
- /* zero only the new slots.*/
- memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
- (yy_buffer_stack_max) = num_to_alloc;
- }
-}
-
-/** Setup the input buffer state to scan directly from a user-specified character buffer.
- * @param base the character buffer
- * @param size the size in bytes of the character buffer
- *
- * @return the newly allocated buffer state object.
- */
-YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
-{
- YY_BUFFER_STATE b;
-
- if ( size < 2 ||
- base[size-2] != YY_END_OF_BUFFER_CHAR ||
- base[size-1] != YY_END_OF_BUFFER_CHAR )
- /* They forgot to leave room for the EOB's. */
- return NULL;
-
- b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
- if ( ! b )
- YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
-
- b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
- b->yy_buf_pos = b->yy_ch_buf = base;
- b->yy_is_our_buffer = 0;
- b->yy_input_file = NULL;
- b->yy_n_chars = b->yy_buf_size;
- b->yy_is_interactive = 0;
- b->yy_at_bol = 1;
- b->yy_fill_buffer = 0;
- b->yy_buffer_status = YY_BUFFER_NEW;
-
- yy_switch_to_buffer( b );
-
- return b;
-}
-
-/** Setup the input buffer state to scan a string. The next call to yylex() will
- * scan from a @e copy of @a str.
- * @param yystr a NUL-terminated string to scan
- *
- * @return the newly allocated buffer state object.
- * @note If you want to scan bytes that may contain NUL values, then use
- * yy_scan_bytes() instead.
- */
-YY_BUFFER_STATE yy_scan_string (const char * yystr )
-{
-
- return yy_scan_bytes( yystr, (int) strlen(yystr) );
-}
-
-/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
- * scan from a @e copy of @a bytes.
- * @param yybytes the byte buffer to scan
- * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
- *
- * @return the newly allocated buffer state object.
- */
-YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
-{
- YY_BUFFER_STATE b;
- char *buf;
- yy_size_t n;
- int i;
-
- /* Get memory for full buffer, including space for trailing EOB's. */
- n = (yy_size_t) (_yybytes_len + 2);
- buf = (char *) yyalloc( n );
- if ( ! buf )
- YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
-
- for ( i = 0; i < _yybytes_len; ++i )
- buf[i] = yybytes[i];
-
- buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
-
- b = yy_scan_buffer( buf, n );
- if ( ! b )
- YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
-
- /* It's okay to grow etc. this buffer, and we should throw it
- * away when we're done.
- */
- b->yy_is_our_buffer = 1;
-
- return b;
-}
-
-#ifndef YY_EXIT_FAILURE
-#define YY_EXIT_FAILURE 2
-#endif
-
-static void yynoreturn yy_fatal_error (const char* msg )
-{
- fprintf( stderr, "%s\n", msg );
- exit( YY_EXIT_FAILURE );
-}
-
-/* Redefine yyless() so it works in section 3 code. */
-
-#undef yyless
-#define yyless(n) \
- do \
- { \
- /* Undo effects of setting up yytext. */ \
- int yyless_macro_arg = (n); \
- YY_LESS_LINENO(yyless_macro_arg);\
- yytext[yyleng] = (yy_hold_char); \
- (yy_c_buf_p) = yytext + yyless_macro_arg; \
- (yy_hold_char) = *(yy_c_buf_p); \
- *(yy_c_buf_p) = '\0'; \
- yyleng = yyless_macro_arg; \
- } \
- while ( 0 )
-
-/* Accessor methods (get/set functions) to struct members. */
-
-/** Get the current line number.
- *
- */
-int yyget_lineno (void)
-{
-
- return yylineno;
-}
-
-/** Get the input stream.
- *
- */
-FILE *yyget_in (void)
-{
- return yyin;
-}
-
-/** Get the output stream.
- *
- */
-FILE *yyget_out (void)
-{
- return yyout;
-}
-
-/** Get the length of the current token.
- *
- */
-int yyget_leng (void)
-{
- return yyleng;
-}
-
-/** Get the current token.
- *
- */
-
-char *yyget_text (void)
-{
- return yytext;
-}
-
-/** Set the current line number.
- * @param _line_number line number
- *
- */
-void yyset_lineno (int _line_number )
-{
-
- yylineno = _line_number;
-}
-
-/** Set the input stream. This does not discard the current
- * input buffer.
- * @param _in_str A readable stream.
- *
- * @see yy_switch_to_buffer
- */
-void yyset_in (FILE * _in_str )
-{
- yyin = _in_str ;
-}
-
-void yyset_out (FILE * _out_str )
-{
- yyout = _out_str ;
-}
-
-int yyget_debug (void)
-{
- return yy_flex_debug;
-}
-
-void yyset_debug (int _bdebug )
-{
- yy_flex_debug = _bdebug ;
-}
-
-static int yy_init_globals (void)
-{
- /* Initialization is the same as for the non-reentrant scanner.
- * This function is called from yylex_destroy(), so don't allocate here.
- */
-
- (yy_buffer_stack) = NULL;
- (yy_buffer_stack_top) = 0;
- (yy_buffer_stack_max) = 0;
- (yy_c_buf_p) = NULL;
- (yy_init) = 0;
- (yy_start) = 0;
-
-/* Defined in main.c */
-#ifdef YY_STDINIT
- yyin = stdin;
- yyout = stdout;
-#else
- yyin = NULL;
- yyout = NULL;
-#endif
-
- /* For future reference: Set errno on error, since we are called by
- * yylex_init()
- */
- return 0;
-}
-
-/* yylex_destroy is for both reentrant and non-reentrant scanners. */
-int yylex_destroy (void)
-{
-
- /* Pop the buffer stack, destroying each element. */
- while(YY_CURRENT_BUFFER){
- yy_delete_buffer( YY_CURRENT_BUFFER );
- YY_CURRENT_BUFFER_LVALUE = NULL;
- yypop_buffer_state();
- }
-
- /* Destroy the stack itself. */
- yyfree((yy_buffer_stack) );
- (yy_buffer_stack) = NULL;
-
- /* Reset the globals. This is important in a non-reentrant scanner so the next time
- * yylex() is called, initialization will occur. */
- yy_init_globals( );
-
- return 0;
-}
-
-/*
- * Internal utility routines.
- */
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy (char* s1, const char * s2, int n )
-{
-
- int i;
- for ( i = 0; i < n; ++i )
- s1[i] = s2[i];
-}
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (const char * s )
-{
- int n;
- for ( n = 0; s[n]; ++n )
- ;
-
- return n;
-}
-#endif
-
-void *yyalloc (yy_size_t size )
-{
- return malloc(size);
-}
-
-void *yyrealloc (void * ptr, yy_size_t size )
-{
-
- /* The cast to (char *) in the following accommodates both
- * implementations that use char* generic pointers, and those
- * that use void* generic pointers. It works with the latter
- * because both ANSI C and C++ allow castless assignment from
- * any pointer type to void*, and deal with argument conversions
- * as though doing an assignment.
- */
- return realloc(ptr, size);
-}
-
-void yyfree (void * ptr )
-{
- free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
-}
-
-#define YYTABLES_NAME "yytables"
-
-#line 284 "compilador.l"
-
-
diff --git a/stack/stack.o b/stack/stack.o
deleted file mode 100644
index 5aa85557f8e7200312cb4b8bf4bffa3dbbe4b327..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 3200
zcmb<-^>JfjWMqH=Mg}_u1P><4z`($XU^{@B4h(z@ybPcD<$i^FbUyXyto`B9?fS#x
zI9L+IJnp~&Vo!)Y3|G|rM!}=A_Jv1h=>w1E+6N3J#rp*q7#LoF)OmEef=qbf(Rm!g
zZ$7{XXLlX~nds3e0H(SbJi0?)cywNa%Xhmz@aTp}b_Q^GfVrVRAnG4<J8<*{FoFa-
z12|qYPB@9jL0KSW9^DKctp`ftU~GuXet2|4jRrddV(fpA8i<uYATB_2*AI|kFfV}u
z2+GFpj^^4I3?)1s-L5Y{+FB2k3VQU~f<gxzBrls87#NTRP}!y+g;1d#AU0SNQ~<(;
z8r<pn<Fz_0C_9fql_2Q>Ikek>0~{yKwLch2FG1CSjX8OkAs{m+BT*r>xa9Ccg|ft|
z%tVF!QiZ(3i}MvS^D>h&6LT`F5>pcO7`VU+tr&Ev4j4R3Qgaz<6jXH$4T=?NxEL7R
zot>=|G(wX~^GZq;EcHzE40H`k!92q{BLh7H6FnnMh&TfS3j+fKDCw~>Ffh3Lg)%TP
zFdP7hF@wU5fq_8;N;6gkF)&sLFiP{Vb4*}lV31*eV34#bh;Zc-Xk&8bWsBiq2PJoq
zybVa4fq`Knh=$2Cb$}Is<YPeM3=9k%AQ~=T50|e2i8C-T>;%zp`3+!skPtQu%CjsC
zAOB;MW5%AN8JHPhzD3o=3=SPsF%XZL0Tfyw7Aj_DU`G{z@|YPwAp+$fQOwAN35qxy
z5)Z-z6+1#m?gxiCC>Jm=Fo48id~jGZFfd3#;}xPCK^ou?H^(7vheO;IYVS6v(cm~_
zU|<Nqp*|F<-VPK&usCI4U`WEDJ{^ZRLvcxBa<*PF10s9HgM}F4-F^I>9DU;b-Q0p*
zL*hdmoqSy58FCYIa`KZIic5-eQu9DmazQ0SN@{UxZUHFgGNcuyrZVK_7nc+zLd_{C
zEh%OwD9X$$Nn>DOaD(~}lqYx@7#RNihk!67aXut*kbgi@=<1t5f((%S#*d_43K||D
z^~mCyNaBJ>>P>Nor$EJ-7#P5*6XwoLs5r=cVI*@(q2e(0Dp2=TLB-M4H$uf>>UE&%
z+o0m;>U*K$F!l9N^;6KqTcG0epyD8NKxGch{Y#<ZFmqt`u7Zk#)Fb=r1XLWR9%lX}
zs5nSHviWbI;xP3v^FKnxLF$psSAe<~q#lH!Tn0#6fB{r~f-x*VCO{Q{)PgW9zciqU
z!}0}#UU6k^Nn#R%UU5kggwBAmic)hD^-5AJN*MG~5=#;p^pc8;8T5+sA)Ms=+}zZ>
z5(d4z{E}2XcfU|wNWOsZ)ALI83X1XzQj1C|8T7y=rDnvZ6(#1TLR~@`1qv5XkfE1c
zuyFYfl0>osjmsbn%^NWFFr^Yu0|h{V$H2hA&A<RI1z{zs1XQ6KR2;n|H;3wjDuYw#
z_JiUbWG1=#4Wag<TW0|km<+cW!T{L?VL?bssD4oS3=x5lr=j{m?t_RxNSOO!v=dZ6
zL>57Qhw4X&Kv*z+5FP_V5Ca3a_Ci<w11bQDUzl1Djqd&|sQpmoASGZd0S(X@U><@%
z*AGgCpuC12{~Az*uzUoHe^6Zr6=s0NKgd7mc7tr&0JZ-INC5)_0}lfO0~Z4WyheuU
r2bl>~3epD0E1*?<9$W;%fEowkFfcHH%4lr*JD?6Nfvbct(DefVb8G5m
diff --git a/ts/ts.o b/ts/ts.o
deleted file mode 100644
index 61c2b7e1032ed2c492aacab17952e40c31f213cf..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 10696
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
F9{|_WS84zN
--
GitLab