From 2bcb210c18e83d76480726472dc6c4bc6a87b4c0 Mon Sep 17 00:00:00 2001 From: arielherself Date: Thu, 29 Feb 2024 20:44:55 +0800 Subject: [PATCH] backup --- src/bin/a.cc | 31 ++--- src/bin/a.out | Bin 398584 -> 217920 bytes src/bin/b.cc | 53 ++++---- src/bin/c.cc | 53 ++++++-- src/bin/cf-1690e.cc | 270 ++++++++++++++++++++++++++++++++++++ src/bin/cf-1701d.cc | 263 +++++++++++++++++++++++++++++++++++ src/bin/cf-1733d2.cc | 272 ++++++++++++++++++++++++++++++++++++ src/bin/cf-1738c.cc | 256 ++++++++++++++++++++++++++++++++++ src/bin/cf-1742f.cc | 266 ++++++++++++++++++++++++++++++++++++ src/bin/cf-1744e1.cc | 262 +++++++++++++++++++++++++++++++++++ src/bin/cf-1744f.cc | 254 ++++++++++++++++++++++++++++++++++ src/bin/cf-1791f.cc | 318 +++++++++++++++++++++++++++++++++++++++++++ src/bin/cf-1795c.cc | 277 +++++++++++++++++++++++++++++++++++++ src/bin/cf-1808c.cc | 311 ++++++++++++++++++++++++++++++++++++++++++ src/bin/cf-1933a.cc | 247 +++++++++++++++++++++++++++++++++ src/bin/cf-1933b.cc | 261 +++++++++++++++++++++++++++++++++++ src/bin/cf-1933c.cc | 276 +++++++++++++++++++++++++++++++++++++ src/bin/cf-1933d.cc | 268 ++++++++++++++++++++++++++++++++++++ src/bin/cf-1933e.cc | 265 ++++++++++++++++++++++++++++++++++++ src/bin/cf-1933f.cc | 290 +++++++++++++++++++++++++++++++++++++++ src/bin/cf-455a.cc | 250 ++++++++++++++++++++++++++++++++++ src/bin/cf-580c.cc | 266 ++++++++++++++++++++++++++++++++++++ src/bin/cf1744e1.cc | 241 ++++++++++++++++++++++++++++++++ src/bin/d.cc | 96 ++++--------- src/bin/e.cc | 265 ++++++++++++++++++++++++++++++++++++ src/bin/f.cc | 290 +++++++++++++++++++++++++++++++++++++++ src/bin/hack.cc | 65 +++++++++ src/bin/std.in | 26 ++-- src/bin/template.cc | 238 ++++++++++++++++++++++++++++++++ src/bin/test.cc | 26 +--- 30 files changed, 6082 insertions(+), 174 deletions(-) create mode 100644 src/bin/cf-1690e.cc create mode 100644 src/bin/cf-1701d.cc create mode 100644 src/bin/cf-1733d2.cc create mode 100644 src/bin/cf-1738c.cc create mode 100644 src/bin/cf-1742f.cc create mode 100644 src/bin/cf-1744e1.cc create mode 100644 src/bin/cf-1744f.cc create mode 100644 src/bin/cf-1791f.cc create mode 100644 src/bin/cf-1795c.cc create mode 100644 src/bin/cf-1808c.cc create mode 100644 src/bin/cf-1933a.cc create mode 100644 src/bin/cf-1933b.cc create mode 100644 src/bin/cf-1933c.cc create mode 100644 src/bin/cf-1933d.cc create mode 100644 src/bin/cf-1933e.cc create mode 100644 src/bin/cf-1933f.cc create mode 100644 src/bin/cf-455a.cc create mode 100644 src/bin/cf-580c.cc create mode 100644 src/bin/cf1744e1.cc create mode 100644 src/bin/e.cc create mode 100644 src/bin/f.cc create mode 100644 src/bin/hack.cc create mode 100644 src/bin/template.cc diff --git a/src/bin/a.cc b/src/bin/a.cc index f4c1b7f..35a741e 100644 --- a/src/bin/a.cc +++ b/src/bin/a.cc @@ -30,9 +30,10 @@ using pll = pair; /* constants */ constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; constexpr ull MDL = 1e9 + 7; constexpr ull PRIME = 998'244'353; -constexpr ll MDL1 = 825; +constexpr ll MDL1 = 8784491; constexpr ll MDL2 = PRIME; /* random */ @@ -138,6 +139,8 @@ template ostream& operator<<(ostream& out, vector vec) { #define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) /* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + void __exgcd(ll a, ll b, ll& x, ll& y) { if (b == 0) { x = 1, y = 0; @@ -204,35 +207,27 @@ int period(string s) { // find the length of shortest recurring period } ///////////////////////////////////////////////////////// + // #define SINGLE_TEST_CASE // #define DUMP_TEST_CASE 512 void dump() {} +void prep() {} + void solve() { read(int, n); - readvec(int, a, n); - int zer = 0; - for (int i = 0; i < n; ++i) { - if (a[i] == 1) { - int res = 0, zer = 0; - for (int j = i + 1; j < n; ++j) { - if (a[j] == 1) { - res += zer; - zer = 0; - } else { - zer += 1; - } - } - cout << res << endl; - return; - } + ll res = 0; + for (int i =0; i < n; ++i) { + read(int, x); + res += abs(x); } - cout << 0 << endl; + cout << res << endl; } int main() { untie, cout.tie(NULL); + prep(); #ifdef SINGLE_TEST_CASE solve(); #else diff --git a/src/bin/a.out b/src/bin/a.out index 20c6d89f4abb765c58730f4f785d207e28e691bd..3fcb4cef34d5e374df33662a2ec7611b1c3c46e6 100755 GIT binary patch literal 217920 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 literal 398584 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ΰc2kBmu4e&pX~f48uun)Ov=%g)Vpzf0UKzQo{6&~e zHmqPEY_<_h5LTSXH&Cd?J|wW4&;-FrK6p0U`V{|j7=N|Jzr2J3#{Z7>Cb0D6@|)rW z1pKGxB{{YZ>OVa%$?0vgg7a9PWSJgM>GGVC%T6Ydl>VG8HdBVe`A*o6>gN=fbQJC+ z3m5YK6H)Ixf+(X6f7puC0pF>SomWoaH5k_$fViaDh_JwM?gR5)Ac*uRT_zQKyR8OV z=}NxYCyw(0*Dry%G~$mDI1A@cLW#w{fH%ksENEJik+L-IT#Ew$zY2&;*h$tM?>M_d zdc8tDy*JFzlkDbQ_(q27K|oy6PV&d&@c+QPqX;a=(!=M2JY+uOKi4yWxP+W!|A~%s z30Q0efr;;81@`*{{s33;n+U9?G*2;s^|aHdrW701luc!}t10snQu;%@SXq8hQ<4g6 z%5a+qUD8pwlWaVK_K&Ey7lEZ0Jn;Mye@UIBMz+p*mt`=nqk*_I;%x|64PQZGSAqW1 z;_YSr3aaIrf7$D8Gb&r+ygY9I@8cxXt9krm!uvOYWkRp;qE6M)GNCk58|eUCKLX;? zh~G!xqy{MyPviLq-#b1Ol5$3~k+OFj$G~ts4~R>eojB-SCDs~(C{gYhjJ!x~1-+pJ zeq$gmVfN(BrSN(x&XQ+ELHFh-&x*o{N+wKb z(oXUb^cI78=MzMFPK`vqc*b#7a=j6VOUOy?ez@a21?Ij(V3Qb8J4|9`=ge*rOcB0w z$D@(MrWNOMvdJ%-qSMd4>Uhp)H4|d{zU^jLdw12NE{n0}9@t?*)D6+^?cdg4fw>lN zrfQ2yFfq!@A_ADI2~sdWng)Ha;xtbRrb&-M->x`Kmx9?+jErqloMuhIq-l5Jb^)ep z@)XRS7D7(|@-%sPB)BV9a$9nr&$8Tgma-GA7PaF|18!lUV`rU=}EkMce!-~D(YF9dAa{f&j@rpYZnTkVN zQKidFo*=}Ef(Ygrco|kJ z(rgBJk3;ka*;m9p5Hmog0)?7jh89?R-jx)~y&`WPqR)bVD&Vz;xCLaD2u(9z0C@&T zbP7uJC4Hl?cR;MuHwsRkX8cXA@H6T)o2?*z@N73F~w8*8|=U5PyOEA>uQL z#tG^W@ZN^#4$=`Q)GL+HoM+||f4Ggk4iw#3_=iZLCB!_CIU*WETmo{QhuC}_wYEWkSoqAkd7K&5W0Y85eKp#}l@ z-vqb(F{O~@j>x)j(MdU3?$E3Y&pL@#9u`d7K#KoIz(UR!ZcU;zD42Cvc@?mN*$T2n zgbJoBYyBMoE0}{ph67eGp*jB02y;=vEP#KU6jU&)K&}v>f>{spp$HX>zR3Cm!U`rd z<(a9dU}}+R3RuDP1L-9~1#>3IX(CiGH-TIWR4N}qzinn&BV(UD?>I+toeRXJ5FbF`q)w4vdJkx{Cbj)6SbnLNq9VUk zg#S7tc_}m2Cs2(&PY~tSNnSsW^4;kS&Tj6`vtUE`_zR-^T zrSId*TK8Ky1{{UnKwRqaY+=O&PHNqF?qv$7Zv{6oSg&NJfSdRQncxNZAjVH*yfX3=xRa-yl6Nlug3S{;UaTKpW3&n9m)|7ag1QU`THNuLZ_9rPk<=D2Y) z9U-&5;hJL#b-^YYCR418T~?&%UPqioXKi|Q$^H-+yF$j6XBs=j4XyqEw3Ym(5+4Cm z-WmeC`Cz$d0wa-ENmmc1 z?DOBRR$A4!GJNO1-(I+@DQTB64-@fGo-8%HhDln3{Edl$*!jT~HFYbsh3N;Bhm{2B z1xn~vg3`MP3Pd_Tnr!~2{6~lJ=Z3_18we}|4yLG|W1aj>H9AMl+2XFiZvN)1Zy9lZ zlWY=^NVY(U)VIU(>|GK5q1aSwl#33hvjBib7a*>*;%^Z+Kee^ zoBJ`#GMU=tCQAQkxHc}Z;$#(;9ACj^7h+>e2rM7|lHN(gU#|FT!+6!UlPqh2gQ0l+ zn|oBqx%civm7JbkbB~15e^4c<`!%ZU&iYdHU+}h}m4AwFFWuZizV}W3E5E7A-WD>G zkLNcxPM0%C=n0=g^PqjL$=^-?8QJ3B>j#$jJM2n$2*u>2oIKC9oYLT8QXT3sdAw46h{ zQzP}kESR=Id~YBw<#?8`LIURNRN4Tr*eHUia-8IAWMGowXKf$<8^ySQC~rj=U!Q@; zGBWU3o!`5qKI3j00M{pgxRm3I6GFa>#f{YAYj_36SQQm*TcRUDZ&7l9ZZ2gJX%9gE@uksY!ilCRO4y*+a z$$3sO)GlU8$>gbw|FU^sXj7}RPV&i9 z9OvJPe{uWxPZl}OdqjEPX2xgKx#a6A@qf6+cHy2R&1*^YiXgp?1eSND!#FU*Nv!f( zw>sMh9_QD4O>G}ZjVU9u9}1&nNb2#%3R)7dEQHP^u-GgDGwH89zfJrC#hfQ*2q3WPu3lcg<53F2rS3-3z!qLD*Oe^%W#vM z!}q#m3T0G?l($W113cHkKwQ!|2{Skl0n9svU-#`l(yXbYw-LR7?L7WuU$>q;Y0OmpNAYe2omcZ@@t?k}3Od@;J9UEe*Z#lgH!avpD!zWxf__(! zb0>NJWR|~Ck9|#GciMnfLQ9_QH2%zM^7<4B-HTA7ImNL%0kf+;9pxURosHy~YV(}N zcX?%EW8(x7HMWbiM)n`+%{eHT82`6s;z}Z3te}d(NhZcR&MdIlVggH~e#A{?SLVM% z-ct9g0PaH|ng&@n%y!)pP3a&GcOaVC{4Tk14C9|nzPq!@zp`q-A>TZKc|d##-}@mH z(#v?KMmiU;T;wvC#03&^l5ysMX-IEZ0?Vf6fEkTUvI95pSIt~|0&z(@$r*>SzzPBFA@fW_>+hw`w*?&>2AYG=WS))k^bt^CD|K}`fJ9W|`f z$;wKCj6(mA?A=L}_jDLvpS|T?t)3=MjdYG>ka?Ty1|Tkt_=5ya^2%l$oCp@nX&o3g z13IKX`F>U~r9Y~gg+cgU%S@q+mL=tbzGRBab#EXpX=mX8CRE7>27-?VEZdsUWGG7b zhI?7_J{8=FJOPwh= zk}v7EyHDuNLp#KS_0#+j8S%trUHGon;LAoZNf;aGvqaH??EIE}8G7DyIKN^3Cm^nQ zQKh(5^T1LJ6-gkmC@`u;(!kg`ficg?A;U$#m3$T&Yl}u}z&9qY8S78f{xWvr_Qo`o zdmu2D?NrLx*6b>7(d!9kG8z+s{C@=^dH9f87+*j}O2RujsGH+-LWLW4_iz$t2Pync zb`#43LQBFN;PoZ_vgrMsL+O?+%T)UFmQwn&oDZz@2TTo-3C@SvI_~ekZlj`)QB|HKCbHG6Y=HhM6hUnpZSWUp zhjdKM|GVWsUF{-JBWNndOoFtTN`WAq|DQ?KqA&?aFxN%dVQsy>7%yNo8EfLWGVuDljStA)L zbh=!9my&C!+v$DG zXAg3#S@V4*ET;g4+Ksg?5}S-z;s{<1YdhAP@LvTyZP5A&O^jx{|z>NLrV2yMU)flXW0Z0C{?g(CQ>V3q0X@)+I)JJw|sxNpBG* zFis2wJiS+V59A3Eded+b&Gu9vPa9`L3!XDZ7W%u1=h|UGyJvqz<_Eyje%cxuXa!KF z7e1jVeU>YY!RUM#|Vsggr8>UCF&!dimrwq$Y!r%%XH8_A!U!O<9I*{#r4 z)1RYWQjhsLruBDQs-o83(<7U*Z31vAv}ZLG^&-qyA@6jVnf%|aw*|2iP&giFn*SF^ z8!Yr?Vi6YVlpMZ~SBAt{h@JtoP!kQsvmz`MkN5Wqt&Lue?4^LU(HlXo2ds^T%Go<9 zhi&vBL|02!ZS+}?rvd$JyHThgcfL}~;hxs&p0wTQ1LWQTN_qxGs?q8$xK<4hQRVsj zXK+;5$6>ZY)1LnXt)w2aBngznZoK;NG#UB{^FIPj^};dK@ggkLDSoJ>r#F!4N_=>L zL^S2rnKb^d9`otM7_V}y648`8; zu;qBo-Z zDPRd69VNKGE#gd^9d@&ueuNHJK{eAs-DOo z+UQ`3&{)hj_HfdBh}d4$IIlqbc8K^&f;KwCC=|}}g)eU6%_H`B1ZPTkIz)UdL7@(c z3x%^yIQs-vI?f{cP9(3F^obDhSpcRRvTw@Yv^3OjGNE~KN)jgf^PWMN~oTV-JsoarbW0mQYy=p+ix^pjF~C29jg#a_}P!|2Co zTS>0h6S8%{F|m#rV%Zd%iM=MVZW&_v<1@re7-UDn=^E;4DBDARa7syt?U(^iE^6L8&mQlbLW)^BRP% zmX>ymJqYrE2rX(p1F{ydMa@u~H@Rp>i<#=9uqSIL*zEv1exL1Ikna(d>5b{J zQ4(WFf@#^4N`e-I%xGQ-2;z(XKyAUMIU6}##Gen0q1`dVqZ5Al0|{1*Ztf2Bpc@>p+)owQPeW@unLo(-KH^x`U1&5p1j zAJxNJ#vz{iEr+}u~P9Lh|L|CX&ysDX}{q^r4x(=WO^fqo&bT^|^0v~3-urGG? zGVT|IwA$zdOI!<4}(+j&RLCyv8^Z`L=z;({VK%$k`c2zGd>6pe$I=5p`Tz9@ zKKf|WisfLy(`O(vK_&osWt3HD!E;`f1t!n&K3LG_>JK4vuaufYd;#(a&_R_FD#ao! zyhA3^%XkxLbyCopGytoUYLH66>Lk?9+DSjGlXi&iAzjr;Uywck1C1T$6Wnx;^OdrE zL8+(nc@9Bf1W+&T0BWGz^g+>pWfKH|u=xHE%e@|s98oa*#|bD}cdrsOnz zPEZC*N$V7V|3hFw1>^}JPlptR3ZAn&OAnepXRA`)fmOs}Y7+2tHc>T5r9fgWbOhbC zQBs!#SUMdUIzL2d-{bdE%*;5o-g;l7+^_i8kH1lGIAydkAK zAhKA5{!7G4h&qTGpin1Og%)CFp z4G_J)dkn}c*j%4(j&rTdTbUn9%F6xqwF+@H{63IcfbbmP|%B%LzQq4Z-r=M zfXAaY?tC)a7szs2l+)2aO01Aw?b2C_&=R0f-z5GXh%t9V%$9ofQQ{r&Zvi}gruZ_* z^FaQ8f_sv0pK(uR+V;~-`*rwncYb;W`;(q_|9pq)*MOzhDG=jTo6^%#w$jVr69TaG zb_dxF$oGOS8l|UUll#+VrO`)Qa-_G!Pw%|`q;~-v_KY|O0^Vs5D?ly*3iah@sN>dKmV8vkGGOh9HF;Qfi* zT##b{MqQ{`ffjC8pf&3NwBA&P5jqnn)VKPfoaelVT=wSdN^c0!E8$-WR4TS=3^6Z4 z{aac(m@CwZnO5m+w}p2v(ed_F0N`sqPE0$fU4g0>A&vx@D&n0?;xmX7i9G?ZU!IO3 zIybuO50w8E@v37e;P`>C;(HPB|2u4~K;>*8Plpv=5o!D>jeX+f&Vk4s0qZ4XUI09u zIrt&S`+&8Fn>^~ieRwL^5jn|G3?Ry;%0?d9fNTERO z`{PKd{Z95 zkC7?;E|&ft@#<&$p`Z8>Vk`W{9a+HuD#flUCHg$5Q-L0}5P3SQyScV~g1=e#1pc)a9D2|fsG6GCqS-fa+*JF(LZ@N{Hn|@H`vLi%W@LcG zW5>QWA64dQN9)4wjn~*2Ky@l(Hj%LxBo{2M=hkzMBQig1|FgfyR1(YSpdBew=J={k z2Ij{U{p@ZbB~RN_rjoZQKvR7R5~|c=p$ScK^liv|MCSpFaoW-uD#V;BZW_A_MqpPv zI+r1IHsEDJYz5gYLc2Z}bYXM=^7PqzXdufu2m^^5yyDXaVnN@&zm3crfTyqFe+AhB z6zcs|sFdw1^>h>V?y9saYk+{gyXpke4(OnT`cNS!!ovH)87@4$6e^AJ5wx>~D08{{ki_ginyLhXbzL-&aLt+!??5V#U3X@9n#899w3 z$P3k+b)gpNOS)%pX80U?+q+Ljyx%BfAx~!>d=*rBmUD{Iy2(o)F^n$$E-ddwg6Bx_ z5x{#KqOKc#9q@EC!UZ6wDng1?9})92)R%z0;`%)>>^fJ;@D(}bR}I3ZUU41Jo!$=E zE3S({&IBqYX0NzHP0!a1UvYhj(8qwi;%c%N9RRRbT%khD6rxvLhru5L*ekC4KyDJD zS6qLAYytBB3Njh^L)A2rp zwQO%z#sTkDh}%JK7V#v+T97A2JOJ@F$Xh^RpWo`uF%Q9nFLALiBbjq`ruO=5pR_D8^b79zhF6AQq56ru{G zDbPm$z!ECQd}ZEO97$|@*li_02BJU6fg*-Li~%_mDAXS-h00l`Z0|3&5q&iLnNrvS zu>|By5nn(o2e|^U_Zgvfwyzz&&$tWzZBo$tjAucf7NPeV?}5An*n5poJIB`!-)npa z|7$7ey+(F#oD{&`Z0PiLM%J97A|T(hU_C!)}r>SATNv1qV~ri9|A4(8FZ*$Z!@$MEpY#U z>}Dz3C(-+m5MT@3X^<3oH67>p2#qa?gyAB zax2IR5%NSD_vK3~z&w%A0DIsnxN$s@{83ntCvqe*QvmZs&IUOHFi#{@@_ePx6S)=s zjZ)AqnioKx0n8H#6=F_^`L{%h7nEK*k_7b-*@*a;($_=e50L)=_7DlRvUbuBA0m1C zGTH+65UB*I00K`W)Xs5Q>mCD7q#XinfRZ^GUG8J@Vr9Hi%U26BIKTQF^F&V1h!1Ls zw9FHkYn~_*3a6LSqLcl2NTw%p2q_K%%oDj6lhLBORhrisp$NPRuC4Jdra4 z!<-l(!+0Vs4x-%TiQJCNb%1#y-+_DvR7%V|kx z{vZbe=7}r{Y_pCOVX9&Z16SZn6^0top~xRB18PJwL8b%Nh(a}XFYaIJp(RvIv3sfO#U@BAF0t7%0gTIr=aR>%IET$lnNVV!%9+8jxxcdez<$q&<*G1iG1?NEpWlhygbi<`GZiZQZdvk-q5n0n8H#CE5J3 zqfX$7j6!q-z!TAJ<=c}dvKe#1GcLbLMtszO0#D?Wb(rz$i1(+ui8gQMLRM&VSmygAQJdu--nGcvJvI68vz&w#q$@7&$Pvmj< zk4QnD$j2b>1Llc@3Na_d!ffLgv{r(8h-^jt59#Y6QZR%Z0`?FIwODD0ZrHaFK18Y! ztpw~L(hg(~fRRsYBB4%>vqAS5cq02D&<7}aD5J|wB`;RSH_H=QlfhZ!bIcQYE+amu zCDJla#F^*k3!h18(KAn+nCXekBE`c2^F*EmSuH}INa;|X7eJ*H%@a8iYAj%$NO548 zPm`Kr7*FKxag>`pk-L$(5%4_`kk5chiJ2!7YI?qA=!vu$#z%pGc_RHl_5;il2^C_d z5P2fA;ZKo*Jdp=MbjXf*B0qzC1LT(lnfx11BrF)ZV<1%Qmz3Sh8{@ebc_Ok*ZrgY_r zoC0z(KxfgUBGidRSdjhtHIa*vz7Q}^B$UtENj~&MUPN@2CE$A^W1?K`q8i2%X;0HJ zPvpiC>{tZM6L|z=wFr44Z-BfeLY~OyAfE!}iG=1{N9H0=G0zWFp7}z&w#qIm?tIPvm&`$4WtKBIkoF6(LXLT99i1^F%`JY+pO{ zL>_>Dj}+vIybSW92zer(fP4g)ClYGs_}ZZ-@)P{;rJyyD+=Hk)z&w$rAWZ-(Qu9PY z6LH@}=!xu!(C*TbCvqUj{vzaw913zU;Ma;gk@KOZ1Nnys4Q2;VgpHRwdm`&HhOB`! ztNKCiqYTbupJSfL7a8#yvsl?cXzAN$`fffno$_=J&{n<`&*?i zq$E#dKNR{($vlzkcJuA>?ps|V^hCxYFd8sV-UZQjcojw0$9MPU=H`;zkdO-jg+M^Cpdexc!Gh%##McIb6;MyH--yDlZ zA}6EH^>KyDP2!YI-axCDq>IsT5a|Z$PeE1!Rr>0U7s|#$8tv$_H`#-OAOs?P2&W@R zJ+Ni8ra_=I5%uw6?9oaAwt{PC*msh=KFc={WIv#dzANhk%q5tYS4TAoj-y~bLb78a zP5~JYkbSTJ(jcAZ#wFs&XlEs^=fZF{Q2Z`ct@p?Is0cCY5Qe)zq^rzZ9U27x zK-5XFZFgLr#N`&CLf>NA$tfm7>rl*y=h_kIT!PmQLzvhCkv_3>5Xc~)PHa{Eh^&{4 zVo8m7hT(iFOyear0OC@R3xTT7zH1Q3m_SYko%G@1Mfl$%fhHvLTOhBC_#2-eLB0bD zyE!A>h$kxB-BP2qKKtZTCYxaCAuA|Nkc{-BSy@oTe0isqAD?pwW zQGht-2=eT^4VOMgvNZu{+dD;c(O0g$@+el$kmp@on;u1BfIoT(;vR^3K=e4o zAtR{cK$k^dHV9{8;j`OCU*VcRnrSR7(Q=5}Aua@>*C7r%hSeJ&Hf#+pKSR9*)Skhp z%zptp0@Wc2<0traBI%Wp1fnBQFTk@5uoFp}Bz(=c7UBUeI4X35jttQ?060x0Tnt) zc~YWbkTkFr^nl~gpwpDQj%HO1h;*8=_5>Pkph_1vd!ZC{7(REN;Tv} z#$-U9SZqqQ%#~X{&m$>6rFtHw2LPK=^&dl52iTO#3q&Sh4UA4wUV#5(z@}7dKt2_r z#ogg!Igt(&KXXB;fhi?E*8XY(Z2qGeaf;bV%D)}a`aJ9zc1Fr)k|XRS&QKtr9gy~tp z>ge$e%G<%`PYr&C|HpvU(QrJM%s~`7yTtc(bfV0#Q-gDo;OeA?;O;zu;B;!RBhqaE zJ2ki;NMB&BQ-fZd1KWrvrv}f4bBeedP7TW6P7Qv5`+b0&8uWyn8uZFCu`-%tof^E9 zv8O&_x7Mja&s-8SyHkTN!uW)k8=o5V%v`&H8Of=^45i>VaW_6S=($T{Za<^!0k``9 zhEs#bK^+0uOwvo`Vktk9yd3{Il1feuz6|vYP$ye#2I)o1Vo^VX{0pWZC8`;u%^bUt zTN?u=YNrN|h8hUisllyXi$N=;XmV1;_hhg3KVxvmAus$qj?9a3VWp7 z<)#v8hqb*@rcqA4510UY_EZ2mti1=y`vUP{ZOW9oF{jCF`&!hqX_JcN}2N)tMkO0Bf$iaCRMG-(1au^-{^Ixw;AD20*`J zcb8IXXty9HN-Y}H!icp}kb2H!MPE(ry@^o$Jk~lUgC>)z|4?G=0@o4(Sga7Yg?JX^ z8K8|m|LoQGWPnJiY!0|4uZ%g)Vi0?r@1G=2S5NVGj?Bm-pB)PUGnulv0+1nDh zAspoVEzcPzQEq&2waX#KIsbAIEjq_`TX)#S5!LeP?uewH3yK$~(&=D^oPE+B*uq=Z2J_#>|cn)Nlh+84v z0eK7Pv^7&GFVFUEr_*b)C6QfV`3l}IBzyqGUm$;o*b_qEp{ms2;1wt9mqhdxDDT#Q zITP(j

iz75qD`8EPgZ@f&DV2KP%BAVTFgSD&JHM{ZbnFRCfes;4ntUCexioIQ# zQz!Z`!6yZ*@Sl{AxvFqc8D-K^YKDFdSWMeuN00HuLS_vljQzY>UL;C{y@)q!Cag!8 zS$3%REf)qoO*_+j&?)HEq28gBgWy2G#v`7Mi9;d~Yu2IOi)D+(BU9j?1jL7WJ!@uN zArAF^A|V~>Jr4ohEnAR#2kEX2eG?DZ28Zt%LX@LYI3OeF_<0%>`?D_iFJ>P zhw{DRWP;I>-zs=M1Z>H#+Z68K0&K}|0Lb1zon-7#Z#Bg%{ymFRvetJjOvgw{YkjAK zOcSBCzKcLE04lWq$xE{yh_njxD>C9-ysm}kY6)qL?{1JgMQDxhIgn)lo5x+?u0-3x zUhl?sCK<#l#?6#ZTG-Qh`nLf)*z5V&>?A(7nD-mrKTCH|e9<*qDv7(If- z)&`{CkHue3WzlF6KG7XKHpaUZ&_y>$dtQ!Vz}s?6AzFd!$#{!w2cCsq=w*=Sfnuqf%Z=_$n!)Pw@{j?}eUrqE-H~BWmXF;qO_^W#AVoMyW|7V@ z%J7o9{G2!$MNp;nu}K*c|2*c~Y*M-A7TLQoY@fmQDUe_6_?z`Ys(7cPxB3!=M8xMse(U8V2Y}?7s==C!n>y$LQIj1oM$l4@}nkwP5d_rY1GsWq9b6VrU2LY zcd+=~sOf0DhlxcOH+U9443o=TCUg^vQxd5n>O#FGDM9pP5CGGnnnC=6teSZn$1rciB zmxH_qSo_}7Npm>7W8A*qDI?Ur{|3*`fVJ<{)WfELweK5&bW+94tLW&LZr{BddvZ~! z_PwCeruMxDLR$gWzI(nX=5y`)V7%i>U;Hvvt2?5?wdI8$QtrOC$7WP$9C=(4rH2$g zw*co=l{A(dkMc1gz zvy$}xKx+KJ@gJD}l9UFHwX~?s0UJ1O1kwqp(!kM6b8sH%WU$y1|7|6p!D4@qej+qj z91e0AP`E6W^r=*6twE#rYrx|4iL>KvMN@;ulh88;utB4ji4y5V#tj45pAyKoD)Tn^o zjq^(|y&$RUAy$EWB4RGY&mcbn6{~)1kPZV$tAM^LBYwgwM;>K?D9^HPE09_df8o;& zq$?2QKS`BRC8fUZ>D?NzBq?bu#wpMA&CeZCuszU5N2$F`lwgSrrBlbK_l0$DvFk1j z&z?yz&#uy`yD)~sdKkd3cvk%1uF{-M@K)G#2D$J`$|rWU_k-4BpR!S`llyK+8A{tG zXJff~?1@Ne3EFyW&lUw9i^WJBN?Xb4$f(C&2>t>t21F#kNp%( zj{??Xe-HAN2=&-i)Qn2NdTg(O*eYk9|4b7mGzbwr2?gV{tw9BX}?ywmxW7BTEex#y z+mP{D5?hZoafYgL&N_o2)q8Ibe=op#Z{5wgmk9OV!$5`rwjtx|M4QL5UYp+>1v)QMjRG6%2?8D5^)I-OpVbtvl0uYva}32U-;7sx^pnyftu@;H$H-pTsa z2OU!JZVi|-(fal86=U`5|3m&Yz&2!f89srS#4wifbGVOTT?r8Ae;T|~ zC9Hn`B9IG2sNcU4&1a!92U~@85;>ZGd0#6lbKe^&^6}wo^TO;jEO8x!NL8F-$qv(2kmyZP93% z@@WvT{{Fukx_k{5QXpu7@199a)!(nijxT`<^|hWY8@%GmO*iqWzioXkUqu31tG_)j zQRlIA^&WW+GU|JGfxi!6eeWQUfg;rR9tkoW=%jA-TCM!4Uif@DW7742>egxzp5$cLx1$i0B&vmlC+^8q^ZVlK5 zE=5&tbiKLt#4C{h5U`%u%S4HEBIA1EA7EWAcJ;)bJ(FOb-S@;LtT{vgzhY%7v)3bd z%kZTtH|%$QnAo@t_5Kf6;3CO=e$rR!4e_54;#yE1al|A z#&SJDwiThV+#Vo(0k^EQl47MFpF40^Ok0_3F^llEtaLB}2LiUN~%D( z$66T0A6VDXZy0M0-B8C8NOsOmV=pQRil?3xd+BXeU-PnCX!A3id$|@r7MvY3*}L&a z98tul*qqK#KfMz;Cl)W6qe~czZBstic^}=qnBTzp*xRy=)5KwE;;1xnLz=iXOh~8^h(i|9tzIJwwn8n>F9urVYnQ!^3u?1N(;2FCW{~L&Rfc_JLWleNJ|Na*dTJQ7hO8jRlrDm`5;Ro!# z%`YyBZDA!3zUt@dy25JrZJrCuOd!&Io7aI{1LTjsB<5Gc$`{HnjwyRrSzEI)E8Q2y zE_{~^Ypb7Wexmg0`zebNzgH@9X%)5lmdLb3NLQ^@FKe-44nq2#$eRef1VsA6$loBp z0~PuZp_eHS)*#cA%gIhXA0d5+ux>V;D-h|^gxiDk6rqn59tv_Gu;u+_4H_yET|OzA zKGx+(DSHvFiLg(Q{F4ypfy@HhG-oB#TTnw23DGE>a_b2DbZQ2B z6=3O957HLUueHAN=;N19u-G%s^`{g+ee!NF0ZY^ zRH%wPlbE(aEVcb5l2RRc7Kx`MwIVImT4BAINO{Z~N4S;G`*2qxy&MP%%bmctYvOiH zg{)Q|uIZ6f`5vnB%UYCNMDRs?en9YBphDm8^lbDtGP7l-=9&xP(|0_ZUBE;SsL)48 zJs&Nj_|^-XJ#ztk`rzmm@N^NMBH;Nl!SUiN3kw&EPl>fJJpTm>f2E>L#mG#$3adL^ zN%0!!jBdb^=$D1w=F=+6GGfaefc~ zcO)*W4Zub*=){=FF82K!ekS5MYA#em>6X#Pv#*5HW_cb?=fyvQ}#R zEV(009RQmp_XgQcgl5VA1?dmi{ls3HeUeC9iO|e=DE@~^Kr`bLK}L(v%=jFTvw-~m zE?ie40=vJ#JMxvZ#H={=HFmC0eralaISS?hHZ}H~(Yi8>oi#|j9oAa`LVd}pRm+u+ z(w%nPj?5sr_2W)|;zK*~oWfK)@+b-(23o7Ip6A%us_U?hv78mwdnKa+`zrh|16E)? zXM=Pi;|lD@u&xAXG(58!t)$T?`sQZtVirXSL_Xt|YUrx&w)mclTqj0)IYv|s-r?@- zcyX~^qNs1`2phd#=;C0*#XB6K;o@$wl4uMmcaL+o7nuKqBaa&$R6kVcdplKsAlFV* zX&5KF7{)!+Qp31^h{=z@p<{!G+RI@t%-ad*fA~o!1`jup(@tY1bPFEIX#{sGKJ&ye zX2KT1Beim>!pL9cG%k3wsY02H!#P0zV@Hn(mYUQ4i<>jEn`=YC$0{WCI}9HITk7id zsUvXV*MOD84ng(fl|2x%Vd2nAF%z(1;dqdffS`70M-J&Y1+3r_Q1#;-W=Uu~KIg-8 zriAqE%m0DA02DrO{1?Ar>Cc@rr*giEyJuFM%9uER$T4y7@!(P)6#eY5*o7UTq+#{L z&F;I30Pe@9Fc-Ul=w^sRLHYxAuftWLZ_ataQa0$(F1D|1+iV_^`oi2JFfIlPf4JaO z+$jwub7oJ(iq@Oak9l!!opBbpgfUf*OVxI;El14u^mDkL_bU-$l36W!R`M#ccsw7obXA zvghNhq4-)hskQESZ~XfMg)K(LdXgmhTp1HoJkM})lO&9-T^Rc+Gn$bO6Olazh_Vph zfh-sCD?9+i+j8vZfJauNEBcxFD;5W=Pg zUPF1JD^3WsJ>20mDbtX*9+9?yja-uZ zsR5g8;!&_yS++nxmwuLLa3c>@q16T&I+%j+)L?@*RxV6qrr{B7Ld; zdXNP`g}zwtg-U|QBou_@{UkIMub1I@UPAhG{Z}BL0fi%6&G9ymBlxP8FEfHl%E+72 z6o$=nU2%@u^C-W9J`gDE=cK#Rh+4f{ZH27U*^~-zN&|*!`!%hKYNAVF*%%!g0wj|r zLq3_J1dI6zp29Qf3c7VohHMh#dHFV#Gt~1k3Cd{_WHs4)@)@eN*fjacsU%nl*bXat z0F6pOb{!!~Ku(iG%lSRw-viLk<}C}7B=cD88QcF6_S<-E2r`ENHgEBqQQ$EzBLEZ)`_GhT;H6Yat z4L4+~-;sth@oKVw+k${-0>thheMB4wF%skm5yK(ofXoD}efH|2pq13k2sgM>>eN0z z2+ty*aAV{4S?e-E{xery)EyT}kB#HKA?qKMqDki7GqC|eW;|1GA<4yaiagWUk`fx(KC9SBQ-POBb&p3i`No`F?>*mxJIL z2w1wz1G!Ly(&bT*2Sg}cJ_T70Sh{$1ncx7IF3Y4&>C*IS&b9%C1^<>V8@i;hbm{m1 zq{|k=1N${fm&}-@lXTFz8&ji5Q^w&=Lq*ISG<~*^-I}C{zk6En+4oV0bmC5Aw@lDU z^A8_L1LpKt|7it!GosQNumbJ**=g;}^ZdR*9|db~K)>2u=<|1RjFd7`s`}yep1qNT z8i&tG*YG|Bh>nK%4P+%yaW##Amx+Q~mAaiPH@Nm1gcjp9{aRW_AX*6VB*52GPE^I5CeG%Iku(Ek9$dMvcHZKG@8?dtJrMbDkCa$yRD!Qt(ufg+z2|-j{&qe{j z%4Tqr_q~TO7XXny_}lCTxPjK&(=B>|D8XXY2+xmp%U_G( z{b3sq|4EXwg(ojm@^3=ZT|%}l>4mtYR;JC5^3AV0e4kYc2AWA0aa|1Myf%>>x$$7D|y8dQL{kI3UPx<4TV$uGuo#=7|cA zISoP6>!ZRC-j*{FpCJ_$cM${6$}mYr!?^wRgtZK>xiDP>M2|w;4RQxiXzAL+wG!%F zc!oIxxJg91ZiuSSk*@3TdJWN+r0a5suR%VSu4`Nz5?yE6yhAI6rzDZ_SQ44rqVh+j zSF46iZsG!eARfMXR<3N90WdbX0Y(kq)`zJUu;JTQAl-mMyT%4&#@sX+RT@6tmV~b_ z%r?CvYJRU&Y4|u0$$g|s!^aaqjsq$*=zA~``a?nt`c6ZrVc<6t#xsFJUsnv=z|Y>c zS7`w1gJm>OL<0j*v;JCyt_IBddqD02Tvfd?3DjdrO5Gkc{X$l&sy>dyQb}31d)7>_ zvBH6|tvU^5`x`L53|O|W2KiP}t(7Td&TP^=!Q#N0ULCa=G6;Np90&>@p@O{;ZnkZX}6)Ig>bd$7r z(}FGZzLX?NUjk*i{M*fhsRf!n(fS|27J5Bf6dW$wSm?b}d|K!|1)eeD(?YN3%LJ3e z$3pMIo8VIua4kFw#HU%M=PL;=5FbszB=M;UcmkeBfx-+IBX2Y%E?(zdmDudDIBiW) zyw1B41FR7FMWygwrGJz(p+CAWY8w$AGnM8S=+x8AMu zw!ptAKCSb12H9AI)_Hq^YztIqo!3ieOghK@v=bDh)_VKH(@#QL>pc|YU=dpD9RqR# zz)F*|IbPZ;3}~F0C39>tWQ)G*C-L-{i)O>3?=)0S1#At?b47v25`MRab`h)>$O>8o zt&(h-gs_N&sD7kot6PYPI`o_1x(+CumuhesV%yN!WcxZ<&ajzmhcRCEY2+T4>=}(^ z-2zMPb&s-ipM?CLq#td1#jS*VH$I;rxdNzqJ;fFUV#`-?LTe??(XFf z%(HEni&o*>4xZM4-Kp<+N)m3LH2Ik|yD4bhsox9so`Bt{??tlfi1<78_k?v1fb|t! zjphY%!D`t$v&PPC4~5}iAb;G*I7qen`4dw_VPcA~`7oJyk zl8`3SCASeGU=wQ3nOR51zg27jYZ0)CwP!C`hdp_#xRH1P8|Cx_*%q)-ju+0ZBkV^x z{bB7VSuL>~3UV-@pAGK3d~O|iy-QyIcH*ZVV>B|OBxi#=FO(0~BlX3&T8tXpoetAf zzy^2Mfm|g*gS#g|mI5}o^BS708|-6U-m_2{;d})93dw75_Y=quK%;1vuOsiHUCJ_Z z31HD~3DN?f`i&T=fALleRb9=WZOLII{g<2`cn1;GtI|zSvk_o3G|w5WBjaai zLt*V{AzP=gL!x?9r5vwHFOp()3cKGC1iJu*q0Yi&xiKDos?!~k*tkl*cRuc<7z!Ki+^dkUkv<3e%i`e`l&Rvaa;K#Qgo^YS-s3f>&2M zAHhoi>q@lVMZxLfqbvPg)mUBW5Ab{|K6Ry@FB4oM zKDyFn;!~^+vmzATKp(#=uO1)wCTE3FveIXqTy4(dvu zS5(xM_CaDtz`D}?K=uKwEA?XZ7_ztCb)`q(f4BtHl}-RTS%kXMvq8=TtSj}>kx8p7 zeMmv7E4>_^c@k1rdOOIiBGi>W4zd&o@~xcpt}DG|t#q*=hF(Z{z6Q+4I(d8gDhgi) ztRwaO3`djni6xr)mr<~;lns;?Z8>gtbnG7mWi4o=p9-(Nhj{4i=^D6x1S)bVwp_3? zYQVfzor?;2ez|$SDx0i>53=yHXm#2YD0_r4V zZ!dRrR`F6%YW&;F1u$J9DeduH1ahAUy}eup@-$#?FTFHhr$btqV~2F!#s6&y=K!E(dF5E_MFTEo#{}Z#~MAO^L=M+D^y=;zx8o=IOdd_HF8Ta;bLs&Zk zbTW4x6RT5W@(Jp!E7kjp;@nih_&e>BUzqYKv_G~%K_VQ#_VyW)Npd=7C9=Hs9;8gv zYwsRdvW=|ibP|*o$|hJMqz!+1<-G^YeF1yreF(@wBJ|386v(lFYmR(MlmwTP85FQL z?juY!N7G@N1Xy$A*|Ndiu&Fs3BR(}p3*ot0d}@w7Uup2H_-Kx1-V2|aqj%tWLwstE zJYOz&Pkb~-2Z&G2(Qokl3>3akrMo4YHR9GF9q)2F3_RvjK+}7h+SlIAK_$R7NarMF z!(&xWL=Doxii{ehjgi<8um-6o$hLqrNM4Mu!^z@$*C6%Bzn=uuAPoZ$)Xpm8W zHAr4MGHI3hJr$%Hq-pR>m5>^wi$E?Ap$6$@kQ;#@e_5k~Uw9-{x-4aEqHkk+&&eL7 zB*t+>lO|~~D(?rZN%CCmR9c(gHA&CGx=dEM5~D9K>lX%pkr2!U$K6j%RASzT>s`QJ z)*tWKcwOMIHnE&dGKNV;FYCX7|0}?Z@tkDq+A_|VzhV6opm=x|_p;uusj?n6NDORN zYXjTbMb5yc_aFzDfn|w-4OncUrIci3;0Exw2h2dv$uvBXb~4Vu9w(Fk}Cdh6OpkCy|IVGKMXKqJtsG3TyUH1gxzUEaC^0OLafI1BVgMnO4t{* zu=p`cnfnjenB5N#*;a@n&@x9V)Lr++q5%jl2cd~M!e%=XO|kBwv$2kx10!* z?f7^UV-^9nS$-2e}?HtNp*)P zT?7K;Hi5|BoJtJ(w()2h>YNx2D)@Z1`A)KR23~c@wFatGVUADu=8ErBKBW3C&YR)i z8Hiqm*dC-8K!!|l>~A&YbrA}c^dwL59_Owk8xy;;NnRQCaLUKB?@pD5;$_ZRyMM0p z0?OIqbt#`myw6$qb+U9IFocS-(EfR5t2{1zt*J(-@fiPD|?xn^q3uFoBZnAs$V> z-Ierx6UFV-9hUWAr#Sz$TAC9RFJJ~RIR%Tp;$iF$8@pI0^x@kO@?)To6H{@@o5;2PU? zI1g$Lu>bI;9FTt8y4-7R_u(>JmjZRO@S(fC&id_W30*d>c06V2p>eQLa4$U7*EN4i zma0XLTjBx3Vt?NflUi|Cx$Dr_gI75cyrH7=W5}rciqu8+Baqzz>nc5OCio6sb(J=y zIT-%~fx^LS1wzI;^V$vZq2#Lw<@&CJ3B@{$6A?TXFf(J54sgsI=r!hc=ZaY-Er9WI zz)X7>16bPwqsm3on^oFfzL(a62J}%`VdRkkx~vj zetnmhw)Lo|Ba-bMSKaJmYj+d>b8t-Zoky2~-#(26x|{gUN7$?k*xkgtJxWsq*xkfW zf-C_l^c7*Rfv>?y1DEPP_Y@iq!|QK&R!c}<&Dm=yYb$_#HOC8O5^--8m+TIcys}^v z?8gF@1yeyL1C|9|zGNMFp9SZ`dah)Z1y_SC0Nkq~FI^g(D3je+bMA%V4xm`+(oFsN zd~8u)GNvpjwn(|(>)mOdj!wB7FZDjCvU{5k0prIys{-QQX1lZby`}WvfZf^L>@jxx z0QM=Ilbir6uoB?T=0}tr`V>x2c(w-Y-sXKl_6F+2X7@Hvc9QIrlBB=4`EZzqNUHxI z+!7CR3Sjp(djSpxB9PO?@GE{|%R2sNNkE^%nFn&I2;JL!E69yNVXg~m;Bwn-Rx;<# z$)$=V_v{a~|8|=6Z44(h=(_POoG`4x$I?h-)w5*s=S~~Toie<0R2Qwl`E^2i42a%> z*z|GQ4WMErndt?h;0FoZQ@X)cYBt(Y#)iT(7>H^hW`mqAq7>p)kY|9Z7fA=NfsX*A zp-FjW)94qR^G~p2KmuPt^n=(Ds1r-u%%7|_L5%~d@;^7I;Jd(5u`DV^Tj2aK{&xXU zM~J^cep*`~8&uQBHMuCto4}S&@~I-g1V(}!4(z)F(qe17Bgg_=E(I!H`?eumK0PTl zmqoSvE+g_^;`IzXPXPJ9hsJ5G{vfEDfmgNb#fg%n=0|O!Cvjd0_Xj|<2;v`*-$dL3 z(d8-LH33z>e9<7yjVwrKXOy(b_4yLUt#}NAX+I#^2;wA=<3+3waUIB&z`*NP5hDqX zC@JRNg~+|A$5I{xANj=jy_#vB`w1fV8IR~)9xo#MEKn!e-r=W2Y!_FEEMjpS^(>aA z3fEqg1uJ&5RqXnwd=giBA2q}$xI|&mKppipHTS3(sqOuOU_S=B97!|i*&<`}?QQ3$ z$sGWzJ{_umv~=pFZ*l?JNO980{qUcmb@bJMjr|rd_G_}5;&iQK+G{Yk;!awK=NL%{ z#LOUYYrN-`Oxl`l_U|(s94uxUv`qXzoL})0gTP_Iyr%M=iy@~2haMKpYc7ZEGwij% zq5sLjWo2^ce@bv!xsX~3Zh1hgCJI9JyO&pd{~|Hp4xb|tJQRq!L0krMfrt$u-UoS3 zL>q|hma!=jFl}!;Z8%BW?9w;AwrQ|T229)4AXkWxw&y?|5g~2aXDNLUU1Zy;L|Z>; zySRzj)ftuz0n^kUWOotLbQ;J}BBW{K=ja~*vupDM<5<#j$9CP}?HUftp@3;SALMKi z()Jk0T_U7yljnnA1HkOsDbaRv%C7!+?*^Eru^^*FNYh;)^F&C~*caFn3Yc9tC7Ldb z?Yh9*^)@W80H&?{MNYo~rmY`HPZ84gI>@tt+4Vr8?T$h!y{JsF+s7oeqHM^K?80M_F$^F^*TNcjO%!%C7B;yHJJ@r`?8`ztuN}6HTr2% zG9(T^_9<+Z^0D>+IjU%-bGFSOZBhh&H7PRRGDQ$kU&JK$OdOCMna$@L@#TMa31a$7 z(ti27otL#9|2V>0kI7fvW!Z4i2%3l8NXm}G$dzi<;*N)b)f#p(Se^Nv0@hJj&_X_^ zMMH)J)iqTsmQs$IzPJM=5Wmc59@Y?ze1jBfI=44fRPMU8)7-bBS6^?)ki&y;my+i5 z(8l=$m~_KuX34rtqcb|m#Y@7{s|aTm4Anyhj1G3hspF6#!-DJ=#a2`U@Wa425FXSF zYyz+LDweNeE?sqBSbHQ@xcsY_=rRlf6Gq8ryP;W049g?YTN3+kip0@jt3i@DC?+;P z7$TVbTN}1L-&@#WZ%jP^-f$|G*&~=1b)1Cf9rZuuIbMfz<}@)#Ii`)qXD7J^HC?X4 zZytVTK=$`chaGVaY977;_nRd%=6dL+AMsoS89mLz67GJ+%CTpA@kL8n$>9G-Ku(;w zr96ULL*>Ac-!PuIM2hM1;(x5C*Sx~s%TU=74!kWqQ~w79Cw#kx1%_@h)2Su#|8Txm zaC1$5MZ8vz4R}oK#-jp;q4@RQLd4!YzTUzG5Nr$*waRV&5aC2e;q@A|^(9r`Lm|Ee z`4Xs_UtlFV5!xQ1%tThN@4-2`g-7M9bYVcg`_{2$6>9=(8S+7s?y(bxVnGP3#}5i@ zC%n2KvI!7v39%Q*9zamBVs#K4v1Kg9wYQS$klWz5SBYN!dx$^rKON3dK%KnXw!rx( zsIP(E9Uv-3e9hn^(Q&?Xl;(0n&=HNpYyH=l@&iG|w6D0{(=kTDHDb)=iVul#5nemM z)ES6wg}4!9frx7$J_Y#z$ltaVLj2UW4k5vH+a6qT#o^EHHDz$>?uN3@8?2CtJ2K>q1e;DuEwf`-lZ1y0;Sxr(MX zl!vxELL7qJK7f^rq22M~$4h?7Wz;rT_7$O7xwr_P*?^UcJ3(#(TB}^l=^hKQq~tJP zd{su?l(|Vcc?qExfS~Z^TGmk&gNklM=C(xLhR%jEmFuGv;{)~BlSjpqWPs;nyAqt) z8JVs>{twO)5;nI6|J;{6DvtQPfs>Eki*v(F+u?9V*WWb0MOcJa+vbWeBLc z;0<=Tq@N8pu5h5k17?6{uxEokFO3<>Lm?l2|m%bc{+F#FoB6QI+U# z@I+tpI0%>h026In1JBt|Q-F%y@jiL0IDJ_|kn!I|#XS_w6C^&I$7?Vy1M)vQMwO+) zACB;=a1)j2ueh|0zg#iEiiDJR>O#EVcb*LF9M&oh*b*!^2$ozw9-Y*Jc$O%^66XFK zDO5{hC8Y^t+cLmfkZ+w{&RY|c#w|!4OsxU^3NNi?yb4F*fmHN-d9HXzC1OjH3Rs{; zEe*^r`>MozhF9Ukf6DT_r?eIH_**o54G zq*i9!)X70%P0GU@ubND%>HXcENhp-Xp!C${g|}U5e2dO60ZR?f##$+CNoth6&DsfI zhI9gH59Ckk701-dD$B`a!JFI0PHd@&gBh=4w;ly$01|zGC<`*MT~T zv~7oXlXuVpwA~D1Uy$8I^n^GUTKb3v?G#*)1fzeok7L1SifHq#^FkY=fa+wy(_(V{fy4<04o3oCVXdG z1l{}F+V>dT16BZffOH3nx2IxMi#i|E`%>=Cjl9^3ux2LeuaC{>ez?py6tCfEJXAsK z191k(G$3AQoSR5JE~)3kO+S~E)){Yx>3T`Ef_NF^d7$on*ar6bgVzO$1gnd=10Zr* zRUG)*PqDMs5OZ2X%xUc~r!~VupPq55xwS&u1t25TI*xRHkQt2lU)cKe_b@`u<5z_F zDPYZG#ryaI);w+ovN2%Iqt`%LLPOF#_Qii^38;BI24uJhHIFkv&IIxo_loVZcP3Xj zB5o5aUci7w&Nix@Y+DhwKlOcV`wOq@k-r*&m;p5fs8hJTuf?UX({^!`-FSebEjq-sk9r0DEZPqx(cV_k{xodA z+XpV%H=^xYz@q&a$isj|JEv${biFvc($mrX0?tn*s_14uWVJ`4if&HPwPb?VjgSjcb7vB{uEmMzIKOn{|JO^H+&#vu>Vwa}Kc0x?YO? zj7TM$bz9=!LVVh+Ynya8gz5<7FLdGfO}hC>z2eBIFUZeG5yf*;L@(mx8ieBYDfa=+ zecX;g{$b~?=Cklrib;Y~6iP9dVmaTdEDQ4MId_eNirb`^?)6MnLB5xBw^fT1ntwsJ z;av7~9d9^)^rsBccE&3@h{yKCcuOEU3Su_MXrS#Bh>k0QpdM&D6Jj{X_CW7TA#!7Q zM0@erVkM;&sMXkX#rA>wO(mtvKd-!bIk|HbK2O8)Bw$0+H$YwoY!dTXBIB`SfWRc? zauhU7Vpbva2@vGp+c^%%hAI~JFHR4gTO4+Ag$w&vBz^%b?A%9;<+k~W+g$b zw4f@#^g$gA(}92mH4@}#z=HBJECT+&K}|$p0zgoj@Maw|H|56(xb;fXzVUqb64++} z`Tjdg&dt0BqzE34u=JBaXOUUP`(3eg3k z6A*QPI09slh+2pnK^6dYQr31qT)u?*A7D8@+6BgvfdV_PZRJNU=l}Z&tL=cL(IFrQ z0hUHyhBm=T|9f_vfWYy93+nbHsC`QmROJZ-)iCFp4(Dlr1>t$QM(qC$;!*@I23!!W zb`q-JF(m{sYx7rpY;K0>M!;gT803Dyrgv=;nKMe(p5DCx({ljoJM(XI$I9+PSW(|p zIWrWW6~OyIZh#(p@W^kqv*hAjj?;QX64D(dh+j~BBH|4R5Rvx*UtbHFdoyY59{=V%9n5}Kw9iH6)%a=hQ0|CpI ztrD44$TW`i2$+rpocehQ>o2Ch@^!C%0!$|Zrv7Y@GXYCrFB1kH`}ab883J`Wvww*a|oA?STrQQIwMCx9$T zH7(ct11yc2ge(HkUW^5zzu=n-auE!f5Y2%&<1=1D19jr2(dqw3`qj-gWtFG^SXpTc(gv`y z;)S9_Jm+HCxL9^apc~-Ay2*vb_mmaZh}>p_J|jI8mW8n^tUCi12hW@d-d7wNty3QW zlNPe*^_5?qmBpAO;_|dGwwXs5mUknOI2y3Ln*uUPDk@GP^@{&7c65F1QsIj)vFs_l zau4u`Zs+k7>~nzJ)pEX=hjn#cHVWF5!a2D5L{>*4b#;2h{;mc%$rA6pFR5`r?MZlV z>H?)>N3dkGR{bS79iJ*zJS%}hw|!!}RM@SitR4qzal@4JaD?#EB4GZSlzVL4-bon! zW!!<44|wA?L4SLo!MH=A1_Sxi_iYH3?YrGsi5)KKgNhq`L8=_2mD#;`OpiVwInKf> z`#^c_PbJN29(A|j(z}d^7e}WIDj+LE#}TgqsSunSL2jv#&P^=#SXpdM5FJ*vz=t0x z{8<=#4$wwscy1OxoCYuFjf-U574TmUw3U6gf!qSPoV;%LI3(HxMR!<>RRm`_`8Z5V zfQH2S32HTvKR6YYI0h@78n$6Ltf`N|@T#L#u9SingBBn~z+&LJxoh6Zl{q# zgten&6_ag2wgxOF{{h(*K$Q})?!U1lt&+nkoT})^s)pbP!8#DI;5{c_x^^--C*yix4UoThZ-pBVT#7fQh~)^m(wkqHat~T-J$tnaqya05^#sxW zxzhGulO9^zKJZ&=9T2}|s&YBcre0Y#C|9zF810>_BZxH{=LRGmsE@7N4#)EUsc2&A3EkYO7 zM9;)VEtq`a$$rP`0E(>eYy{CBs1t{kpgo{=1@a?YlVLsoh<)QE6Tz=a>3X@dfeZa* z!y(MUm5#?CJOZF~*)FAm{9!#rt!7a1G{tXjU$N-7NYZEI*6*t!LH;*N&Y$XtzT+ZhqF}SeARZwcbKg9;uUyb0<67Q4)OtDqYy6>1|B0z?AN&M_z{8c0a|&Dc$OqV zy=FmGuJ%D?f1%j{ET|$#Gr)rKGF(gUr2jprjU)iLpemD~zE)75SMIgi#i}Pv+X5C; zUy%O*)(W;rWTO1qt>7Ur9RxV_8#`9sK){OnC0_mUFdYY&`pF;@0gH*3i2{%PdrU4s zU^YNdYHoTYL3NCSD*c{f(0D$78|>Er`G@wFT-;#hm+sR*#Pj*S{bLtya+Iz$wU7Tu zs%Sp{8`9qaHlN>p4I=`;=JOALTrEQL`Ax{h7C=t(`8p}FdHjVqjR!237rQ{X_*;RT z*Y-^ewgT0Hs$K*vZ90N<04#013>#;i^uMP~4+ORWTu?tILCvtBDtG$91+@oEeE|#V zK#;+J1?6S9J?Z}qY7_#;0xqaS_Y|t%l?rOs=2!WkrouECu%ONdITx@3b$BAP1ewNF z<64-m22ij0{3(u=ZG5r%m(iLG{*TY{T&WJ>=g4 z%qq`I52`IgjfVIC!1M<|QF<&@l#0(gLcPHusJ6C!>Uidkucv(SZ>NbBX(DhYOF^+L zMcfi=%ZynuF(|Z6c~}s034*eyS-vm3ERBXGG8?axMt8xq5OC_BOjvuE`pT!g`X^v|3^4Vt zfxH4(8T2yTqvNFiy|}MJ;1hsq^J^+KKO_W_Co|@%3B2D-rCEMbiYVUV2u)$C=sOV6 zT%~w-ifQB6oy$=t@a^xE$Ih___m?Y|-$tvnbei zCf(uj=wAG8Hn0J90anLh#H7_AQuA_Grne^ zEGZhe2aIp>B`=@Vd-_{K0OTb*)` zWzpJ6QwkrMG^V7%uA9OV8~d)ogr8*whV0+h{s(&TFw6qjM|U0M_e>>!aZrjlE4G3{ zL@pIi+&30i{#}#yDV&$`u@WWzAV15gvURCX9AUdm#-{}G6H`QRLihC<{W_QVnK;C7 z{-D1}<9>KG{}aVPv>$}7w&*Kj2*iaTX9K-QL-gLWHMu$xtoFAYCxiEk6|qr>Oe=iQ z5C8O6iPuonfH%1hhi=85lI9-jlNM4ZOsci>lm_T)ao z>zf4io`U+mKYR**QL=#Od5FzHHUaV_`^To)K)qHsnv8H7cxf&TKQ`a!H#F#= z`~e8)Q}%^_2F5~ebweuyLG3d{bW$SQwA^Gb`5oD>@R^9*I3W5E;wF%5M7#>|D#%kn z)%)u;D2M_nX!^gfio5#Q>+m_fyq}1s%J&pf8s+4-^JDOX7Pj?L!?( z`&!*as$;D2Z=h0pP1CdgAhx=S^m0V!NSCf6eHP>?!0xMQ?PR#vSMdnLHaQ6?dso7< z94Kty%0xPQ?HYU^Ae#;)9E9cjNLcr%{(#`OfZaq|K|@sr6jnIvRl2P0U^H#l;CnMN z!OgK5scY~%A=w_tf11t(_TEqsc1X;BP*MIhx5Hl;um+z#Nb~}_=;DvvlazT)Y~OBe z7yKNL_Yr_y@Z(uHTOtd%;OFo^QKbuhu7u|@@u@m^z9{%Zd|dF;O?*nQ#qit<oX*=(_?;Gm)z^~3X(4YL448J#KdHeRk_U7y*`^On!49#IT9ZLcCXL(Am0FX zua6fa*()%#-reh?*<&eS_xf}M=^#S)`fLrd1z_K1^3uGkL)u=C>rS7&@ZUoMy3=O_ z$Z!#A_@;xL2IOZs!`*B0{HCeWLqXML!l6r_AZUm3!pg!~ijFRoy#x)jrBZhZ-v@FR zP^d^XO1{gf)lI@%CW^L|qK~Ryl_Fgv{4#RSOOY-T{sQDvDQdm8BGR<@lQa0H^%+qh zABUh0QD+r&$veH_*)AlN+)7%1F^y@*Cp(?H4hIy!NilVIOp|sD@;^9tbvA`!Dm~B= zAA4ZaxsGD!Ai?I&|5#fo(Kf~t5VPYO>$7w0A4N*XL>`2=6tE*7M`dV^0XvHGILLg! z&Wy}<>e!1y5^-i^7irT;qLC%satoM(l_2kkkm`0>5P{B&JOpwBVA`%sv<;QEi<@-y z+H{z*9bnpqg7gs~ZL2|E5+Q9rQqbN2Oj|I>73tvA*tW=Pn?m<@3Sipq0=Zm-w5^|~ zVFgUv2O!S?rcH}%$y;)9I0GPJXiMG39 z+m?E5mshYf4VbofKwcFgZ58Yu_)~`p+FpolyVYy!Qpq< z`0JP;HwW39)^InV$IVCxdR)ju(Bm~2mx(!ip5_VYaSr8N(Btc^dFy%`E<^6+jReqR z%}1=h13lhARM6uq9)dv8$p&HBgM=3jIe<^jOkg~46L8IDaSZkR^GHS!``{by7rwH2 z>|X15rkZ9R2uezFM`Umavq9gQEnA^u%iupXFpI`}%OF$PvwXYq z9_4*&dbMgzU!Ls}?$8Ry`e?gskMdEKThxcWS`DuW;Vxavt8Y!pGuJcdSsx-(U)>U3 zZbwr9`5vKknR~f(G-(=?*O$qwe1o98eEafDC5i79XJpB!N*`dM$}?B4WhgV5rUls^ zo7uN!TTHJqrg|xuDASs?2r^}|$zn}nIo(9pCqgm8?DG1S zvHJR)EN{LRTj{YRXA83&Z7#JMB}r{p0#a04`uK^fKI0PgoY19ft47|nvfL6jVOTGY zs-;dG)%CrIOEDQPBU@L89V=_fGi}#zTSf6`W65v%E8jYcdATxHX0=@_M&*i8J9tzi z98bL?U0StwBEG;-2|KLi#Hz~%&N|c5kewY{Qzo`8--4{_)R<$7@?NbDcd4;qOUmm; zYnfJHqiK!uq&zOIip?gZN|`Ub%Ky%ZQY%GDlepk++9j|uZ3&^|?L|a4TbG+jrYn@x zzOH>JpGv09shB}GinocY1Z|Oy@(!&cEbg8TLh9oxM}^A<-D;xRMSaK)t97b{C4HIb zPDU(C5y75@y5*9L5aImnrmjb`hxGo8d9ls5=wR0EY}d>Hfy^R zJ~g2{97u*x1Cq>X=aSEr^!l}nM?+BUyO6S@D&ySgkmmE%aD%nWYDX6fr@YhJMv*%~ zuwgodRZBKX*F~BHDnSw&>CsTLHc6bVv}wX`$r>m9X6ewV3W<$Yek|F# zCUO>zFQJ=nZiP_YM>i{_XtjEhusdrNcK3AErkhQIarx%T$5sv9!`3M^^|`qI#)-cT zbu{ixwoO+_x>r@lUadw|s(b0_>SldWJ;VCG0oX24>mnoTdYNNf;Nq}SeOzx97qWOJr^zI!uTy>bSPvcHz-*Re)D%XCo6?HbO7+`teDss}pF*;KA z`v!__0;-oXbC634RfEB`8jLw?ZBL0t zaV#nSoZK1f$^)jV>paP&SW-O3C01DxkGuQvaT+`k zY*&AG#Q0FIt?NT2&&kw4(t;O;ak9PwkBwB=1D@{oPfhpnvDS%kVON=%qz=(yR8QB? zu0E3E9%Y7?rKHyX9`vY>;%-I9VST%a&x(wd;yBi4 zCO$8yKB)>?knEmIw3WysX{>n*fIV@ub&iXNYa)+r)td4!6TytjVOc)QERW|b=f+Bj zN0qBgGDBSF#fGGtYo+G-VQo@X#Wvep)o1`XCoCbz?dx;p^(B4doU<140?%E){&w}x zl=P^tNa}V&g}5-Jx5Oe??tq2X*81m*l9a(?0Tq_ibnOD~yFx2XWU)HOOHz4rQKP(J zW?@-#sY(FiN}svhfTQWot3h0e&kD;mI+_F17b^=m>u0iYiMSzD zOU;&lA8Bi<>q|#fTEg9w#M{c4vS47XZ(D8-lP<>%HEvm#J>3}HinqplX}8;$P&0C* zwY@!Tm~suQtqwKqx+83uMl1{&5|fN~Dy?1rrwHD~qhUV7&grlO`nXoxmuuGHTgH1R zqlpUzN0Rq?b6sgxV>~k~k2~=D(gI|w1ny7eVB7#mq%{+@MPzy0r7jL>a%G+sg$LFO zf+C!np)L7WU$x8+dM$A?76cD9u;OHO0YyRZ@H+1O%lB;ACN=AMBrZ@%ja93~!p%BS zk?Yb_+Pc>Bu`n5e6EI)@@Pf{acxix&hTjuDsI*@;_IuLTL3*;M6gxM=A{b6?rRtA4 zJY!8t<4jZzEDLQImL+`&LoUy*V~^#D3-!6UD!Qt?Enz>uR)Q(oFZgJ?e0~wdu1Hy& zU&7xd$IGeU;x_yhZ@aO++Mpg~%BNnflI4fjRNHalct=C3S}gttU0zOG6h|x`7QJEY zu}j|?JlR1PZifcmg~#0T}aWpFBu{)zRw{B7KWOpVloC_)X(45vlO1jmw088$6y zJS^+$5^=i8H_WO}kNPqItkHVV4Ai9i8dBz8`WN*2rI-yH6`hQY5G~jG`bDRbhKY2r zANsPqgx*7X!|;#Fg8tEw1^`IgOn2}pz|}w$wvC$R+ROK4kzeScO%+j%*gNQ9zE>X^ ztNoZM)xWB3+8f?ufa$>Hz(U|P;18e-sV#v1z;NJP;0EA%;BUapm=+F!HR!_NBivq( zzIqJS<7hoj)?>OJ7wB<~9t-t&LXVg9ctej>dIY?74x8#>O4p~Ng>6JiL9`iIW-C2< z=&^$OpXn#x{q-28hmIeHC+YDQkCMrHoXI15kscyTZ{?A>M~?^fctVfo_0SQy%yJ&N zuXu!6)Rz?$Mp2K}dTgXeR~}(cVY>?3M~`889IMA<9+}hin5D->dR(T*H9W#Q^jISD zF+HBq<5fN0)?>LIpX>20k8q71A!E$2Mh_kP$t&D^2Qcn|#jT$ngY`IuN6ASblj2cPj}3X0=-5K(4m`^D<`E9z zk<~eX>@j+b(_@MrC+qPOkJ58_lw2b68j-gOyIJR|ZY9@!6sm6F({tAu^S zqvTIvN}-Z0YrUmaddSF3OR$O!c@%czQ8`c^hw#V@;}LSbE~~h?ARqZ#(K1hzg{5IO zU%E#&S6ZEI-j$cpA^W_@*L>u!L(A|6vost$yX=STrqNYlvuxdTltd+Av}v&Lz$4dlXR8^`OE`TP}-14{p4YBSw`h{iBT<0 znd|fdza%VcXXzc4W==s@<{{!zLTC}m>C&Y%^LW;x`Y-84vXB55o;cf5EG(^27-hYr zc$!ctF~c+87LJs~M_ie0Q(BABQD()2!IrvLW&6eH_~C@H=xZV2(#${O6}2ccy=<&9 zuvkj{4HaDG-4jE{q|m~$X7U!6xt>>y{9lr-;9s=89#S1;-k(s`OIc~|ig_I1yAw#C zSh?K(O}T~bm1mm@TdGIdZQ1NeN4Cr~D|<6)->f7{(myl)lWdD_y>3g)xm0@+No=jX2GcTJ-(X?zy<{%S|3;LVm&46iGl+FBB2r;%v=CqRr_u|jozG)K1 z6)ozb%u_WR%+LImXTvx9m6WO=ymw+*v(hlytXZ~L);yaVm@P(=nrFL~^~x3pXS)uz zQU%*JncGUrGS^R{sL8xi%e|;$GZ8=NQ8o>IrJ0AOge7_DeXDFXC7^j6@v&yWCzHqG zSIo>0d&SPZDEGHaiW`9?q4(?;dr}wi><9mwk#n+&c=IHx3(bht;|IdAs+9zuw@MRc zo}O%pI5t~}RS~kT;M_ZfC|P?%URI5b(c5I{9a9?B>{orQ%bOjU%=6}up>~mAnJdSK znX0lYRf1^b{>c774O|kc&8#VVa~&(P>9%g<$Im~W^0ezNbw7q^{&=F2 zP_#^~&3rtuA2czXpSi6e$zF6xHdwr-^lq1A2=z3FkFAYbA3Vx@SGp{5pL2@x3cJ28 z?Uyz0(jCO4;3S#J%%MfHAaAEpQ{jk8oA)Xy%Wj^TH+l9FvuY7J5?iT?p3l4#%F3$$ zWADx5<2uW;Va+@`qp_2CiQ{ZI#282jiH)^bb`m*#lXya0rKI(j9HT!%WfI7>tbad zXG{^%V?HP%f&$T)Z)MY0q?A<`t&CXYRp*$GgHw8rj-7@mx*0c}MGn8td?PdFJ!5gv zJKwyj2QN7-_k8YyJF;8km7C0O_dLui%)<*5ZTvg^QvjtiyvuNiOu|DW&~s;a z8#3m*n9I|l*3UL8M!aX5gG2mn$p1}_jd>d;yo<80#Jy|GeLZ#Dd6D_?0_nwYY5aq- zZa-cav&V*bp*_as;B{m6W{!=2kA$v)ypm(b>L+mYQuBQot^$rX$dzZ~7@w}-O^>ZI zKUlCT|8+ehz8r;Y`3M+2j*AvS5Nm;KL@q`!6V)GXeE-2z0|F7wpyCDpoFTMh%trwg zyt7~8UG%>&9^7-RXR*mckKvw+adQf521v*SIjskV^e?W3&gi}#W%Tf>SS4|+=R}j| zFXH*sDBb?^GpF@{K0l)hCzBnKxArV@-w$&c%!*@BqCWs-ya7v7Rqnb$4|vf}|xTKE37vO7FBa@t;H zr}V?7OUB3PlD#&vWQ%sm`0``A@=HHPSH?XiwlW*CH+g4`$Z}<_^3HmhF3~UZw@Wj> zj)}|W{Bi_b0;?x@RJ>j>F=8bk4zt=+=bbn(HzZ(!n%v3o;@d|EEc^kQ802-e8 zd{=hDT#)WdWlwwCaWrM-K+6IwN4yO@0K$3Q2}`5800XrFkmNn|0jZl$*QtX2UDwN5&ulUoWwzj`P%zzEXhx z81{H>OgG#-a5Q~gO3A>g4{Ct#K}F$B)Do$Ob$Dhih(KO#d2G=>((_>Ylt()?y}g zVkG_4vte7m&d|2THY*Z4c_(xwhd%)fe=%f6H%Y)VAB65wFlNyW&f>BZFYvlQhHKWC zMOag~>q7G~pd1`gZg}*NEC-SHN?J`keGIhsLW=q|=J;XWbCLO$N7I{skDM^`w7&HA zA9!Q9Wzz@+*z*_NQ#0mGhk4CK2Ip}QCqI8DW<~P-^pTXv*EK5WX!|Ca{_gRdpR)Jy z!>7$WZ5MZn;v5fr>tT!JfvNE)p?vt+j$R$6=QVRWgt*SCgHZR7(3EPvdGIt>@i<V1Ode5s5!wmKB`B!_-m+fo0p6;Ia zu7V{f@45GIc8gnwjQNc9Onf9eM3TmvmwAeSkr7?|=jn?7X*Im$*_~JK1WU=gUX5k9 zY7vLS&QB!H+dI4KV{_IIgkhw$wBH~3}tpbE}FrD3EesniFi9tQZ3>f9uigMn&V$;XX=-j|#sJHKOzrkcMHD{#w#l9X2#~^hbgk zb@;Ef@a;!EV`|F1c7aH`DQXu}k>K9WdTG3!4BP9vbe3p-*z;%;TZU#s1hGe9n;>>; z(g3l~>)Khwj;{>r*2EAy$xv~37_s{Y%vdO&X3<@57(>v!*%CWDn9D?cyj#6lE!W&ZN>nlgRLH?Gh%TG~594e&8C+FeZ zSdV%3n2&p7q(dJ4twV4t;M#QNLVXMTJ@WT!^v|8RLE+;AKp~J+<_mB?DE%B4=%QyK zV)zs{thD*Oh#9=$eK2XQsJHjm$EZAxBh<=~%1`PH&-^VsoNLq9rm_!jslyF@T)5eM ztD0)x%#mA{GIO{pIt^!gBpCc+<_P~`s3v4ng^yX0-`vdM#mksEJe|o-D4THaC}#{7 zYNNUT=%OQ5K8Qx8Fu@Z-tyDIK@7Eu`S}?yQHjqYmL`w-L39zshi|W8`^I;Hy!@!@p zTdoMCGVCQ?3Ldv+leM{&-d>>G!_#0Gp+xg@QQOh8^3 zgjN3VsQ5}b0&CP*bB~V-rl%&J(DPdJw(J;DyULH>76MHR?c<)b`FTyXG=6>0nJMp* z+X%SLN2}Q_vJf&*sywmXD9khF65f${A%83iq5sBNsfX<%rOo^9P=8XeN}qz8RE<3U zqK_S+E)C32oy;echb%UdMN@6nE$b_`hxy&JQl>KIn*|S6)BA>!=R@g4Ev>l=U( zF{j^5!RHAJ!u;>EV8*!X-hKydSvL}VXV!dU6;7W8T?>DwYm8w&R|RV`EF>uOce+<0 zpzs^;KHxg@Bt!K#9|I!kXcKLa(SvzxrLGUm+V z-eowmnyiwop`4p z1^yWUtm1=yd<5|XTx4FG0y(VCm@TR9HRfF0d`{*VUa{VM0`ht_4A+vpa=m%dh`0J> z^3q>Hgbn^{_{q6K2A*zQcKZ;Aa4yCP%kp0AEZ*FcNevBUPvUW)j{iQALZl0pmmT>t z#}EWIV>*6}EMrz9hMidth#`+XPx;SV1-CuUX0Pq;G5-kXvAEA=IX2PJE>8AW97S+o zHS`Ep%^euSYkN#@%3Pd1oqc$5%sb1J$7DuzSWIW(&oht9bW9E7&#dF-tTkr=q;S@? zMeZT~<|15d&gUI#&3-%f^WeV3s&g-}KX-87>~3TLJ%1wG;IHTTUN4*#xL||%9jxgZ z_~-vVm4(n-VgB$a+*>_}Ho9H^Ar`6U$k=h<9E>9UtaXdBNoWqhYu3XQ!1EjVc5WK} z&A!cBg@dW=p@|7EgAn?NXU>BakjdQZnRTAmaNTBzbdx!kw++>K_2JV?US0REp72(s zLO1YL+n0NO!yVpAjL%@$Yw&Ilt|#OutUBd+C-6_|*eb7Q5l3I(tvV9?w&)$z>TDl*%pXX)16q?Jb^wZ7;|KS!~l6|o*(8^I#GpK-P< z83qOP0yotvxMX2w%57Mc^<&xNc=sW=XU7m*I|H-_XC5xY|3S6hnip{Ko`UHE@MHNv zhJ+HwL1|9`iU7%E(zma}(H;bE#peQ+0i|US#Z7f%p6kHPA393*S>c@zuJ1O#xhjP# zB-z5ezshJ91j8%Lka=(=?l6B;r2x=d&d!*xk=@OSh9|rlqo)M%sNX#}NHgYdAtlrF zs_~up{)YdE6>vyg0O5pCHx{59UNIO4Sa_tjT(p=T#MK$|E~N3!06k{bOZ?7!yXzS4 ze+xo*hv->Rp}vn73(2FMF}K>6&i1;V`)IhrgY|S)Zh@L3`D*H^5PhlU6(p#{<#LIjS-tqfkH1df7uQFBD22- z!E?95?&52>U2>^^|Hovr=RCSOFkqa{m_LUzfkN+R3#a7zSHSGhzlWeOaVz*H$7_4c zCvhqAsCaY6{3&Q-16df7PcewF|y3nGxAqkm@q#(OHRT$zDS zgU|kiJo^ecWd01k{%7%5&h}FCr#)Ln@Q$bRi20-hl~)oktjyBx1#=Rar7~NDgg@jm z5zfUej9@^iJqY-}T1Yo#KBn109Q1`a>zPl9qsPM@@G+kHH7RaM>PE!uP8s6IdQusV zL%p4!(%?1(i@|m2%%|+C;*S&p2Ty^RF)Oo=LQrhf?4Td{L-;6majh&A$o-&rBq(*f z3|Af@<*c$s`ds|+;sx*>{BZQj@jWz1(?Sv+e=`UU@n0?kV48(`4MGF$lbGgS0xn!QNZ+o$>?aT2H z=)Px^w+GCNIFH_M;J->z+pc zugT!*3m9Wq#C%Be_{HtSvlYqU!i&r&j`Bhd!~7mw*f82pY59gD%va;aK1@h)1w0KI zDvFPJPdDR_BBcH>auBvqpuQC;n_ zg76x|%fG_%d~jMImmS0l;V|D|Ho@JE=Y0KwRQEX;Em$t{iu+QufimXzK#woEi#pmF6Y|2M7VZoYXXpbH8_y)A8WZ@#G>ee^T2{xg*1;~PlUk0z~{&&{3fE! zVh22e_#kQEX;gFEptQj`+^X{aOMn!=52T+qU$U6w!eB>3 z^ax$H;QfsGbquK~^CMTPMM}(C009LVa1BFq#(WqAg?D}m8H!*H2(rJ-h!pzZA*Gei z+JzM={zG^W)lHB#pA?BHJ{vL24K_Xp$t$j$B7lS=hv;I=hx+}cR2)BZ$*NS^FW&Y|2@#1D2JN76J5~-xjUt`I6@O}iS zf@1*joK@yQy%iGrFK|_lc?U%LrLdE6DP6=VW3%BPYN@%QUx+W@ch#qhN?vb155v|y z`+u zajLEZ7cB=ghBaC*6L=%W{KdPlt)Me#oqHsBDlh%mohj}H!ex*<(_;#_U!Q_3aaR8d z@2Tb?tS3|J{#X)apK2b22Sfjck-LIyYvp7=-vJTv4ZN^XM2H@0CL-W$IB!Yua3X;i zo_;P(q!sCHk_Ks|z{7Yy-66p4>2uDf9{}`;j8mY7HD0fI>yeSghh^m+ILgdm=(%-^ za0k1M{VUBlRrCIQY^=)qNyQCdoPQ+j*kC?-2pJ&9@%N|kH&XSu7oR;0hy(0oK6eC8 zIAW5grY}v|i}cK!0b}&pPli{|>1q3LfC5|%#R1a~ibG(Ea#?|sSYy7Qd6@71AfS{T z*FL=!ufNE=6UNIL^$cz7^Cv`kDF1l3iJ&GGwnWx~%NFg>~MzIOT3v2;qfb2D= zyT*u~PDTksJhsZ*Req}nqHYP?~{fG1^c^R{G=&mt@d5>)++;xw?BYVl_WG9R`O zj(3}v;goV;I{Rn`CU2HzNgForqh2=xJ||%Fs_AxE-4%87GMVWg$8X8fhj5N8qHkUGX%}KtLe-Mt||8gHtnn6M+Kem0?+(A@;`AD z2dRABG16KFK2(b8S3p!>kXe7a8zlo7b6O4Cj3gke$NL{b^pj@jdtmA6-y@`2p@odO zn6H;o7Wj4O-uD*q1MWHgOs$g_pza4z6NKPDDwMMZdHsyjtU#_k<+%GBFLxyXlsBq2 za4DXIG)_C}N^({D|Da7xF(@c1hSuPit`^^?fk$UG*lpDAwqdw~JDMBd? zQ^;69f=Cf=kV|NI;r(mOAHzW=c~Z>CQIdSMp2Br$p60*7$p>ZOFx!tHYlhF40wdge zk@=#hVbcFV4h}Dn93Y)o#0>huW?S=R)$h}^D(W#N+1)c~>u1HhPo-MumcaqgMb zaA#hSzV#e0buBMoM&Y4)W^NrgE9LFtAsDx*@9M7=FST2LyBFTrck--d@%J4~hYVS; z%x8fLehbE0fWn)22BF5Rlspa4^yl3e&qe0rcfvxUaC{a;!+P`j?y>IkxN+~k^E9lX zRUke=@}EWUtjBx}mhH;SIVx;ERArISa!yPP9k0a$Uk(>skNKXsI(@ezC2t0o7;_I^ z@U-mh`q$Oo&N=UCOm{lZ{MI}OVTJcJ^T>+hbSh@dm*+;zhrov`U@Vb8%{O2>{Q=DI z!zp?V)8>C6MJ;nKrP>DbPb&!KLsI?n&b zfo4!(zoOqUjrW=Kz7`k!q!>L2_d&Xg(WA?b#N1!BWq+x^>^DB{%if)|?A=^; z*`MD#V}d4tEHSR+zuibiEDcUwa@k*Lplo?#`M& zHYd5#yUc?SEdnGyc(m^Gc4smM>Im}Xgp&N2h?pPT$&J0p{K}XfPB}@F1;l*9MGav< zf~dL8dzuwG!&c~68Iv8dLS~%dGUP7^<~<+4><&C>r+L_%f>8Q1K+c`!6Nsj*G54p( z5Ex>0l=+&-Xo|Ts2pZ`+{0TqCRl7n>@d$I)R+#sv z#)7KFFS^=Ej5iFN{@em5h}KQ!zYjzD^43KUI@>+(W3Gl!*6P1t?k*>fyEzls!{@zi zQ8Dei0I59hT=R`1@P84-z9W@_vt=b?>~Foxt~PwfmyPJcBeKBw(Yzv3xOBapsDgfm zxd)!So#sF9l4W@4ZWh*v{|8vFiT?-m{1O0KDa^zgK4Zwc4yw`Ia|oV-KJ%X$$pA1v zU~S!U!M3xb5+2bGtY%<$$hOnthUOUfK}+);z>Cx{;w$>s9u#zlzB!?ccT5OJLxJE( zt{T%2@Nc&Uf->g&2#z)NJHSyRAbkzAyY)XD3mgz|FtBP*lzP|!0k=@h;h=B#%=VO* zA^`D@d%H$OPG^60!rPStLg7(Mx4Rzo$ySAVkCD#+bZ6l)S^s~$T{Un0+q_*@%g(p!qrJmuUE2HvmF;}}y;AB7MYa??%+>eCaM3-4%Mj7%d{#cd%q0vUysyb(%_;_|Mo_-2sX481#lv1VoV>8c zCsYM!%qHLom5@RF*-A*t#w=(xY>Hp_h|0*9co)ujS5Lwi_b$BJ+l1do5QugmjU{C! zf=((kg$}-I#Bekah$1`%nZ76O_LUNn^tJ{U*hE1mOdpfnR7nc|o)e&-Fal@j6#$@Z zPk?fXE;R4L(^P&U#mCA|yYFf9CW*&iXug{k2t{JxK}c0IJ8=>f5pbrjLxKoGaOePV z^*Zm&+dxmqCDq)fv(neB@y_1rJ?TC?`2zFO9wa}lMW)fu7P1r1!ri~)Jz1&FTZejM z{(7~#Esovr6U;H(6#pM*jXgcRr^cquFT*6PLPzifnf$UBSAK#(T$0=@6& zA{Cwnqru+y-;m1weT#@etWRIIP9JkMZo3gNE*xB8Rx(vqQV7;;$yO$BDi zQG1M~+~6X3YR_&WC@CeD^VAwB6MT-vZiYd~1hyV`AoDk%!5)Kvi#vxP5+=wS{t2O$ zboT5M>U=OSX9&^!{0P#?tw76|x5%X)suLS3z%W*OiFv&)=qc~4=Yy;mx;qQ+I-hg; z`H@9v&wqj8eksDJ-ArmT-@H4$m)Pbi-uTflJYwb^QKk+h|i4kL_e)l2x)9x27=tp3LeH zeFS(4n&jWo^{jCn14bOPRzRwX|V!%g;->B z8*X8Qh-^esYj^uTO@e;*-&6By4*b5A;zz8u5YLWeU} z;6D%%^!Fr2x8g0!oR+u4Si#G^4cYtoEGKFI&Zbd!3k)~^SK&K-iHKG>@7eE3_Zk;Y zaJPO#5~y(*Vbtdkn8ApkeeRM-3TXnlbF!2`Q!Bh@7}kDXhfEU!YS=08ejsP{V)Gvm z34Fp=jRbZsKt?M;j6UGsMQ+Ih#G8E#hSh%9LC6aIVGTshC3!^}W8gCVC)fA3F^I6U z&3lhx$;fn@%-^K}op=mgYsP$+J(34F$wfTk3Vwf4+IkS=p1QnKS=_vc@%w$1wi)aQx(;&v+OV<3ewS&|JF+bJ4XII*umo zG8Vb)uxy1|w0{O#+wgXs%WvMPF)G<4u5p9*Kkl9Lh=_@`M30N|#_!;b0l(rENR(P@ zULkINYJXhs%1R(Z^gMUs#6ell&F0&PU_td`+}x>)HAy#R{t1h;%1m(0QCyWuKP?42 z1Fku94`8mBS*<4ke$c9CY!Q0nhiN+JP9_Z3*8e+GJ6gQW+V z>HI%L=i%GD4KF34m&>gyNd{69qUHK02S!|@lz5goWvRAueX@^0iVPv-$KTgN#cjDm^7lf$h>bsGCm+S zKLf`wpZ&#b%KRS~!9kxTMu2o}QIBOE8js$^L^}96^u((zoaQkaPun+g7H*<=N7rbzE7PLRojD)FE+-fN45ZCRD(T*6d7|32?> zju}}H=MU+x)BzWm5A~!k;ZWC_&n}Ej0IfqfK$qyLEjV!zPEZtLFc0)>VZ6?}bb@cx z;*-z9niRW|ish`#%fYIi`5YD<>GXVIhFSbL*kk^x3!WapefYW&1*Yc;%dQscIvG*= z3jK4dp1c}Vw81>{7!r+fo1~>O{Yp=2#^$@2g(1S#Puaw!oABsva~t=lTQXH8GT1$V z=V21>f@e){v6o^EAHu3hQY!o`m+>}~LuBRvLb(v@%~vHa`+V#@H~=BLnGYmqf=UU?V5B&p(Os64}apNfQZvf}m> zjtwK*97FDfXD4(1!`_PfyzJH9ia8k$i;6t+g*z8<_X_iY?vV*R&>gf3`!~2I^(dM+ z0a2jgSo-o50Eq78Cq4Ev0bC4)Mt!OWgPBL~vW4k?j3hL~JH>wG^MdAR4NM}8_5m%Je&oZAT`HNgrqWS>RqLc!m)osEkrJj(m*_*v*Ef#Pg^?|bDo*wZ|QC5i5 z?M4QM6ISS-BO>hoW{?5ma+B^o6qbmo-HYD2lz#7jt(AUfQ20Gdv-}^)aJc89u#zP) zYhat9s74Qva(O`PPF_Iy@hh4$hlCZ0wmwbP`HhDV+cn?I)JJRv$r~Z=b%?3MxN9e# z)MJ<}2fryu^>NKlv;McG^3xs;^3#|-`N2cl6~gAHA>IkzkEf?eRE!eLOz;QSS2e_Y zU3%IVy3@~#W+aK9DVC9R3^)J@QOHPo1!90pls{pmSpB4lP$-8=N?;_OLFK9K`E#`p z;BnN<+Z8w8TBu{u(S?)Og&kxUn72wUzCPd|t+a1EHlnvNACZ@nI#!u~T!0z6BJ+r( zB%V)Jz>>YChfOs!g+67z4dRr1HJT4U_rEI=LQ}eOpjFFI0MuL1U z&%Y$PU}GrNVu-)w$YyzOrEf9Eo^cnY5RV6(phYmj{KkC{_UphB9|Vq=;VmglQ5 zEH{{4sN*8ggWH$cSZfTvJ1Wls?;r(=gE$-Gk(|8?%-eg?JLI}`=7GCMhVZE|%^6}* z;u|faqU8t^a=&;N7dj!wPJP|x`)S}u*u#>7yXH~fTpn@W9J;2Hyxz!_qE7!KAkL?n zV|V+$0(DLB@MauFH&0YIb9l(Gq9EzI#E$PxkOFL+yAF95Fw))%5f39xvuvr`QWt8L z*1vhF=j(6J@lqe>;(&bq3N0i28;{!?vk1m(qF->%Jyh%*4G6s*F^{$8O~8(Xf=q6H z5VIFp$VW3HbuHBYX4JTkd7DSPr@}tQanzK-m7uHg5-h%~3UZy;xi_hmVkT@~4K%vI% z#M4u!P93+_7I$@}=5?8O-i3%9Vv-qiH98jgUc~3oyLk+l<2>t)JYxuAZ*D|8WCHq& z6^{}nuCaUR3ZU-P$uU0LunL$9ku~>21PMO_6Y2g^7(F&l!7O*#h+@woQD4sqnRX`o z0ldB2yy~cSyTv~I3$*8EYCttyA3P#R5K=sK9%Z5VdN-^m3@{`Ck6A&MemVu_TI6M+ zllbLUUZS8_YBi}IQxAD(ZYH9-)~1rO?qmoyVrD(UTarD+t1{-=6rI)d(BTxGxCO8_ ziyqDwK*OLDug$Z%4&TL~w#N@hfG3$3!*W4V!J?{Q1bi`-RT=a!7f`SWW&Upb?VOrs z!S-Yp;Fy85Jd@!BByrmtP_Ql>%=H2z@T?2~ou)T2`4|&r(h+XRj%AK#(wCj>{R%EM z=IuwQ`ThaO-2DyHg9nEE16Y1ukV!w+-ju;zsqQDiVTG=JBoMvzCku->2>N*yI)2)N za3aG?qn8d5xQ^qk-KbgR!Am$;^IkefGv+(=>DbdhM33Dkk+8mlEVOR(NvsuO4QVJ_ zd(W@I#l~A~D!qC0-6+w;-y`NQM@-T)Eu4n}6(!Ed0H<01~|r+}Foz(4Q8RXBhs9ES#@=*-NyTjV}iK~l7c z4)O1Rj>N9M7Nt|i5x`*s5XvbK<3-q`j~yA|V^*0@`3I26 zX%7fn8*><5@ICrFD!|b+k`v$v(ApCr6%3mD(QW=3i^S!I-Nvb<$Mmle{cEJ*uez`p zI;y7-;Nt~qvdRgErw}ZODTxk#= zm-E%E;0u-$cV=)a@}S9v8O#Q-ycXd%$E6F%Lwcu&^6>`sB18H0!dqP^xN*i~)s3=3lwVvcGUFhZ8p%6X?Jt(=Fw zOYxNkw4TJ?z?%S|kv$EL*T&9Uzyh1lL&LsL)yRLrNwMCXIW`nNwbW3cv`rP>3ATPl zECTOE4j6p>Z@+uQrp?30u38*y#b(g|%)jLdwEtn-a&8AxW8IEpKbF~We@hqf#H+|o z=qk>=7D`~(dLBfJyPSeJL;xDg3N;^x+~m@Hr6)C%g%j@tTj9&_UUwLhgXX0= zH*6x4$aRk3Qu9UVkBe`^#m_+8SQ|$7m~Y&fdKi8__N0DCH~rYS^vUMEbW_4ZaiSYu zdZ_FScIF{8)~191Yb(cyN!^^jRY%C$T(cvYlIo6}xYg_#1U{)tnVuS6JV zJ&xzWx%~Fc7W|v|k(xBWx&B@JUp_dK{!M=GLw-Q+psTh0=(_o97;46#>l7SjC}X;P zU1rfsJrC7rc*XN>>Fv$uYlWF|y?nS-?cFgvQ!iC#3R5>v7iOPZD%LC2;bQLkf!uW0 zfopM@JN?V0!tBk3$#Su)^+(Ki<@4hccu4G?zOC-Lqs7W>X?(O^Eze927G`HlGvm2E zHx>`aZy9j61S7qra=ngsU|*qlAcyxwrq{RRP2+`n0XNA!N9%aPb84k)C$JncD4new zzqMK@mbz}e_SyOCpEG*v?wh;zmI_l-m15}Do6F;SOXG(tGbO$6z|Dp7%&q0|t^>gn zZZ0fz&CS-U9OjJ;+py#~x0R-6>xXo9k=v4&ajG;kS>NC8a`fV1Ad12i=mNVRU+tmd z{zCN{S%&A_a^o$#Z@Z=Iz^>9nVQ#8^LwO4GUKqu#@yYdW4VGZr9&B{I-Jz8iFret( zh93)h#XfQbrO8_g(+PuEa)k$KoU^5b>nk($^5k4)uEyW6i>2!B-PhS&B}>R`_Le92 z*Bf?xsxmXVQGU$L)XI}HrSXlJYHZj`4rKeTQmtOC$Y$pYcvrrRJ?W|o{mstR_UB3H zN_Nkls_ZLFH4H&08AM#&Qz_R#isLtzrYqG$mT&V@WJS5=T2gO8=3pn5t5z%3n@hD? zVX}1H+{6T!fSY+FP6n|Vg*W0#GRd_!-L(7q9GD;PQ!#_z`NAok(`>aQ)0(Z!+WFj8 zsgCn~!!y^F>$L>hQ%<)O7^Q?Imvo1F3-|Z>LUDiTCTyupPM4xuEgZVOQaMnzoLeoC z8e+3t@+I4GQ>i*nzG;uQcN7b=g<{#Uck4poN}n2XdvA;jSrq4+P%u%seE7-Z;Fgi%XSPn)0Pb zf!FS?j+d(X&}ZNBoQ>CCetGY}#@_xdeOtC}+&o>|U#lO$zxBD9($2{eSgc&cpM`31 z|IURSgPR8jHg2BWxOsQq#?7_*_|D0hIk|uH#Gc{nH*TJoschaiSDvbuXY`NKLa{W< zx7PIUYQ0{@ZTar3F$G+R z=}hQ};#8rw-<`%Y+atAY`%07L8SG&mvH?@FGsmC%4^m=;bdu;Y?DSl9#)^Q5dTg%! zcaQew9O`?0d4&)XTR_(bS5-t9qrm$=8jdtZ*(e!TVMUWApaSac$Yu*8>%HM z#GrSIbK?~XIf%Pj>DJ2bQBh-%T(^|wOM<@|ByGdUWM3`7$$@qqCK7yc>;7t~pwiD# zQ)Hu-LY)0XxAR@Mm8YhlrEe(I>dz5rwB%9&+w8e<`bAjPxqZtmYu`XK$&IBF7|B<) zF=9nt`32}ml=NNffmCSi|UHeW_Sw0mfbR% zPhP+rc(gJ;H&uGhbB1?yz@LF`jnZXPT2n=tp9XVPD-&G@9FirU`0}mG!g?;(XuY>D zuZA|jZ>=;uHCh;+%F*No-EPfy1$Kn24A^zFJ~*$I`DlK)jLXZp9Dahxb2;Dg&5u{| zb2G%%d6?9PhKfK#^^HJJS6!ty58-jwJoAe9p=-MG&%SB*b=Tem!8x}tKb)`1zT&mL z+cCm&F%JL(^E^LaE*%^$;&3n7JP+CgSckVDH!uN6l^gBLPj}5$Y7m(7r94d_ov$0b zooMes{$@ZI;N^P03Xz<<<;r{>2rpk;Sm@oJ&(Bn<)36lE(4PbW!+UO=l9}$F!sABk z1282fv0%66xmcta3}}$^R@1ebpDNetxFFa}0;S%*9bMD=YW2#&VvV9yR!Z*}&yTAW zo1e)ShGhA116C?#%-KU+NO^NGaEzP7@9iBZ%@ix+TrGgTdZ~9iE*Aev-knfohdovN z*xNrohlv6Q=8I4W!yxV*?g(h3zD-UJ-!#>m!~eH#-I~Myrm)tbLpW+rfV{3O%@Et> z%M-(6wJILh+YhK%%li+#6=bsw3qM!Njqb?j2I_}qOQ5}5u*$=?Zq46Hvg*q3p`RjO z1FH`C+jG@bvF!=3SD4t`GG4RsnkzOoJfJdL!*hnQDtRFAnryT#XF%tc$erCEJJH); z+YgdFkgr$r6J_-$fDE?gVX~{aGCVbs%gyh(HNR_iHztLt%ofJCIeKZ4t_Q0QY)_Wz z2c2%ii<)upZlOs~*W_FQ2GBTOTCIaJvAMJ5`O5#$Qs!rC^{FnbLy1Oxn{)2nPG-ic zR%> zs7o0^U(vfQpZCqVJe*~{{SAMLj)b&@TO$vr0f?wjykicwY*$nS*ylBFRg97-NBcnV zkUUl>m#1f^^0ZFys@KDh zFD|!53S#zjiBMGLrhU{hT5o%utEJf~xG0wwrNz+!Om_6j{GQ_IwIV*-e;ee<&G}lX z4)zs4qa}_AQ&<+pBFgz>DP7Dt*W1Jtyj$Ymu^K9*V$|)kkwSv9o`x^A2f2#!X?QsW z0x9Y?!s?)0?iO$=NDaaW6xS$>AUB{~uFQ+rNKn|p%)~;(%-Y?r-ag?m_yL5y$Q#Lv z7+?cukYg&!E=wy3Un9)U=E|hS4o10Sy08E>E}l_gf47Ks0iblb4a*Z_45_|?_u_G_ai2}+oW*A{pQ90d0;QKt48S)-Z-sNCT_YfE8LGW8VV9f;>g-l!VVX$0`Y;+x$Fhj@ z;Y=3}l=A!G`g)?Yz+P1Y1LJekv)uV=iEL2E+U9#{QeD9)&oy0h_zARqr<<>l56*#Mizd z`UB?1Q$Z??cUi3w0L>QFwQ6g?QL7qb2B^ap{WEjZR&=y2PqD^g8RQA`YDx&B+qvpk zIM}NQ(-jZoCxB_|!?1yi+!Z^*{vE( zc^B0Juhr&dkr1ZBACOf9$`t$%I0z3+iyV0ZNeylh`ocOPx!VE>R2d9{F=+*xg@KMUOh^ICH!-$ z8WLP{IAJZs_QsI}S#li64)|gLl;*p7d%3{~dr!`An`N~c-3pe|Y3!;K7lVN}u~^F^ z*P&P%FVW{XwI4s1g}I$cABV9(&ai45*}dGjh1|X;a2V8ZNIog{^%G&#D|1*oT{Fjz z7NrKkk^DrZnio%7*Tfv6)up^Tu5dqWU7-f&Pn$yS23*go${xFrN^nd*7w|abm!yNL zcBob_IWI=rs;-GYZFo1ZYxRIeBSRo8E*}Sq3dDg2s|DyZ%-%V>n|b-c2$W0J3gszM zZz_+YK)+&R!m2fTQ1JSj=^er-fHtS$5G!GeOI@XfQgM!c8=NTgwm^k}+OQl(A2k6Q zymtL?WaXxZAqt&^GPE&leud3Jr;G>|LHiw`@g&0)tUiE{hX{lul$6W$BcCMakMAiv zTN>ZBlAJ{csWWZ!g}H^HiNaK^UFn=XNHrX4Kuc}cBbpUyLn zlQb-LGP9q=1xYBQs8x(>rs5rhn;$_VWJr}Fd=W7MTiE%>`~VWSHTmxLD*e7ddGupb;_8c70jdapKF5lFDPLm6+KO|fV zwrTcGaYTgxiDVBqbq%Th$X2kk|){ zUGk4W#SZk8hT{E*LI+P645yFd{+6k2FzSZUi~y_wj3VkZ2iqWUHi~4uMATU`RtF*Z z0=o;&oFZgx*S_*Nf_;*U8A=k!*9((fQTs(5!v0ZT99j_2z84sR3Ja@S8Ig$2^BRvL z;zC3TkXWbAyuFAvilEy!H`x_-`ABvJd=>$?1G%@G$RVqW<+ctjzKCg-HJ~t7cCT)|W@g~~I|%C?-VekyVPgzW-!$Fdm%C|tux|iA`>)*2pGd)&?%OuF zePBobVDC2k(aR$PeOC@#Ik>&=N*>{LeS`gjSN81~9N5ZBcywTEU*Gort=qTpk-a|u(@4?N<>5UEq8QHKL>du7 zNbmq-~qDCS+5%IUuN$yhDn1m{D}Z7Wvhq#y{1A%2EUKx5#k;YuAFmQC2jeS9ovJ={@*$Y2!FA$TMz_ZhC5hO8H}32$$A(otKC*>H5xDKGATZiU+cOez{C z6uK<76S?fmQ{@9b(Dzo9>Wbo_eC^QmzKV)KX6324&Ua1Fz_GHVX?n3MgXv(#LW-c` zNQOY4zzwIxh%o>tbA}VAS{9~m(R<*ltLdAt z^Fp#65MGqkd}BBy6p=+9Uf^Mg;uaAo0S;hVp(}*)L(PaDG8@%yi2hoEQZC-K4;k6L zTWx_MvcqzFAs6Rn=4z#J_`|}g(k^RaeuZ1|P!SdC#*XB#6*53&q6P{Q*EpuL>4Vur z_%G%IWo2C2mV*R&s%PiCbrk9BGbZat(o`d8%3Ya|k`2=%>3OJ?V74l~+RG;ohLZn7 zkF(1a#E`ho39|$`Xy=~h3SuyJ37Vja%UI-OPZ{YlVgwos=ovxL|RW>goR z#rtmi>?}eV7P~3e0a}=>0XK!NP2dvm8)jx1u>0104jF4mq5?TWOklhR=qo-D;SEbg zBDpa?3UU2fo0O2 zEmxDI3J4^qnQ*=!s|6sZ8Y^_bL%0kDI^bjYpi1rz7V!+rZA1VG?Ep!Y&kDe zOd5kL8^Xw#xFq&U_6n8%V+|!dF0nj_*DL)Ib>vur%%ORyDXcW8Tjku@ntFV=?aBF3 z5W>3Qi4eyJP#}b9trHDxlJ({eP@};Bs%a4zoVim?oH~gDLW&neht+cC6zL>+HPA521+u;pmR&q~27GCONfBGran zWfeK9Rgw%cM_o?UeC;3tVKb;N%fnsD5^g*X32#B_CS2giUK1J;G7@AQDS#OeI&)Qd zvF#B5RJ2eywh5Rvs3)>zVe-QTO>T-EZtXTwE0Y|+87NV#On}`hRWvNJ+}a|#9YEi+ z3dEc5g`<}8^B6lx4%$`~9}|2!bmC}7mjKKpv3@yM&c*Eu0n*lSFt71*)GT+gXc>-x z8I1{t9t@g~a1wLfW7;k^UDkxr*5$vJ8r@Vu683Cms$4{gONZXhkO3Q*K&`4F7kO-* zXCR|psKO5|Qn?SuR)slaQu#@TkBDZ;K;lH9Hrf>@QKtj=kGWy+f00!yHU4G|=Uj1P?Sj*Op8s~{}ajHYxBdN5TUU%es$kt-7*s;rQQ>&tM5S`ItNq zB$f~Z)W9Z&8`YuV5+;{|`i#qdAuNYor5T&!WutMr%k2uaZJGnxB0}oQ&r4S|C}t#Z z3fRG_#bP<-#0}ij5M;w*hun2En<3W~WY^2nrP^!>C=@Bi(o>KrE;2s~3B4}gg?%qq zhJZcUG6VkuyQ=G=QPR1dHlp3)V-@$IzPB^Az(iW1sT?y~JKF`#k95V;%UR)AfIZNF zdAOL+PI0^>A}WL#66}y-4xaCAutN${2MdR4`O+P8Xv^X}fQqVmw{qbD2Eg9Tx#`b8 zx39NPGvo6`Y{UU(S+rP`&XgC8MnBv90vT$vc|Hzk0cW;{T?v z!8J$4tu)YZD=>ub;&z^12SJuzbRxhdj6eDbQKzIqbXyPMuzsk>hNX>25P`v}Vptt6 zs8FJTR)c|dJwVMQnq_db!GL@NoDxzk@c9DMuh1ICEd++PHAR9=8PIkIPwRy89z%kL#ixk;HE1U0o-kLn zp=rtE3=^6*Rl;sH+CeT{=O49+mm==zFN-PcxP%LwK`zG-H#Ucmq2?3gl{xmNl5B@V zzi#mCV&v( z8A5#6QhB48vUxj%>fz+VMw(fc$C5JTT5WXWx@bVZv(AN)1nHj1nAK!a1ZDeT+;wyp zkwu3F!V=aB-a(zhY7a!1E91nsN+B8hl7@z`rH$#r%ijE zo%GPFsv;_68G=q;0}&RXI}<>qIJXHZUCFhWOT2Lu_MxRVMEL+TA^#Eb1(woK7P|x1 z^ZRsoT#MGcrINc5IPpoh^ry)S`#^0$6^S?yq)1lb6$Ta0?NCp^6&pz}S8NQ5?_x5= zd9{{aj@WHEhK1uUz{V5<_BW{=$fL0{da2Ks7*=E70P9u$pVA>A;cltDAscUEsvsg< z;!91Dbi*wjp(p=42#_PSSsSbU#c-y(Eh{Ax0!=K~ zk7pUL41$050fk=p^bt7@Q5ei)zl{jnJc3Pd2ti~72c`;D;UwrMfO>R!oXyL)(QVH0>mn+nIaKMSL5@ zQJhQJLK164+KwZma9GS)_sPk{@dt-8TCpLRs&Kwbpn05GI}#=EU7wNQjf=P0Fbm;x zb0sEb?h#jXKp#6%gJS}&*;03J^Yg_~YR6g6@mmml#`Ug+r?X{WG>ubp6H?>VV8tdX z?as(S4WqD${P;e69{&G4`c%SrE-l!kg*H@MytK|wYFuiO;W@%f5^yonH5)f5Kryy~ zg#^d)^OZ7snCiC^>cYsmbxt#Rs_vjn`v`DMoyise*~Ic9oW*WBGP?CqjF1gBoK@L^hhid z%%rJK*7qDnGfP%M#Db(8w!}a4>>LR!5I4i65?y?q%Sg>6a~w`FL5A!~+DtQM+h*uf69 zU220eXe@Nm-Ua@|!@JzPadsdD8$?e6oE9H#^IQ=M+hju@VmhdzZ4k`mNe45!|T_t^!v;OV_N zKMQFj>DpO`b@C*~k|(sx0EFWY_@jS1In%sD<<-7j#%bEVch@At9Bt#}@Dv>7R5 z+=ET6t$=P#PBnzdT1wvV9khe$Kgz-H6Yj)^0nOCr^h<3q(bbe1F*{5Jj14$pbAPx% zZVzA>qTv)hOyV@cKS+yRIzKHM7qsNx7=wz2eqDrYj;& zk6t;x8G#M(tyI9jX?#qNZW(|qDGB9Bf~|H+r`4h(%{>XaN=G=vJ}x+F{oEjbanR8V zrS^Ft?1j3Kxw4U#pqNIZ>ad6~4Epf9X0$gUDEsLjpHv}`Q5vUkQy$l7{srlh76mp> z;JBu1aH2FL38&I@3!i@E!nRK?KnhqKXw`#7jBQ#!57TVZW9bk<0xk50?rgh)PY2*) zTeP?n=`H^1gnsI3i-!6f>X4GHa}?q3@H4nW`z?dXajHk0g8u8l*qH(v;CCmt!@B5bPLe!c7egh$4pQ6rF z7V9|q;M9Aa>Pez7q8mH$}UvtNr6-+K)!`*<@@H@9uwui)4NmzL2B2L(lFJ2-=cD*YUfQS2H!JapBxc4<0S=3F%cHy$AHA&~ z>a@_9N!iIn5iF=K?4%7SGJmcrq#!ML?A_)Q4HAzg10|kE=yf{ za7XD5z<^-17Cx}Xq{U7nEpG(IKqnhH*Fts288MF!xJ4X3?SXZdj85wqnf`P2uK9zr zC>N|R`&F8t?_+2!6Fs4ze9Qnv-_o>uNxo@0I_aLNrIKp05Ed!hx*8I3uPp_KP|7EI z(yyK&X(TFysgM)iNs(}`d}w@2nXPy|eUnFVjFZgCkON0Aze?poxBS zZ741P>R?nwSYqi zHgTt7l!2i)lqHAiw(LtSEr*=Jwogh72Ri>pw7Ln-;Mw|qAV6SCazS%rfEB(Prs;&q z0ZZw1bf05vqtO)r;vQxwaBzVzN?gGNPrR&|-?)!iL`*xAkE6g!TPg}rZioWNf`%*? zEvpp80t;Evpk@6+BW&4njkK9Ts)Nf!|HVjW(QS7j6m))ozO3%AF&mx!yTk z0oPf{<_BEF(^1BgpT}MuM3ET=s1f5th>VU$zV&WZEqi9*KP$u$J{{CNLxN!V3j#N1 zh>NjfF&};G!BI&)jw~w-Qt&XG5EJDV%5In;xoiTU70|E{TlfyMpCN~RaUojG+$Y;Y zW`R3hV2PU@nsw{4t7)N7ql(hBNFUO=dQ&vSsb|7RDzDW{FC~8+``R#(1TLXAr?B{3MU>D!lp^A^KcwiS>Am8qIoWnsY zW%v>(b7+3wA;6`JG_NU)1^_#TrJTtdkFDBG3xDuN65JuCU`xhpxEL|?$I}o{fYaP% z64PTBm1MTCvD46spJ+0ni$IcfpCr`)2VJQ;GzZ4rtN~9Nlhw;ARcRVwshZ~aBtNZ5 zL0y@(NHvyqwk7eBKFfm9NoIS9vf_3{D7U2(blU;Riym%V6Nk}hR@9xWM)PM0QKpq|Z;Cpsba6V!xh`UTPe z5m2z?)*?pNs$6xPc8pD8^(LfE9YDNj`AVkD*AXu|lIcN(Oj+G`6ni)mQBG! zmIP`x+1Sx(q(~Ubu9C0PqR|n1UL}u{5)wHM1u2sz9nQ>IQo;vdn29;S5ZdO{|9ZDw z+2*9-M`NA|fCv6>r`#RxT-U7tv31(Y_}abf&(cPxW6CCgIKsH@>MJ%jpzLUE zD2hUWlF?ISA`%a>djijXMB&qIjsIFy_$@NK{ptn1GyKTk_0Clk?GA|SX>lX9*pG_e zlnEtDL~FfpQYxvWu&Oa5%`bRN;P!Ss@9xvw(r{aWJ=a_EeUgN^ddpnjeA_JI|BI4g zb;!HmNbS%}5xr&MFGQ@UjM7zj^q2t}#OCn*FsY4;&|K8A3!DO0zo@ZDFN6>={zcU( z+FVukb@?J0?`bsjolQIAt1~c$P<^D|KRG@j70=ceX<{9yTr>@!I)p=$7a{W2Sh_{X zW2+~Yls*j^lda}4sSyH+8hi#*0CAuTp?Ja0;Lzv7l=nL)hCo8Qw$cvg4}kHxXYcUM z5_rPQS{-r{09U0X`G821zzp(}GjsXbedCgTi)Y8+LkvCA+=2CnSJRV91}2w z1r~AMfazd14LBR2+Grsxy>pxbVwEZxPq{KkdOz(i;6W#s^c^bB}1@T+cY!;^GD6#4kKii+4K6x7Cn8o8GgkbL7zq{`rX0sq zu6-#j?_lBmQAcvFdi!mSgQo8&1%cN5>st&02Op|K8Y2wT!c4Jrt4#&!;Bo%i+x{p@ z*M5@$FalD+qg@8%GtW#F*rh#C+K_tz3~h8P(PmhfsKVb4?zCNCm#{y2ds&BXv)=qB zjn%abG@6tUlMaGWBS&C{fcf*GMwN+X{} zm}PHj#Rb~K!3uWg0 zT3;P(a9|lGZt#@vrxp3_=MfXBmFbbBr`!g7@S$i}EmA1fm~?E(KQUh;9_d1ZUx^gr zF1!=__H8a<58Hu`mRzzux}5ccaC;ZY`o3As2?A-buO(+mCMD()%1t> zpNW%!+UAV{NCOm-B)pP7@d$4-#sXDi+muV0k)^l}&_qL~d+e*dXkR!pH*MF~ZIcy= zF7~vX_(RwmW+YtXlIcRDu5s6$gl#(q(pMgNm>D-E6G0$s?Q3Xfu#5{^%C>uUTP4Uz zQ^Dcgm^tBEu61NX*q(BJNUYUN4(C(sWM3({Q8?l1N!{i-V&!VLoYTr~QY;*)l_yb3 z5?-XG0*zSWT{EJ?r8iNSP7-49(j_vfi;}i>QJQI2_H+=uns#B!Mkcr96N>fV(>B$* z_&CE}v;;}oZp;hp0$D?j5kAMFqp4o}(;{>zb=gFW+T29Ti5P&w$^B0gwHr1ODqlRv zlzefUD#l^K*S4TEaaNtA4L)UHwRnJ{t*)vVmNn=dVaFF9*I)(dwYNRE0$&|qh8?vpjeqLanh{sYsq9k@=I>Wy`t zN06+1u@;*8F9gvdCH3|NYcxCVc&J7=i^ zuf_ULVGEROmVqxx8E;ameXxSBRtecfuvAQ%IDHK#H#5C_E1&spwDc8O(n{~L=lmw> zkF~@rGWTY7c*haY#wtgo0^2G_&;~!U5^gf1&c2xm#3gP<>zO*fF`Tq|4odl|i;!1p zU8|+Z(t@%~VWuv3FSBxM=KSVuu!d>TIn+SO19Kl$xIlr@p#vY+>pBSY zf5{I5sP%?{N)zB2WbYFoPiXaU2rjkQ<=Qt80uI80Y1}Muo6MuF>=bLe5^c-`Mn}4C zZr`o&CsE4hClFS0n7>_G9k8EAixoNe4~jb7`@pgKNorIyh!LH<di zVm!{{;;(Epg5XC3Fyj!CD#r0ZoCcCYtc1c8#THoBwgUom#_vI*#UL^*us8OTWWc|J z`71Sb1JQvT`*&R{wQ{&_z-JL{Z`qU*xhy-nK!cJ44GBY|O+WsK{tmh#$#t56G_-1@ zEzSm_a$g47xibLTjWO_8Sjz2oe-$HblQFza$y z<5)1}B82R`YG^Dzjlx{bJ8sN1a+wcKQ^Az1mQkkzO|_(k^m)kUgFse^jt^$&6G23@ zstCmO?2~~HlovxZvLh>Zd*2-2~JFR(0XvHM3 zZ>Dk@J_OSX&T14SiI`sDCA71Xxtm)SxjuEYC?b488us7eA+Z2`sN_L9PwH$OMOX>n zSExtL&bUak8zjz~rfhHB{@}fBMS@>^6hmx8d>wpfd@sOniIZzJ|- zUly>r(~wY1z1t$TJ-+URZwy5mYw=@W{BKDoO;>&16$UIrmr0sRX~HF`w!6)ks{cu4 zZSW~P>prrKdSvV;zJ`W&EGYY!uemlGjsPEz&w=@(&5}+lg2-=0p(*O(8LG@OO3jA^ z%a{y{0mqwt2WS~})D^@BEynQ?noadN>CmvXEu4Wv=>u(O?-t}%Nqe`3C3u{N zFduhGH*6r-rClNnrM6giCnyfz&x&+W9tD?7q4lHtjIfeR#FG?2%I8M9L}Jrv$!Q*> z?{Zr%(~^z^wEl%No|+2P!EL!f{F%k{lNBXSf5Bl;_NDseopw!@&y+c(-1aV5reC%= zCnWKA`04wtX|LUMAWqD>59pzLNdeAx(SPj@*UuCRi6TdcS8Qy^Cy3~*7Ida-3DfSN zR2Z|tpL199Ymxo2udz^`<`yi-k5F(--T1yxe~o?ro~1_r#4!%9)cEP#RCTsaj=1r-em(L4cXKCBr?LN2z*LZ*mPV3S)`p&C|6s*zXI&D zuUa_(fMOk0R*bYuUJXWHJhv_AO1K>QNpSwy&#|&xwe4ZidjUF{K49D7>8$NG^*8Z? zGFP#`4&{ad$h<0E@_$dBH>f&Tu!ZT)PHfIT4jh~0}hwhG-Noi||wJ9(q!8lb_2 zh2Gw)t_oWM+MSuHOf_Uk+MLh!*L9mXAcR5LaTy-ka!nIUTq%hzahwv6w%|ufBmCFQ zu-MIzDOU*W75dmZWrCjw)iz-SjoLc!<@ma>2xqA{y48_oE5#vUt?A?hP~4;l-1&tX zx`R7ivs|p!xi9GlO|Z>cl+a?&(5It5W29Q*;~3L|7ulpd;V3ip#lPHeEwlCGNBa|x z!ugqS?KY7&0V+;}gq=AHfaTH6uW zVoZ>S2t)5H*OBu)Uf&PkU3OWk5%JMF?JEKjf3#H#co`atB2rTnjEdfk9mn6Ll!Tob zDH!eNm?68+CK_{Q@-PB^Xnukqi>`P=p1iM92B|CXfA*<^_D7B#8nCk$%d`C$h`)@s zu^*m0Q$%``wFV=!(!?^19d7M5CA{n5JcBbD4kQF1B&@XzJI6OF(tAt$q4A3jY@L^{ zA|%1J3LcAmkv+>krG@sP*HZ-AMDy_T69vVxFT}8E{&t{G;3v{A=1JG<8UpX3$tDd3 zHI4v+=v~N09YsNnWbx#!LI= zCPgIiomOB*-WeGAO*(Y94PjN$SnqHLNUbVJ2O^K1sNB-QzH>RyLFt@USHYPu`#+dE zF9Z;asZZq^qCBVr1({Em$H$RX(-DVt;xs02X|2!f)SO6bnw(Ea_F(TI6%lkEDzWm2 z;1~A`wq~7?(;@7Kk1sqRkwFR#xD0_nWMzcHH+%-7T(1p_7au*Ymgv(SlV_5+!Pi(q zu>L4ovP+lB`^I?$sNi_0!dUh#!gK&2p{y~VQN>wcSxM=itj}tuaDRoR2jx62kukZ$ zGBEc?5V?x@XQK7{^sL*c)Br1lhT+~6Fikv;VkG(EO~?6!;-7Fv+%qmyN^jX5bh&ie z1I-0B+BJ-Hx#47JuSK8a)wI|qAhIK^VU5QCQ52>`<3nNzt53-dsJX>#->%=J&?bKT z9sLnx^ns^cjs}1{Aw3zc5NiN0=L$)RskmStm}$A&6Fe!QyJOxjs|NjiAOxCX?U*}l za3hP$pMG>D{Hfn0*MXA-_@blxlw%+RZ9oP8058J-hEG?LU6+Wb1otLk zEI7tHfO5HT)26H85NLeY(@qYs;!YjgGvzUEJ|3eabYC7<&hCjVm>i zdfa^_q&%WVuFjgM;o8kov&48O%$V!OE=D6=<*g4nHS{i)qP(7*<&`-m?j@#?|ZQng$e z?}Wd=FHGUnI_Sg_=(vRvDwGfuv8+84@2$#cJFCXnC<4t)(PI!bgLLcr3IFnuT(_T> zUoP0uPY>r`^8FI!rskA^?S*JgsA|E>0pj5a6^En!%AWr^kdI$2>ZGbVNAWa>#HH## z0+XnTG2`PhKf2?8T1-AcDW;`+o6pECrgMb)X}ioX|9wjbjZ{_nmXTXiN6L=Z8*nm4 z7m2yG;7RZ?QA7I$tTVKGI@C`2oR9#{D*wPlz3>(`85XrSj4lOi0d>=7%Lqj1(+!dPi4O`Ut$#`Ly145kB)a zO&s8mC(d5*yOuiwifgf0csoM>f$u4nVB&||TFRyLQ<%a{A=}{85Q?CpbeS#kW!%!Z zgvKQp&ipu+^+N2#4|4ADJ4hhbtshHm-|6K(i{Y2fE~5cKwvzwh)amBUDq!4R1g;1O ztx@n&VTx%tv@Vr zKuMi#m+gm0t=pXP6UR`XB|k-Y)+=m6)!3y@(mM*trqwmhpI~D!d}hKS<@k`fhpmWV zlLRAPVGo^Q&Ud;LxD(Ch!~J%5yCF+V>dQA`Ho=>tZM4Bi^Igxr z%Y@|X!=;_JtHj35xCSi|2y}8ap%NkBfTzWH-Sn85ohi6ss&20Zf5w(8% z-D%`><3w>H^f#t7TE|{U3^Q8!hn4kJG&hsA|N zm_xn^KRU&<00!-LQ1?r<5$@R<^x7OQkEk(h3&mtNoxq6;|5o`9GDd3kWkO<+TB(W= zVl)G`^CHm`gkt0V1s1D?Qgl^e^aMsx(j>n$YQuoqo1zj+IF0z;sjX-|t@!+f&$J?{ z&vm;DzZt(f!{ZkNY-7a)okEdm%z9Eh0+AOphTK1G0fJV2Pzemvsph&==KVOxbnA z5v?eTlHgUC3UzLZ0}zQv_*!N;STHc11`+*)*?;|CwZ8XE$p6*R><80Vqf#PHpmC*Tht1C81$@1V*c#F)AYWfG zL<0c>_?j+#oc80zq9AV>Emvzu(+H9n>?eVgP+$kZMAI}PfW9ZZsS3KQ@uT&+8chvf zy5nPpZ)~CX9X{7g5eYW>#U2U)-;Zv+{lkd$!)R`==>hYNF;+C%#OJipKf`{OR>GH% zj$)OCzQDH>+7kjJDLFYBSj&vr3msGD$Hd?8KJu)1Bt!e37>Y}%iIX~L=CC?JjdX!;Pp9e~;#bg0UFOG^?Bf;6~98$nx$PSa|an}xaHfSa!r*gS%&cYlJ`;sjT zM{~{<(5NN?hP2k4tJVn=R=c|he<0+(GFn6_E%ml2K*4KUQO(kr$pVBH%b9y4&0_5L z8w2f<$TuAZ`t=jBk{XCg3tg3n4D`!lT$=7gLp-7tyx==y$Da#Hm7H~GH#pc5sZ;VX z#3<_$88q$6?~%A`<5=U)22u#5B1?DmQv&>!>tovq;sqPFiL4Q@4qxWLPP;UTNw@d0 z+s4UTWrbd6Nu4xk%kwzBN%)`=Uo?9t)c!j%m2i83uqJW)vkgy>C@_-Esble#cpXi< zlg0+!0@laeS;up*%6^_zA5?aN>)Kw%+%1FoXS0)@YS1f%R@8kaT1<2p@|mklnN3JF zQ2(ub!Bo1@s@o*sRDVe#IPgkeVsgID4eDRrqT2WKL8tMFHY?F0n+bQ!D2!Ly;q?+T z8vGCO=$`#zxKx}yh9q!OX&3%q^a~u@U6r_&Ue2O&6}Q*MI|>p@S`XnhU4S)+>?N|E zb5tz*D);F<5PoM|BP|6iGn3r>&w1Lw_W0DE`6e3un5V&3;Vtxg z#5}IZbB=rygl!rc%fT9L!@%MP8gVJ8jZXenZSY7966l+gAFa<$4Hq%k$X5e_9?)8? zdBjNi+VlH72&IY7+gU6TwsP1GGGChEE#VUBY?oW6CmW(l@~afZDv4p5mLDB-f?m!V z@Vg9$Q!doDZNpRM$7!02vrwMRZlDNPp3qggLwrr0*MbI>jG%JRO^Z+sY9l6j<4DBS zJ8EtQ{NZJ^ej~f~Zi{>%E4L3CM@q2s6$rsn0iX8p>ste4Bq>EMe+O`Sw{IJDm_}6LOIe6dq*py_-;2+%W0e9>wE~jx)L)Ni;hKo+zC1eCg>=N$bXB9 zLTQB{A15vB$t7@EezrVcfv?2{aNX+=YIVQr6#Qq}ZErP{ruyc8LZ^U^- z&i83kC^oh*&Y0_sH~CLMo-RYl#W%yzZag1lk7z1Ho>{WLM+-SB3L_&Q(`$f#2|Ui4 zMiF^3?NEvL@N$?SAw13op^Uq3&r7pN>!;=-M(b*01gjpL*kMU8Y9YGmFHhUB3(-60 z$D-rFwxm_ci!ekZySM$OhEA>jFLmz$Z&h*akMDENzWbbexxfW1GyxSs%B9+qml*R% zVxBKiTGVK6kfP+FAQ#X?AlMKaf+%*u8Vf3lHCVucC>BH%Q3OO$#D-X~^ZS0+nwdTO zoO2t#fAaq419#S}S+i!%nzp8H%)AaC`g_^lm7Y6U*mxf^1UGlF zplha@c=1ucx5=)8yFk^vE053iFk5lAR&+wXV_mFw@V=pXDLh+P+lLAH;TbGk_QuuS z{5N~}$wIlS+gGdK(I=g9;^DIX(eV9XJ(HREDgt#^*IH>|SCN0cc3gw)i^O-~t?7Ub z+0k6X$DD%&uOnEIic~0&`Q%01$H{tyzN_+kt_tGaG2H#-(w~1z93vtQ=3vwsHU32V z-qDXJX?^ncZ`#aaS?cI-T_cItSj@rExKcZz^5(9+``~@u#9Oj{Uu~_D!c_vA0xTrIA#aKH$)_1FIUoml5-{Yeds8!yh6(hzDA6~U@Fj*Hf?hMfY1U6N;OJTfC~PWfmE&WDW5|^qI$x9X);wwmG3ar?I@QKW{-|WO6|QHiM;i zcFu`o#{Cs}=NS=6{2TcmeD zA6?`QU7gQ?!N}0_4u}31?rHS1FM;6>lHEPC&A!mGuJ2689vU>e%wAVwj6nbBxtS?I zJ@~ZnP#k&0yv5!ssOzecKl;S|l}*I1j@NmPLzh>m0PbqIIxU65xl_S9TR~a{>u&gl z-|(hHXHoSG408%_$IS`hPWq$>#G0eQCoh@7{`Pm)Pe4^3p>zn z^$YaWr>nPi>BC>fNp{?S!L4ZXiLf21MDd+Ew2lVtUhcz1CO7Y}8Z4{;o-!?wDJ}FJ zTzo2a_^Xe(hG^G)tR6Tj*`B&jm1%cXcsf`oa4^`-ZUD~B>bVEI&e+f)3hhWP&sCj( z*Ph2h)OcbYPYa69b>nWvkPP;NeHtU_kVXA7HIC<86_?qhWTFRaMb5+%~Xa zDZ~b#uZkZzXjnziVoWRn6gebQpp|}9M&Zr(ykj#7wkX4bV+I9$i)dS?>wE@XZ7G^k z$=e_Ht5_$Q(h#-yjSiL09<%GSgEontT9d7DzS^4Xz)a7RxYI5(@BDk6x?E)T){A}7 z9$A#h5eHJUv8@MFP8>dLB)%sD<4r!j^DjAXBi38-Aqmw+7p*0m1q1xZeg_!4b9g`O z=&}g;QuB~gaWoF!+U3WH@sCQZqd69Pbi-CzoZI<7@nq=!cmjSXcHaBpNWy@s6UXB* z40epN>Nc&2o4B zA{FqeUo;&^9muwV5u2V3otM`GcO5AXeFVFCf66=~ZRZPE(Ue|lps-7F7cB@mmDRf>#N9y~R2Ux=eYs+#rlY4z^ zOtL{3r)`>~{n86NKprzbVK_Q=ZK6B0ox;x%pu6QKy!OqTc&o`I-`0@5mV(vrnuo_j zfA_1y4#Rg)&9^L)ZKSB3w4;ag%qMXQraGpmke2D!xSlH`AO;}spchwDbmS;tQJ{Ob zDObo;#@S)x*~R2rCH35w`qwwjqIKK7ZZ8$zb!YWlOtc3gM~^#UxU8(zF&q~;_^q#l zqITD|MKdJtCLBtJXHzss4HcRr1s-1IF|ht(iLqtL>0NvOWQSUo+&qz6nR@Z0ZsVl5 zHaIJ?ABACybBC@HT~pyy3+;J;Jj&q?xsj8bU)k%H4KNexS^zI>FnMzw`_y|(SSU7z zKb{wrn+3LE?nsHo-#|wvF8!%=s9Zm)Z;#DwTl4kMaVL(!7bEieu_6;2IsISDO)Msl zMG%~E$1xGinPqVeC&}#yV|sb--d_FXh34YUtk`5gp9RP>W%Tx~In!wktK^}yLh;l{ z!)#g%E4)W6&yY&>I%$|3;2$zd%ur)q)@u&Q$?&0eb=x0yjZz9%<-9!-stJuFdEAUw zQ1~7#S_%|jFCpA{?30d%-8k7FJ^a>Fb(~w3Nvy!&GZ#EGYreHr)B0QC_)+tqWNSuY zOG%glI4X=fzus+1WCacH8B$q`mJxv98=y{MS2dUTVzRtxh`lek-+)sIOP zKcX3nYMWlXw$Ev%XZ;nHfIaM3yiuD0$aedG`I$pfz9O-&W%=U0f zUSBA$UFG)GmE@ui2S#srwU3^S7&qL0Po`o02UjP!_A+qvf8wwQY|Zq=)=X>#B87$;4K-XxH&ejk zTY;E0Ht=F*)eu(g|EW3-XETTCtJATK>_pC6J?Oo^J6JOOBz$WQ2MJiUijUT~UTluK z)^o_ixQoY_s*WEztRJg74ypdn@PFwO;jseDOmv?rY?Q@2z{pQcU(G9+Y_apVQz=-x zHGCq+ENK)hArvfi$XF7ug}VZ(=X}V!hoX;F)n!8O*wHw94V3N5?d^#nV8_+kkC7(2 z4tv(vHgwx77n@G72D-CHc7?;8KC&FF5Hj&DI6NAUz&0hc<|;hw;pQ#=(0J$GE>vu zu-(RLX#KJV0_=X6UNivQCUV@UimtcBS~sPWzf+>eEfei9-u2L|AE;;2aAv>Qjgo$S zac8OD;R8k|4F;2(w}mX-SkXnf0wD_)>H1b3j^&%YiJ9v~64fE@6&tE$toNZF6;9jC zH4+|<(~TIEFh6U;%YSm|td26+vBs|XNWSev!^KXujOA_g>{(;z8fx7m#bCy};XArV zYWMbe;|>KPYu#ujIF+Oy9M~Zf6ib}2LHS}*{HiF*;($VvfG_yEX@|)?>xQuqaG=H> zmUN%wft@*e7{3Nr^8PXvFzN(6_T)~^ z<#o)qpQ!0Hq*>neu5g%dBjK>$=&^sT8jVTjSS{+c}#X}Xxc@rKt(U)l5&{L30Ssh3H!V~7W z-ir&jx+Y$;eI|#ccmqMF`?^`Ko!p7X@#|VNQ{8e$?VH!}lBu!o%;p!nOl#TEa4K5c z3+_qw+i$3yKO#GL=n%`?c4I`QkaB-nr+HpN)+F^&cI&m+z!DEuHMgt!@1bFAm%}Dn zr5oBccyo2H&4Nq8@rxbY#Ic|9V*|~5%iLIEzZ+21yKiE*w;%G9G%Re7O0~$rsd$-{ zE6SsIqV4z-$KiY&O3buKR;eAgy=1*X`ycKbi6Tv;Se~DCwWK; zI&zm9&DZyz1I>=F`F0;iDu1aHU!8!} zLLKJWL@r}HR_*zw`7nH;31_{M#bd^Rc&Ci-f|BINW!GJot?^|kUP{V)S*jlEF8M|g z4jJP(g|3_YvTDE~d6lnl{6=4dqQLq}yi;mBC8G*ZaLy4W z40-xVWqfX;){}pDke{#BLj7ZLmdV~7sc%Pa4&vMCL+u-mwcZIEnYi0Z z{tQjqT&07(DBW{V)eo<^tKDoq(KT+!@%F=H1wCV4f5=KR^wc5VmmqjN2&+W#vzWNZ zAz!9U)@IvnHvB7pvi{W2!NkrId?ghhN?_IX{Qa1|Wg zQZgq+>Y23R;Uk9NoqV%AOgoaY8#;f0|AhfP=?aI&!jvoG6@ z{Gv(H$LVX{&rP!yiQWQ=>e~cY!_Zu*6#KYD+$364} zyq$=X3FF7&0=2E`4LX#qixPG|Uwr0@p&)cq2uWATl!Q>uoH#pj7J*I_2AM-Rofm*ft{ zcr#H z?4A5_pF>AYz{g~93|S-Qb;Sjh&K)DmUn7=9graqDWWTu1$%Z%2kfL}w+s|>;P|p78 z1GelD_&6Spe;tpnzH%t$eimK6Q>Q0)dfS6spmw)C0HcH9h4MOI{P20z%xcGGH+k2| zQ6~IKaXc^A<4<~SgF2;7>bVSKI(3xE1iA3Ud)`=va+ekB+Gs0sK*laZKnh!*3Y&o) zOt{Q%PjVxIdy#%$d90pxE9#niwtv)#qc};G59Xnx(4`A69WzoTPlH$?Oiya}dWtsU zk^MMEW8rWZ)H|*U)H~j3Wf6F0Rxz`D zhqo-WJxaT2XvYOJhJC+0==Q5a4>RYJ3I}Q&Am}yBeUcB;cAEO~;SkzVRU?LsQ=__PhswfFfKC`W{FFL-hz7OGBBv-&4#$tN-?`qQ8h~kx z^c~voHnjejYtnMGx6bEPc5n&PeR|j1_BueSQ{m`@5eS3H2`GU7(fe2WU<;oo9AHd{ zhGxj_g4OF?AkhFSwr#;ucD8@ zt;*U?2aFg#cI@b}0jIO0hM(GD*y!w_b*36>aQHg<5p4n{z_PFHE-lu+$YR(0^Y+^;y5M}54UnBc z8F|r#aG`H}^$BtYZign#qedmxw78RkDSCA^7ar}J)_`ABp>OFw5S;`D<1xpLl`m!d z*k;&IkC`D84QVuJi`dV{8!mjq4aXDlq`kC?xc{{VD(=a+$NapTYxw?;n75`Wm?J2K z*0X7%7|d&VMZ=ufM;?lvwTOi>l`px1)mKjg#Z-k-$cK+6+csF2%yN7oK8wcbEk*-< z3B+irj)PE%IRR@|_2{wVcD#0Zb*pemhUIV|sulNQlF4S_6`}R+x&1Kwm>oCmah)_-yCGit<*8R z@&JB>u=<4RasN~I#|ZJ!Kz@?2Py9dmslfjjF@Dr2d_RzPM|se;a@5GP>&B9=6|;^=+UF6`&T`7Xip?=Kb1JPC!aNwKb+ce7Tsg$m@z?5 zk+dgdtnA&l^2npA$NblSTc3WR(NN%vj8*&XgZ!K{{?tl5?o-IT?&NEyaH7IW!DmfQ z3StBekg@z+54Iqxdz|2fC}{#EYUWIJIMDK#n~k3E^D?|xHe`&Do+pexad^-1*of%a ze|+`0L#q$Lo9Tz)B0*28@;K~)3?0#X|9uY}-ec&{0CZz}jy!4TsPV&w_rzx@d-m=N z60EWm3*e$)5quI?px;7vMM-*cXC|3$9gOP|ci8ab#vh;LVWNy1+gtIdSga&H3nYRX zj8=*=7*joNRM7yasOOmDs)kkf95x&;?A4E`Czfn@Xm!l!Q6q=`wO)LCjynP0X_sry z<|BIOCGaSMR4Tl7JY>}Iqgj~%S_=kVG#FGoY*h{8Rc8}UQZC)Wt0PvAai|!2s4%DZGhjs5O*2GnCUJ zutCPSND_c84mm;?$`_0V7B4A_;!FVuJYu+rF_dnA%l+fDRSz9cyP3&C9y$_Rzd{#` zsIF2e0gS;Y2cfXvGyGIe^3VsKWGXcd03OF;lD3FE4&$6za*w@8OD+YDz; zT)h>2Xzme&fkKYw#o=0deGsPQ2jHjjUP9%_lYT}V%2ESSnB;&`z+9%F`8XLUd!5qjQ+s@P4rHj_C*qLfkZ5I;NF(qby=fuCMrx-6ml0Tx$ZjMy_T&k8C6jsuJaq&|YgDBqmyk!vK$O71BQqzX{Es{*1FgL-}Hom4>p z*<6vnCS4GK7$QS-v`aj)=|)Wp$iYV|aZLV1iuqldno8Z}2iC&}bgZr@xJ*4^ z&^I+G?E6$nYC!l@$ZT~3vWmrF(-T@ z_kIq=@_z2yTxRB!$>F!Tv&$qT2q>fZMIA3!C=5oIU7OpkzxLrB;k6|wvh%Z7WqtIM z+2<1em$I*ALAE-(9**VdT#xyAsnn6-d8wOHnVHijEB7P8{o*Xpv$9vxc{00zhQ~&iNO7pWq)PaUs?87mi?7wf60C{%Vj$#85iu+W==Reyem}DrX_Cl zjH4W#Iy#)1o|}gAb>^xN&Q;-pP%^YJ{E+^S!q4F(;^%uje*F=n|DV#m=7fJ55&cbD z#)#3WKZavZ!=I_?1!;yYNH0w1#spAXget!Wbqj_2S!H@p)`04fO2j6Ya|2^7?Gza6u(n+EGOh5e9a z39Sz_t1Z|#ET6k6 z`Iw-PJ4q7BJMK(4YIB98AA~_U(!DqJR?766iIAfa@yneDYrQ+QEM>rDsn1ebc2(?hZ_M10G59+&OES5?2d4&Y8L%X? zHdAK$HTu_Pwq{(ct(k2SI0c;^0!_kEPnRq+|4M2D3Ot;Z`52v{s=LpIn*d-5gGEu%!r|zud0%en#s2F(e7eH3s<9j%_D zkA>&hAwn?ZIKc%$DtC!t5I~evrbcgid@d239v?WJTWKQ8D-8BWTKgX&X&v%QP5+mJ zfEzSeJ%dHEV};<@KN(>RpXhd%r_$2#6|mN&7bxvkdU9Yr-4F6Ye*UXCq>x893{~9^ z!k?f2s=z4qlIj5II&>3(x^-6}5o=KR^F#3Gkc3{5M(#-?WAjAPG1?^+S;{a#0fyP; zl0@?snrG9S*GiKro|=z#si6@*(p_~B2EAx7_8N#$>+IBpDS9qUU6xAe=oS6R(N!|& zn)LNFFePp@+=aD4L5H)`SEgCu(oWBJVO<&TgVYwXmdX&tVeJ|3gVZM}#>4W$eI`~e zQw?K82Xu_a|BJt9YPHSy(>qbJr+2!&O=jjT~9+xFbPC*8|BKG#tKp6mEkM3f z({+ouTe`mAO#Tvc*b zB*0nG!cvg19Mf8bQSpY2v3w-qo`X_@!$H-V2`NldD_2zta6ymRJ%FCw3|ce9Dtylg_yw$z=!Thr!kI&Zhx)W!zodhM-3 zA8IkS71fp7J15%QUf&eTn=~h!*Yws3g+6I^V{?U;H@~xmLNB&hzmq~+cKX6VpYDA5 zE{eNpm)i{V)-D(As<;bVUe;2fr7ah?QfNu5cMSAlt2bLK?v=KW?WWMG-QG6Px4WIw zPH>UUU>LlVQmVD7O$OSQTAvo2WF>mRWvPo&-q-fAwqE!vF1(F~-`V!T8pF5zbxx?^ zfRz7%u7Vi;Yf%y&|ASpPu$M!ltJ=J!kj77hF9&}O2ZTcN45mqrPvfw93l?_%k$W(w z&;w1DHc{xsT~|ZT4BfQrRs-GH=0T(fTrK>TJAQ8F{ndO3=S@+m|S6{36!Q8q3-$RPn9cld9!tpfVeN3Z-)egPTy%3(j|0F z>nG532yJhDK2ihZrv`69YB9n~cS@>cjM&0cQm13WHFum?z4OZ#l^gu!&8}-^!0Vbl ziZU}Kk2ZVU;va{k4o_j7=k%S<+sQ;ef2WHrcunh@TN^Bex74xx786TsAWv{AjD@EP zBcuu=qzaRw6@?K}g%MJP0g4mU;xQ&yTqs8sYW*LobuoA_vL$Hq6C^EgFmm{-A8n>2 zXL$yadXU7BUsyns#E_=gFFMmzx6VfYo%go74p%jLuaUt%RiI$kpWzMNZgh@yD{?XCH#J>NCvHknT_zQC1nJ5z-1+FRv^_g6e-3-Gau zHF3eNsaS9E>npyG@w1v=6Bq0?t#5S&>yq`-Yp)r(9}E;?Y=szAAg^>97_;VL_8HMS zr2ur9JY6OZH)a4&5evy<^Z%vhVlix~aIXEi89oCVxKYBJNqWPYz1m-tBnf=45=5+j zHo-914lkB0tyS zRTv9G6dmY7+Gi%@F!yQkbPECnq2P9!1`8zN;9TY6_X6i$`#XE%x)!&(L{4@@v^_3r zaapktSYAkgfdbhCX1lnsXxV$6Q~of9c|z|sz5>=YN7`obnx!0}sDL!#-Ltq~B8m*%{X8!@X(7njkcsB|eP-OrkQCGNDQ7dEB;rsj7w zr@OWJ>K1UlwI7dV-Pwp|{0)kxV=J@KplECZ`rDysiAV#XqJ`z$&S1F=)N&aZWNiu! zlgvh|PZHkIjD{4wjaHu|N?k5|z>jGb=9`=mmP`;!a&_s&Wd=N_{Hk&jeif>b!LlY9 zkd?`RtWO4Hl``Pg=J&TS;Gz~U8qkOm-Eg)-VbBA5e?7H51!oG68R(`GLp`FdXf$1W zND~s;K}w4zWLBL(y~efFrD>tOqscu@1bDp3(+VtVzP7nwzG;4L3j*k{j6})!Xx3Pn zAOnTSK_RkGh&%+Ui3t*zC_Dr(LQD*e5EDZq1g5pcg(yM%J#)grfaGC7axozJC|E0} zikMSH=r~n~JQBS^BvMfO0(Vj*q2493qO>IS7z!(VEd4|}GY)%}PjK6MAkw&-E$Q(l zOXyHa4&)S(W4Ck_wR2sO!s^|M)Vfq=47jdKf$QPQ^>F2ScmdZ~e^PDQPth_BgR^;R zWpm??8^hV&_{=77E@*yfb2zh`UrFbI=8NboZvGS;VG}KKu`{J(f?S7=xelG?gqdur zKf-f1G@GejKT#uW@*<2Yh|uwL6{c}C_xuB;oMm4l>TU30&=ZviqsgPuqme@AR?Jj0 zj7O&|9i|iC>i; z3Q2+#^SGG&#ks;V-|tNBoB14lJlJ?%wM8*rx`+mY5-G~c$CDLwko&VqQ#F|zeU=uC zQEWN`W!Fw(_wJ%Nmn)Ry9eB*&OQ((%&Tz;U4tc^MLpbCHhpbY^*35@OasgO{ zB&0$TQXvVckc3o7LMkL6X@RJ-an3oFK_=hvGIWp0P)bDcX(1#DMb>*LYdXwXRz~Sb z%#>45oCP#V3~9ow&xaUmws^^J>>5@hDEy==l~3r7z8ek{C}-F27nX`Yp~R?cwEDwf zC6`i=-S@lAG3ESl?`K>&Z#2+?K2Mo)p4Ip6BBh&P2xX8P9I}G*M(>Su$OH~KNn%K2)`Bcu7*IkcRV-1zz@qbAc@2ODH+8+X8=Qr`miB`4darlr+|&DED*1*! z^Pyxva^T0-^vFOV@=%Cu6e1^u$V?!1oK}W*tmU3p3DDPGXN1g2`mt9D(1$sKLJWs? zFm)6z3(;Da^&^nIWnEXu9@sZM&q1b5HhmglEo2IjP?IwU20VTZp)E|CRmfDMm}f_r z8Xb=aXD%8Sd9t3~3+OX?P3o^-!} zTIkN~wNBhOdw;S&{9dmC9~jZx@|YAU0#fjQg05a_U~|ahZHm>K*u|M|3mvxY2s6Ip z5jpBN+7q+=Z+bf2I%M2a#*ux2yf|7OvM3VM@))wxNVXv4H?9um5SH6l%lF-$n|mq) z$$d<;Z)Oq<&v$!%(33zhCWFAl$qUNOJ)O@ENHM$OX>u&`1j|d)j8s08+R~H^q}`5d zCA7S@=Z2mD(az{`1$eMi716(T;T^E^h933H%I%c`6$zh@ zoi_~!q~RS;78i-_qx@G^u0?#ue?J$F?H2afk5@idb2#{$aKm4jqr8rEeCCFk!Lu+m z+xw}#1-QT4l5PUrR{21s0N?jGucrVDdOzKpfaL<$V>B<5ImR*~AdCnIBLcz*fa$H2 zjmP2oj3m<_QMBVDt0W_)CyWTxA_|6!Ax0ON*9_{f_0`Ay#^O#gbS+9I2M6FNpXqZg z8V6_)&=)hTY-2Re#w3H!be8W}0HgX_3{8`;dj8*p>M4WiXkt0PilB>wOM= zMfbVg4fWja*LAnl*LAjvW(o%m~`ISX~Rr$3=o1Qp7H&N5E ziVB0nBo~Jb%nX8n1CJ~jpQEHlo}4)X&dKAAfBY3GA(+~EdS{8Sy~`P01#?E%sa;D> zmPqGxo!(WVeb#MCcTy#ijk>usFTqLVaC4`vo#4FPWpfueA9UGDXI;0qyTQ4w^3F;* zteop(B9&o18iixpY^GrK_ot3|C?bUIMY{H##n<^a;`_}g@vZK(rjz*Bbb6~(3HTzX zE4r-iB7v`Wd9#ZIzS-riE+r?QN^QK*ZACZ1t?2f0x01=kK@wxy#3}C_&3$+vs$%$? zKU-);m)E;k_yt5Zu+0Y)6vgouq@uYu34_%T%)%?WYybRK#9b{3BTF9!H)HmTDB%;`w!xYwbWV?17!?V<*W*2fymMTGH0bKgjX3*2 zqKj~!LLg(n89|b1;(Mwy``nNI9uTCtDmIiH`VLxxN@_Azbe^NO@c9=G5!pyrW~ z=8=%*5s;rAN)SPsM?#uMKx#g@I<#aRe43i8DGO0U(D57;unS|<43vtvQA={ zMz(+^i6ISp2Co(%AIWr*%{zL})UPnO7PHN(k)<_Vzr?x$p{bP@!-^sFZsofQC3VRl z)g>X-B_MBbmGVlaF$1KU1|dy@kfs4BnFfP24MLg*pxV>e0#Z$bkfuRM(*TrAgF(gW zL_E5@BKpEuFuOqa65B`f!fzIOW0k>>O6Q-syZ%9THcl@>agDMWSx z`LbzHv3%P;r4H$wF&;2m#Uj-xM;uj15s0d#<^B*nV*bx~n@pyC>b(_xwcMZF|n^NdMCv&)AFZMSEQ$ z?y|kU7I#~xnVpHhw)4|n=+5kVYj?W$b$?#m)!omngg<(?vq}>NqZmByDPBl-~I*T`jn8Yx)EdE%kMC_;_b`rzbvQt$wcD5jP62sU@Bfq9P2C_w4;r#?WFm|6(t=5&cmw=3Vk1)1G{t! z6oeN0qM<8w_pW1<-jlKvoaShpm6mrL$DuTi^_pG;6*>=t)^0KO#el`e zd~?|7w$(KRJ%G0+|DJ5L5 zPDbZAjf#!EwaX7(c9?+{9a#wEOQAu<@+I}GxD;APy|BClJcG^8M;=xE#E5M_pB0T= zQ3-6|xN8?1SagbD(P_d4PB4Jh>#0+WueMlW`Jx)o@^u&~wsdZaDK0cQQo!={FpJdk z^)RG?d5Jz8ukkQ-YJjPAD7Ga0%s z;ZXs)Uu13-EBT+{WfA<^h+|=s*0IGKWx$y5Ft$4_UJ$T_JzDM3eGFrZb!@2;#Ryy2 z;!WB~3}egCWT_Id(K0RG#7<%uJF2k?!4}Sooy0J)7&< zDukX&st{bMLU5%D!IdfmSE>+PsX}n23Nf5j2(DBixKf4SN)>`DRS3h9e<6|dQib43 z6@n{O2(DBixKf4GKDHfU5Y4@?%Gk#RI30YW7u+lk_Ay#>csm~LQD{;4yh3cX+YOy( zA3K!Vy4DN(SbK$BxHn?rXDwT>aVU*ry(k>UL6y$Kpv7B^<>I5%J}x!sn2sLyaUMp+ z(7(~?rzj8xm!ZR>!FyY$cd(#9=<2<1frSJpn$g8l{Z@m9j8ymJ$>K`CW%(v}=Bk$) z+n9V~A9*{U&)*@#AtPh>9jFMZy_d!x>*}ky_#xh9~300=BVZo7lrJ4OqY)#@NIjhBVUgSe)3zdFgoCi}0w6 z{BYtHHt`x5qf7VNxR*lLbiNfsC~!&Lk%+pZOWnau+O0{RD0{<`kn#kS==lTYRv0QPi||9Y%^Mooi%@2F-~Suy;ModbM{w3~6BRdKl8c-p#|rx%TQo z5iqjx!r&=f$Op6V#g?0Jm6Fg+t-rzTJVF<@IkTNYv)bKap!w}K8fZ%Ug*X^Xx~1)( zH_%xf?&+Yo`MW<0yO^P?cAo;vm(U}7ZD5ZD=$lScQJDx`-1%{Z5~HYw>9u}RaU@k7 z$5MqjnkvNcR3KzEcdSt@#wk%PaFN9&42~o%`-&unEnO_$qOmcwSv*o=>?DS<>tpeH zvdwNqJM-mMx3s3asP)}q_b%S;RdLtuHme=+ceZ<9+%MaGEABn**UK96+74fdU3~WL zcgouFl)Yw%-Fr)?d&PaO(-yi3HIrX#@2;2C;G%Y}&1yn{Faa#ys33{4U8R>r&q{`! zn-@EYVQjH;Emb0IShW^!(oSL+TZS7;m57ZNY4Ij@62sVH=US>nY*@7xZ(=7gj4gJq zrAowxRcrAkb`rzb^|5n3t)k+fZ<2}wS1Jx%sW@<@;=q-P16L{zT&Xw=XT^al6$h?V z9Jo?(;7Y}*)yhT10bLR6)^>ZaZg)MwShoc@W8GfwtT>#pM#~L<{|9xeVDD&4&Mh-E zo@MJ$YNc8)EL#(2x#b(L{5q7zv0fAh|GK_@>a z?)JCn$&NfsZ9PV0X)&!qcLxUH%vSHB(fK&4 z(1*KCLHAAE6CGBet0uI3_gBzW6Z&lTZw<7h<2&fIiJRT&PITIUqP@E6P$EYn8PxB3 zSmgk`L0c*OzX`E(Tosq2BNRRMQT*7)EW|!$Bla;Xv5(n_eauqqW42-+vljc9z1YVr zI-j3Shh$crr`CQwkzE{t!!0Z=B|=(CgtU|hX(RN=QW|q@og1Q3orm5_=`NJS;2q7qV30VPFckgMqaT&fnWa?qlnbSWlX3Q3nD(xrfODIQ%4N0*|} zrC@X^7F=H_q9GC-ksNm%U zY^*StjTe~^F`T>0LwFR6(3iU|Lz^e`cFUC*ED62S=4%6;-u8a9Z{l8RdjW<`LRai| zt$|+IjdLR6PH%q|T0fy%+P{Qhlh8AJF2Jx!Xj#Wq2KuDqEEFYh3DaAtbcREEeYlK} z&T9ziyarIR5+{7obXTpmV`9X1aQ&{^kWoTUw%lUgTYI6^C+OUWyR^+s$S9#Z+H5e; zIc;Ym%f!9a{#|5>&{-WWKu1PsLC43C6+nLN)}VezsQY1RI!pnOBxK9?c(U%F0d=_l zcD#YQX`Dzb00kC+@(Mt41)#J7P*?#ds{j;L07^>07gPfJ9U%_IB#-S{+H#zdL zAa#uN4{$h`!Qn^-hr<{g_7QM6fWhJD1&2cy9Jc$^G2WoH8<4y0lfhjh3|!)fDFA;R z_M|VFHCgc97dtLEBG_ORY_JM8SOpubf(=%|2CHC$Rj|RHVEceezr*n7up=^)ARWa@ z4fZ?DB5?GSv-!SHA!iq-mr`3F?6PQAI2X2jh}ycW)q~X5+SVVphVy0X+o`SPZC4Ht>@dnLg%|Zr`20qMWpdiNx=rIV1re#!7A8b6>P8yHdqDY8?F#+unIO<1skk_ z)k|A7kCmug|4wbyU$B3nwxE+e|E9$j1_z-AJk|PnR1(2NU0q1`%tYL$f3)?I)&vSd zVejK{I|d8nRRbUNw7)OtP{miFwkpJ$st_xyLQ~sZ#YqY1mbZDuK&-BcV^tN%Z$cU* zQxVgG1mjCl1MCU6yLldS_dV=Gj1csRjKMyUS(+)E97GcX`FIGb^3^R((ACIakd^yd3TEzpuw+jr7tgqP>PT?)p`=gan=d%xtpp6{{^pmtPyq#qU3mY!Snw z&`$Fc;oOL_(q)%Tm(tQ@r$v{&1YAEUqWc}ezwDsk);O{968o1Gj4!F}JZtP!S#zVd zr)gn^!BIN)+|}|)9msUG)(eN083>b3c1Mba;CPkAbFCCMsgFTaoUO_u@G&$OGr4cP z)mCsQ*1{4s(0L*oGYsBLX?A91Ud5ww9D~>I^!3gP-M`EETvP<^hFxDX&{-`vnDP6} zR+rEUK_ z#YaHr?(x|k3Z1{_WqT@g*PaU%N=)oEOjlGH(|ihotEZ_PK9s0GV_ZkaIx}Y<7(h!} zy#QlbD5B9Wgr@SntsX8Gf+sOx{4h|USer9l?6xTTIXi#8Gn{i!M|UoYOT@N^Hq$ogkMHZ}v^i&|&EH`;ErAe*7VZtZa6 z?g|F@%)=vPbe6A_7=nxOSa+{`PXJlgMR>)*4ObJhz6Sl_Ei&0ASU+#2B7F5|rplVc3D(2Vj z4F=KNl9QPNu7MWdxD*qe>)8An;$!#ew$!5>mSk%wx5R|<0MKvbBaSgj5A#?G8~`$L zmRXK*9EUQ8h71Lc1TYQ`09gWqfr>1K2Y{Hek0O^ax7=_s`<-~?GY^9&J@YUaw-*^( z0@JHdYwSXeJTEE1U5ReV)pBv&F?2y$LQao}486bgT^PLy-P>k`fnIO345K%3Pqe!Ob8|vZ zwSUP#@3;R#p+q;XR60JBUdLxZ@{}%$ew8z;evKM5rTLWRa6WGJ1IJ(N4BKF~87Q|V zZ+aqL6Y_%76Hz$&Ua^f5289V&HAkN~DVmf`tZ*~_COyi=#Pk2Pt=?*dmz<;V`i}8i ztv0suf(8QwrX0^WCKo7OP4HcQV>vy|=$C&}$*lxaombP1|P+s*Vl~!LuT73b<`7%)S z#pw$1+$TPN{6vZ-VD7yfoO>I+)CkVnMsL%(vV2}SoHv?&)D#Xsje!n2Ux)u|?4tiV z!^(9m2DJs*e`evVE!$8A=i;Wbo5ESx^f5SzEcwyW2VqkjPrw2EZ z!yz>s5*yyp4{kL76Zx*luFG0Jei&jgNSodQD+@oC=`6n)LC;jAt7^-`Mj$-}t4*$-bT(qL@)13>}OEhqQJC zNzinIg1Yq;bv@g71@#1L?;s;fMVwj!EjAF?Sh_G^LoID4wj0a7cnB(qjp1|l(d5j* z<-d#s0a@nmnhKu$v1)O6sX16I!V{e?@k9_?)>Y*Rrby{vlfB#hW?VW5HP z#&XXuwb-YX-8>Qz$PX<@33{An2~*14{-wh1x-3=3!817L#D*<8^}Yj#rdq73T6V zD9SvH+n)*3{3g_7&@xd8lwowu`0%~Dh8f=&rsNC zzRT4w@NoJwsTWdkUQ4ZqgQ;enBb1Tj!GeJ|>t^?H|997-5ua-W(sm~Cjm_p0p^b+-3s zf?sNd`AvUy|1dE{x;+DOWWAViPs!$&bnRToq+* zz+kW{+8Cuz4#JJmwkVwW+N3Dl7Cn_^Q10w*8lwk&3g-Qd&X{GHUY|(~2(Qmv5u)>( z8{QJacT0E&eRqW4()VpR1!i)1Q^^K88%jPd0rKOL&)|zwLYHYxaAh3bc!^D6Kdx}^ zHzk$oAO4U!KMm*n^xQO&bJI7{dsF&0@h-|d#kWYfqV~Rt9h8o>--k+|!%6GSncV2l zE-NkZU8?I#ZZ0w3rDFPCMvp}3>hR4F&f0Jzop-~J;E3QJ-Lc^$-p^YdejExElqLDJ z3@0tek<@o398i()`G~LKfQp2ZzlQThUU`$8Esj8V=V3_GxPT^!Aq_e>#|PQUs8PvCo%AXgR>sG^YMm8LLEMs$eNiV)ebFgO#Mr4G*w&k4i7Q(M!* z7Yy!ItVwI=g(Yv42ozT{O<4-|R#)upP?QgZkFqEw@+qatTT2p0~1*5QAED zpsS(-w9FsKJekp~urk*cE)$11{$3jYVHclcrWe0$emK^a2H7gEDWWGl#bBCdCe8ml z7&yevRw##QngvO;XG%Ic7f&j)qcO2?@7NL;42DvRiTU_QQBdxJq=2Yic^FY*$4jYn zE+zDlMj5V7txak3L<}2>`oIPY)1wwlX40m~36cyViTx4TSVdCFB5^OgciE&ZlcQ60 z<#KiE&6MZYd&@De-b?@jznPMh@;DXb2PN{KCb!Leu0CEEd5Gpl6>(I9!2ng1nU7ay zncQHLs?j3!nukGkvYmdZsZQzKbTbSf7P|)wW_cJXH}fZ2K187~=#U;4gdGNkGuNLM zg#&MIj!|S_czg4u%@wn>`J$bP$^~XnyC6lc&kV4~?-v}VegS@)9KR#L@80Ib-z$6> zV)!1B)8 z^`v31(aF^ilzyF1?^kfNRTc zQQ)4k#}s(7>;(mGX>?B`q4}=S+;Rd=o+|pB1PUY+iSeI`e9b9x5EMDTIqib^qDY1q zMGkUorGUf`@V+A%ClmEOK|NuBDbV2X<<#q`%mj4Gucwyqu-7M<=^>n(!rSP49zI$E z=M9)2aJEI?(K$VPK9}e=WgcR7xkfA>BvA^zklOMXymqZr|A2W!=pWg6+1$)&6QkUp+s=uTaVVEHkBNDj0jdL|c__ZuPK#sG=OPh^ z-aAhHVX!Qfsa`ZG+|c9$d=M4DmrcG`;Jk`i6@q!FVvz!iE1ne~&lD1diygx=c`59) za2nQ=1-QEDjS9Tl^j!t!SNyX=g4R`hs=#&l+NNOMYL2h4GWwhrw+kQ#ZxRB_qWqph zbY8_J5})@BZH@x0`=T4J$*Yqd9Ki7je6JEnp2~(=CGmdRY2mdMx0vLBk7^Coi1u&P z)p44pGyHH)lUsE%6)tG9&_EwS^^$z}Wz!$HVu8BwV6!#YA|&)xv$?te72eMCT1ke-D#K%y;jzl_SY>#uoDU#NkJ0$BdOmWYx*(*wAfy@qR6{)24kjKUjYml1 z(XuE_rqx5!iuo3X^Ae7R11b_f$-hzKoUNpo#8J{DhBA~F&?GUW$(8zih*29kI?^?P zU-Ky8r`QOfdv=oxo5V*7eJb>q$N}jTBBekwzxOER+@j^frA$98KdzM7DNYu=K}S8U zXuJlgP*1QltfZXG0)rzQd78l?jXVry26GHgqdm*J2*_dH41?!uvE>p_yE7#tB zN?Y7=F24=J5&ux*M-8;3@x@REaThnau1QR*ADboq>n5k83n4VC=?rYn61ueFVRR;h z9&Wa{SvX-Svc9<4QiEIC?0JKGzS&BHTiI-NvzYtpX6p@peY1@oeq*x_4gSMspT_ve zT2Nt76*D>hoRp+&^b$Sb3gf3}ubUcg!Nx~;d&P?tuGuC?@U={m9IGVmi;*4|Epk#R zL|$5yW|=dl?NOEqZc{<<%>=~o{fy`N&8X)I)1yG%!UR~y$(Sw~vaT0W)hsgWk(VTn zhOkw*%vmLV=9KtzcHTEOp4XV}T@|Y;;!ZsBsI=cEokFA(s0c?*Q)!vH(z0!swjJ~B z<|$01@coSE`HRFZCVOET)TQJQuH?`iN%nHc*ViFyF{v}uX)LqRsiWlLc%NZL4{8oH zpf%f=VepY2VhTShyS|ZD|G8+*%Nt$BT@19ro6B!E(1P-f2Ku6WyMeZsPj4K@y07tL zC@98y7vC;dXo@oz&S*N{m)5J*x(jdEUAdOFR6Im z;GeHp;o(DR>GrUc!Mz)N$@}1~EjUL0`JeY;+PYWMyv=);C0N*z{84{kT**i5$y}=0$DMUtF2t4F{;28@8T?qcdIjzF2?S z-00Ira27Ustch8mLgVsD1}X^-r;x;-M|)%kY9=-}+G+}BVUu-6%`Y{5%_#S^rf)X& zRO&@f^y6gWbu&nJT@%l5yPa6Z9tGJjeU3-MK8K9yk|F!?LaG{bAsbzuz^2b}`SmNT zgQJI?rn5MSl)V^tOT#5)@0P(in@4a4hqpGmo6bXx7SmZ%{tgc$eOdl3oi&Z$<$;oC zo2=0TC62EFJoXo3Rx%frmdq6*e}$NYLQF*=CZrJ4GB_ls5K|P0OSU!-W?tsJN}z{L zJV_*@eId5yOz&OTNMV4-<>o_9l?hOhaOT6w%*}2an-ch5l>i2-PvCo%K(!Tp;>zL| zkZx+D=~Va=ZQ8r|F|)n7&M zLX^>*M*q+{pb5=$BJ9DIacSu_rED1@gck;dFo+t!FIwngwSXZvwRC!^Zh+btO|^C9 zoL^OUZJylVWKsBNEL%t!#4p3t4Z`PakW~IuF8vot8@nueMlZ66Fld??o0=0g-9?v| zEq+(9!TOE!O3kx7)-Sjm{I|CGyGkD@Rp`6&sXA1M1|eg;Xr*6{DRF6rgNWlAgw$Ic z&eM^Ja1`siRy`61`dnkP#FxupZsQ}gYo(SPNfsos;O--_z26hl=v!_0YVym;ljo;S@wqMc;6^nUzX+K-@%?$l@}FjmnJG86BUq)y5|@)!BlQflOFVqPLVei@-Vop zkcUBDYsX+=0NKx@$-{7&BbT7T@_ddOu<^nG$AIU;Hhm=b6g7Yth2h*c({S!G7KUTd z-^NFHS$QHwaLmJircnV+9tJe1rw4d?10UZ4(*i8^H?pz9;Jr{Y_g;8)i5l56VEAt? zIT!DKGShRTn+)_x^tFM$j;5J4U((){eF$s8q}`sqMHLjjnp41<+9gee7=znu_W8k&s{Cy`ab{qf& z5tLtBxHP#qe($pCEtBvS<+i-ibzaHz63?&A)1%EG1tB7kAKFLK_auRG4>oe*NTo{! zV#j!4I_&_&jQ$y9He#3e&V zA}Q%7x+9xf82kohhNf|8W)2P_5!w)b$X)|YqC|?TezY?1#9TY)aSgKI<#A#&@Ka@j z935+bsYAi%8B9}DbFmsM0yA5ZK#vyF6xCC$1|O-_+|rm>sOEVXl$^!He0-!<^DC1A zqKNV^$i(rTL}@`zriaXxK?H)p)^HL53cEI$lfhO-%yceiqd6p^79tV-KMbWeR;P2n zPDJMbj_8F*mDT=@mY=U69&_Q&^g+K3XU@QJr{8WZm!0XYm|+qBZTUrwHRPhk>l(`r z^{>qi_|J-NPROxnE}f}{Jm00K@l@Ew;T#?SdjnTMLGum|O%1@2sc9ubbW=1h zN)3=vC;H&q5ks(SK_?jb z$}A7q9nTqDfTRAb0+DY4{?dt15>8l-R=hG?k3ed zsB*e;41=?i3@0o?ar9)B{K-!Jqx~te z!a!t2CPy)sz2gv>lg1%<)^)zJBp@?Z6sQ-Dl9^w2ZyB6>C0$xAHT|Mqa-)cLOKrErnIq!K+&7B&CO4~;h*_n#mkP!0rT3OH=Dnr!$`~-O?CvrN zxVvnzAQqQ>C5ReCh}Js^R%KFu3Rh*`!9D5+Cx>@OpW(m^fX|{!vIw{&`z+2|!2fLa zZTjENeyjeOxz}^>ugiT$=Q}w=1G3XgXO^b^HRn*6=gXj(rS7AG?_Qq6+N$v&tidr6|!d$;U8>S)7Md8p}0mfMB9jcTr z3^Ju-{+{d5G1sBfoG?>@?#+5iO6`)>Q9iK?&#)b%dD_rOlMJ)55HYvFM=PPU`K7KP zTc)bQt(ZNfs(63H7H|-bvO2w6R?bSL+&<%x-ECRqHfRKWl(qJUR2b|+*=-- zFLU1;g70%bD8Uby9lCUC$b>~FGK0RBIgv`uOu)|^h@Zj>K)De>p-U&b0;A}_Qf?1R z>4Bx_9+nvpR+JsV6x<7@_zbopitEWam1DSwH$cRLZz>XiL&k8v1OqdIqa%t-YbRBA zp-Rm_?vp~SqQbNOSdOOt_?XOCj1s6&c_cnYNKj)Pi6FGwPh`2k^ z6}1v(TAUV(R0vq8O7KJOa#J0d&gG?#lnTBedy0s*yViBNX>-; zzwuhvIl1YkAxzI*qz&Ps+-!rIox4m?8*=X()cd*3irSpp8n>tVNQJsVk)#S!8u%%S z_$dYa6v3;~6a-jG;bAEYuoT3@Qk=Z%@9E@y8nlw=07(?SbHEkO2E;?Hw+29gHYcdk zc2rH)w26ynf}i$grj7G=HrV#99tH$BaF<8mV?bag!Imft3KNM-C>n1})-c!udfcO0 zN?>itR@{_;?Rb`!$miMb1aR@ZXw}Gq&<_xL_(*NE=+O!LgQQe2QMJh)1Va9z$xe<| zNV!#SQ+zp#?=2i_^m5lj1}sY-1_?e+asx!0TzdN;y?xHrs<<6i5;tQWFL{*;m>FHl znt5q7TdkJa(KYm66J4wRRak1vuV*pib6L;G5sok%0EX9MVuTAi?{I#U#^FoJd>rR5 z5@kDQQ!|mO(5_KhOenQzgM8utB89dcX;Jokp;tv~R7h6qf&{z3r0nt+T1|=gyhQXy zMB|AzZ05%$9JBBwuQOr1AyHUZABds0J^YM@ny8cRDy#+5JvX~BO9PG(!yhMe%%UMO zn>3NU7fULbmQjsmVJux~qh~2{Z1i|@rl%C5 z;;5N3Z-2q6aA$Onl)VH7UTCAt$(Wfp`b8GDMbsNZ(VfwP$a<7IL5^e^{laE}T&?WV zR%=Mrn80yp?Wq=$*O)3LjM}=q?gzpfqJM~;%$E)_xsy#;;Ks__=s%l$N#CD))OsC- z^y<>K$lY?lf%&u}3Fl@uc*gAy8QgNB-HcmK4}~$+^WkRC_eRMUW0=4oHZmlgXzr1U zz(fyO>HTC1bEPL!cc)>%51JF+onDd#VoCZ;n*KnX8BIf8!)ehC5%4!e>kNJ!yQ4pa z??e}7g)o_l@g)))D2WZQi4A08pQO=SeUhG$k?BJ?Bl8`N%W~dzmfVbrHJoRo0z{%=`GYQD7K_OVJ|JI2!g42+0nds0``K6 zg*{5*n$$fkt9y_`a09}y0ko`Sc?p7+Q)UJUpXep0n-v*R#e#5+D5o%3^UQF~vkGFw ziTV5t!vCyF^HPPy#{pP;#C>?l%FC%0EIaZ*jtZjg4Ec6m!E%PYl29z@yH3zY^uAnp zZTPe&N#qkqP8d$WmopFcB6Y#|+vT_ANDz|lv{RdQ=!Aazdmw**MhY|3Gg9}b8X>Sc zFk$!O5w#@sqp9af`F!e;OoH;-@Os<^#Ge~N1mA!=u8H6~!h49n2h#fZgro^M2S83$ z=Wp+)dMSzeA4SqYFymCORLZE=(aI_e25Je8`z)=%>dg1%>R}K2=w~AwcP5o`X6mza0=+u(c2Y}kXEtR(xCu%5ghg_J96~VsrC4z_`i0Bq zFGc8~8&vqESSpEy4BYF&8)~2!>`D^ibd1#)y%3)S#|JtTNPJj-pGL48xX%pEMI=W zi7Zqh3%<6)p<_`7V>cwrisB@wRzLvItwMr6-jo&6xY3oxAEYcsY{zX!bhsPSo3&6r zPoHZF#ndK0ik1fAD8NVxF_u?AenpH^EQN+je-3^8{0~L65ssKi&Cg72FIq56t5~eh z(_it{_*W31NHA4gn2)AVQPV&83JQ^@grCVJ5X_;EaD^8=FaFuA4f}h(L+l^ha)r6l8eBM3nNx%|+`5Wh@p)gz7Is6$#d~ z+y7Ce34>F$^nSpz-Emcpyl^QM279IAg?EHfJDys1?(y!y^oA(OOM)xQnO&fWT}~~M zAz@quuNnQYkIiULPMjW(p5_FqAS|4KjRpx7NW;H!aog&S*8R~!ESh1@4tuuPwcW3; z^2P@8!Es=#hn3^fR64Z6w_`9YmlG2aE6EVd8r)wM7NqlKLW5 z0%pk573r&0(yQ?*M#;&iGN0F_Z_#YrpZ=!=B2BX+7N^rJn%iUzCPv}GM_TB*^sQ+N z-=AJ+VcQ|%;JK6Xf>bnj+Z&Aj9%Qlb73n(>N%6`+V3W=07*pzDumGF8dr0)}GUt_8 z_@a_I7IvB;;6=QhivEsQiU)*Ohl}XE!dE#4U|#eM9r7@igct3XtifAB;c9R!%P*x) zNvPH?6xmE8X%=g!w#bqq&2xEafo9xd&kP8|d6|bY@I91yG$a1!GF#|>EPR~X!jIzv zYJz?`e3t%a@oEMAv3_Hwy|5KO4{YEFlViZ-Mch_5<><>2#j$?8C|XUR@|bCjqS&>U zSQszXj~B(V_n6iwiYLN7u3&a6Ihl|7gg0j%%ouP5 zWzWobJeglTL7WMH%c9Jp12CyLZL(k{pOLaC6lHFW5ujBxcfvYZc}V3xHn9rMN2BL8+K3kjY*e_3*aO2#93PkI z**_XR#CszTHF^>EfxeoEhYWBBiXjp=I(C1XCNG)1ntKx~{zk95R6al z!AAHie9DP2;mqNq4N^STZ0>uYM&%o-hli(aPL*Ao+pfR%;bsWy`@e}!=hcGqvNPeh zBnd<@AAI%g=x}=a9(JPg9f8e6~ACAeL7EB8E;8N`|!y(VTILXC;t*LFP+!!0Q4L$@WlOR{G9F8r^{P|W* z5my#b5T0KO+o$EwM;g}dd_JxmWnA%M@xy2DMqlDU8IsAhGTJJS<}P@f6#@yO81%Il+c)1JiDk6lzL>NP%Ubi)~7fp6{4Nv>Va?;%S-5 z7vs4RGwJauqPguTYIxekFi!-eKN1b zIhWK2?d-PjZY&H*R78#m4ugQ#hqv-G2|_YZx%&k8kRz9k>$X;|qJf9KbdL$ILOx8nMqWtVPD$XJCUT4KK6rG{;s2}c zJK&=#w*T+$p1Yg6>5T*k(pw}!5bP+Zs33&MQ}nrpBtSGIc}ZxmDAKz$X(FH?s34%C zpr8VRqM{;T1rY@l=}i<1{J&@B&g|V~SAD+UfBBG^IdjgLGiT0}JJsS4921TMFCm2H z5F8VZ1D3p;HV%AJQV0Q;Gw6)iVC689?^gb&*iIgC&y^g9pC2Z}hFhWY#m2qB=_3c6 zGp=7;qVr>{02I#gA+E${c_4wEeA7}5eeLIwGDB#egaL2S%aL5XY$f$N^Gl3rZU zg{qP_-YZ8jUtN;oMZk; z@4BCfLJHk+lo5wG1ZaKK8Xh14v?gXRU-q;YTX!Yk$Cwc~Ck?U@vD0EDXj<$l30f69 ziX{TsDDQZ_CPj$cU5Jd3C2)6Z*wy43mCfbisOygCAK3Ma9X>VijHHhVuE1r)d%_;|b_ePG1V#ApqwUDp3 zUlg^Jowc}Y3MA{J-eKq6sE^p$j-yj>c0_*>Z4vK^{ziHCMSrKf2cwT$UY#3%N1;JB zk2_5(<2jL==NzjzH>(_v!uDu`Ym$l3S#y}%aVHIPuW}>wjprO^>Wj#ek#J5%J}h!E zHfpwTXGcBGqRxw2!j9Mr*^6F^S{DU&Z%4hyz>lK7;Lt9<*1s3+i#o#28_}DrQi#}V z$%H8ri0TizDn$j@P^^~}9j}#Ih?i;TprAk% zQ2t`Lq!^DS=_xz>)3pCei%#$klVbeY4K2!KG=(V~fKhE<`SpFWq>GK|%;eL)crN8Qa zhr9fc$ZUv=%`T&}%lL3D-pY_{a*StFIfSWS7{>)HXCfq0%m<4(Y$}hr7qPR+y#-F_ zgk3!_0A?!T;iQF!(`JwLsja?LJ^gg!s8r)LHC04BdiUWi9%sB z5ucP1&nY4smV&YQNvwu@bFI$Z0wTCOQu2GVb}hGh!GWm#LY zgl9|E_AF3r&)S_O)83u6U&iduI))hZt{9Hgy-~@@N1Y(iPWKn`Y~Mxku4;^#Ihs9I z)%raxxF6HJPm-$um1TI`BXPoWD(PI3@cf)~UV1Jh4Nn%35y|7FXF~Ec3z9NEMMOryZr0u`0fp&^FC zG6G;qDwgcO`?-^Ek_2QdkrT~J9FtvU^-!K@p6vRYh~PKbZQn@}qx>XknQWjP!F(Q~%uEw2`H_y1}qgt~OC?;F*;? zALS{$%TixV2DT5nP$MUTJ{16+{P#pCVL0_oADn z7pLa~<$5}41q@cmwK8dSl9tOxp{05{X^qk#xJ7(z@r+fHC;;w^z~#gcO#`H8Drkuo zQKzdEDn>9sqoDvEd~F2;dt$tzV-@+MmL}?3&5#b;nvUmGNumEhGxWRmzDAebJ+59T zvU{u*v|)}(4r@_ul0&y0M;rp_W#=ZjM77De(m7e)fzd&A;vLb~&s>Fg^_gXDndr^Sx_dA5UpLdb7rM>9<$SFMAaqph+e37t6 zdcI27Cq4TU4olCGgwxV9H))wDb9y3WnXrr?71`4L9#c(S&vFfW(fK8oxTOE2cPJWk z>EE7k1`BV}KQZY!*oyQ&k+K@KO8VbP*`fSwLnlB7SnmEh z*&KXV9ZL8)0nYKHpOf(65(1^0MCm3`p_ zXBi@6r9%uNRysySnp4&cf)z}Sd_2nXj*gxlZFv_){}5|=XL?7+DJZUfv%H_h9Z=qJ z@o&dVs4Y$DwWT~NQj8@yIpN{Ngol$79!^L?kc{wfBErK-u*XuHJsn#T|DQ7#{ON@$$IM|>Iq@cS_z z$G|xldps7-iC9=D$DTpch43?R%lU5Ufpj=-7T?i4koy{K3ho8z=eTwU!lDK2ViDa7 zZ;?PeoQo`(XE7!B*+3fYc^2nK;Q2LTEY79DGb{2C)-K_h9`hP*$b;wom|raq9ugFg z3$g2XX3*A+3*PP(I*nbD{RuuW#XKfNelEF=5w`;ZvLWV#rMOSKk0l-*6jpd7DuBF6Z~W=jnp;9Pi6H=fc7GyJ?}hf~N{rm{=6Kn^;bS z_C_6u0?L7?qdY-%l;4HyMq^?o#2{{B%#;{lPK|ktokcNEv-3>MN_IZSRhMwSjXBQF zaPMT?8c0*TkFzt+`xHBiy({1ZwJRY7{~qgYD054QF)82(r> zQbi$C5$Y*`UJ7#b=VQri1Zdt>1~rE3S;?bVzex@j?H1*La$^t))nrT=`)a5Ul4zdrV;^4pqZ zcjw!rqR4m!GZ5RbQQ{Mx92CACo;CPvW!UM6nYciSeJdhAk-m^-V`GQs3{X3L+xURO zHs>o?`bO{*yy}ARE+iqsoPzM2ju?ky-!u+(Bf={p-;ka+kRB#W!r7=TLG0b>C4`5= zeBqqt)6Bi-Cmb$^Gc0l}JLC99yd4pGc_Z>YcD6=-3@2owwgi2! zIN!Uxpgi39D7VUwI+5GEr3~F6!`HkvE@Ze{%5b+#;BJ|~-L`U&g<$_{OK2=JAIoWU zlWAbjhq;HFU!Jdw#v@5`h7$9WJ3RY& zSCv=fzPl7o)POaXam0zm(Fh%MFSzDcE)mos1>*{VJAz>Cr!As*u?Xo8+K3bih=xj{ zd%MWIXUddxP!WM|k%fZ$xYi3I3?qhEFfw4V|uuhMVK8d!VFT{=c?z`Piy4U%RH^dLphJ({No##FUkT+z~6W!N^{d zHeFPcW=1Z-iC=~5uUE)wm)m7}&19RRgQ|G|N}+{<+h66PLBu8tf`$;({-7d4VJQ^O zq-=lXErwKd@tffuX)~-#2(?C7( z=e&vW*?Ds=UO$oe*53enZ0>rKPnWzY>2bVB(EC6?+Kn!7v>Wt38+`zEcWNmP3t^#B z;CBc9Yz&Q_evoE^P)soM>T$~+7Ke)=V2+);K?rt;OdZN{cec2YQ5P8;j(>1oHrFD% z%svQ3Y?Edr;bAmuzqFH=3;JnZDPXeSwVxlAdBmJ4c>%+4|3{vwi9&XMbB;znL=2L!$N3QV6rU`4ANzAf zNSv>Rsa;7=dFidw3-N z6;3cAD6nkU*TB$lEe-6AYetsEMc;7iXN!@W#Y*(}HWqli2r*wV3sHoM2^saF;7zVA zQn8$}`&un#7f}&j#I{x8Ip8{KKlUV$Z`R0Hg3*;XIRA4UJ?mP|#kQN%yF+H`Ki5f# z{OH+;l890we@vP`1`WASB_MZo{M!n~;nE!Ob1Mkn4SWZA;vj)c%O4T#uEfb?+=3I$ ztK;ZCR1^;fxcd*uguk*wMhFcm7Gwl+hb5>eIoMz+<@Gl3;Eo)Wk&DkX4|k4oiaZ5G zH$*`VcaFyu;7o^urfl!{5iWm5zu@=|YrFyw5YrPe2l42Yt+x_L0e{@BBv0^ahxFU= zfl6%b^-bol^2v_3`NSV@^mPn{Tr?C%5G3Gr=X(rz&pE;BFDB3euUxAbly$j1%pyWeX$XB4`1K@R>a|Ol;=W^>f?{e2# z7XWKrLSSG_z;FhDX;NSS7SU1$ER_NSu$6W&Ur9?2zD45l#j4`iXT9qb0M&Zl-gVG%ub1cVzP2GRDh7kf4;~+LL&3|BJ&7|oMT@Na*UA3HqQO=WpS3Z z1k0zx?nkse~AaYV5av}g> zBn*%ZXXIHnR7jTX4ka7HUpbC2;D|$r0)Qn7e49l>PFtW(NqbZt{5S#C2!NHcd!8=3 z_R!p2xVZ3M*bMsOKh&R}@)8uzCGAmAcTMF&pX%7gg}%)(jEi}gb3GUOdgrGc`qYUO z*eY@17zSW2oGH$y*SOQ`NqbxeICQ}EEr-5kOUQ>MK$br;K+cRUCzrq+E@>Zlfcmb! z0QQA^e;4uvMs5>NkE7`vCQeM&sKc);dm!d|=lg*u?;}HjD4e%Ih{$GlWb<|2`~5m{ z8yLTbbNqLaV?Lj$ljpn#V1_Xl1rAU_0aPGtOq5E2$h8cMf+-LMBLSQ#m^5ca0yqoO zCqyq0B_si&kP1X0Nq{J)0#Qx^U?Q5)6+FsVVW@ubNCuJYjw%SO>21>gPw7{Q=t z*r1-_&aNlUb)DzXc?WpmZARxvHj|OA32Y`4ToXAo(KVez(_Kg>ywTWF;`v8!dnmvC z0|A<*L8IAJMmwGnhiY|^uqc6u-{H7*K&hR9e1Rw|Y9M4Ji~DyWZU8L{9)PKeHpsQ* zpgl^i{R6TrSX~7|T{6tF0l*ST081i$LT?2^ZxSF>hs~OhKmdYL^atJEzsUgKzJ!W@ z1@wMjV8usq<)gS3b2)wB+{4bd&SUHxbN;~1zz@!|96Ia#jYGdVC)tb3mcSJ-n)|@! zUdiTOumNf~3qm7cmko`;70KwsQKj%#oFTRj65pp91D~iCp^>&Z_VMik`;d*$2%NLf zF`U`ZF(Uunk^l2f@IH^+gv9e}JIEK1!M`Je0oFqIRl=$&rv@4%x5t5K+wekgfZctG zOa`KG<^my{sX)jvE=4?>h*AvT#^o7+8Jvl7Z9#b`{=8zCLM7^3KI+?BT+@$nP47uF zoR714JdQJ*w%Y9WQy0T9DnW6tq_`IpK)u*JY$QCD=*ffb^NK@io+_<7CEjv`j%V3I z$INif<3gPW8A2iiX#v*i&q+M=7@rrQ#k}GG9a80g0;2!(R#2g`V1X2@zW^H6WB`g5 z$^D=%5*`QKhs!@u*&N5%8O8YuR;rCav;y4y-!}-QH3+1r?o5hTahwym1Sc|wQ0;L5 z7w)th*eYv?svA&$2Vv}k)cza^3-sqOh0Ivga!zt4*`(1oVoXA2{uC#zT=#sU?rJ>Byx}f|7g1_Kw zD54(m2YOnUKcx)8>Q7->YO|%4gnT7+37IRwHe`&E3r41xuz^Q>v$;QSC7EO1%{iq8 z@7hF8shLhu*A1;VpCY^f8B<&OiA?`}1Ngo@gKIYFg87J>UUPrsHf)jE)ZkKFHxLN) zPz>NrEV#N|00|Qxr!&lJTPsnBJkbYIr-**03s{f7|1v*XbTlPq z7^XVBk7*9_)}^j}XoYjNlQucuaT?}Y8-7HDVcwvVad9%I9kZPD3zh=tF>@jA7rswN zFLBUNnoKl{))9R~pA&scXNks}j|HGzi)(?;LazCmuqSPBL2z;3&k~$M#CPOwAox#f zccxXYO)hb0TpSs<$F&l1rvG4b1F9Yl?d;R+Jro^nm>!+2Mwqeu)Mc3d^TJ)l$zQ{? zpVAd)bPaRkQ}~R6^TzE8s-Si0i_BivA9ACEM_=nLwEi&i7tw5hyl)OkU2j1-Izt1 zVGIqK=fE9bF9F|w($q!nF4Qd_XF%7WY+ukv)?8#pQTbEAwH-ner@su-c8&{>#~e6E zv%!HItZ?STqvEhkr_O2_v6Ru)FcYp;`uE@j!!RehkeN<;*oAQ`Pj=IGd?eE5*mq+M zv-lc?N|cmN4^&dkVEXq%$ng^p=ph~JrL&xkRv zRs34eMqG1im=V`02vG!TAHI)v;F3)`VUBUrWcMsLJ?(zOO-)<~24@Rx_%25EC^cP*po=IMGhWXAa!k_LT#}&BG8yop<2&!UeYeu&BmK^)Q7q z3nh`?!7m`HcWOPu^dAN>u$H<9wfBNT zli?k$q-CkqZuID&to?{sl zqxQA4;Dm;ur%o=KYW_u|9OE3gqjxbd$LSc85>ly7OT$zf*99?(_g9TF+d)rb%88!z zF2~`y4^Nb;Fv?5|v$LfcaJr_#{0F==*!bV~0i5gErG6BHU>NiK5uEj#f;x){ol=5yO-t`HcslAkJ`LHYa`y%M!c1ecn{x2xbq_E32c$0SFlk+ zQEl-OZ;AVTQY(dUxc-fDF%+Lpnf0mpb#wzRZ66+eGL~j|H+gBNcX%Alk6RW;JLA5N zqfzm1LcGv)rBsRAopA5`H0Lpk#bcU1pT>%$?8bCsPs3C@g0P4|5i!)fJ09R%9!<~2zJO-A zncjYb8VaLJrn>LC=mXbhF8aZo;>PXOpYoR1mm}$e$RAL2RT|$z4V%)9cNpe_8WcnI z@@N2ekNA>6rPdMLW`6EK^SzIAa~!!*n<-dsSCl>M;%+vzK0W7o0d465y?H`*zm4V2 zh>6%hf%n^&^eVb@_7%`oR7QU5~rZPe`^birS^ z=oFTy4b!%KOSg0p>$irvO*4wbqdTKrG~cxdgSB@wn5an$YB!K3xfZ*yZZwy$-mnYY z>=-?I$Y>dJ(ncHKfEqWa?_9^hGpj(!Tp!Dp?*L+3t|VTn#3bcWfc@)<9kI^1!iD9? z{Q=-?0k$KiSrD~;C#nKU9<}p~PBw~S8&OUkO?J+LWwy}Ea~LXQ(?JJLVwsbzPbV@K zxiHe5fQYvfN!XjAg6tiJsF3d11 z?NnfRgl~VH?py|$Y~S?Md!d6CJDzihFLUupZEX$R_fD;^bC2bujB+Sa2+&H3`z zMUHJw+QFUF8C)MLZ++!^V-52&UTMdV3^YtD94|UB>HnUKmSKh6F#UI?VnDgkftywN z?oh+D-x)d>*M;(zgJE{y%{qeB4b=Bl2i|V_#);*NBZzuhNA;jVzc}b?tRG={Yb2uV z7Z>)~gXH`7 zKjOjbE_*!0PrBeimm?A46_+6Nx_FiI3ydTDx7L5{paVGDL7(Gw0C7z}@g@D@ihes9 zHWy3qp#bUtu)1uXj0dQq8s~RUnc}W`aZ^3M0`*n!_382}P}VwJi*j-ys1Cy(M>%Ms zV~PW}y5lLpcQGi$7MsOx++}vs#^gNE zJgPLdn!FE#pFYEn=|LZR8+E_e@GP~UrnyPS!!R-Q$}&9L3MI+<6pwnhZUXA&uHK5% z_f9(I{mo0m;>N|%y11=zG$VdNJZ+BuG@eE$E={Dj6OSj-*rZ1>R`OHDP|RN@yi}xM zm{CPahE%GZP4nWPMyr^uf#_55xcD>PHC}qnyV*-W@-S*>{Fr#!hyztLEb&~W3gJ+MJ#(y3+8V=+$wGF(I2i>L0zJNI^QPH1ql0OONi(~oyz-Vw#V z71vjYm+Iw%?Be}+@pQa+HJ;z67q8RXNm~n4!?ZoOF5XfXPp#X*$&{WYV$g$>D8(g< zC(;e`P7N_BvL3CEc^CQfzh$0DbsFNC^CkFToUSo3Dg@8g)bdPpkDUU$`;#$E1x*k-x*RYvO!fRW zr%p)S_K3E4KpUgIK1!Yj;?Zo36f~rm?ynMWWrqQ}`YKuvr94FMMI1msRbK;B#52qo zaA`;?Wn_zYferHx4TOR->73_b(E4BAy+%Iu%dh$0^C?&+YxJ95cM1@TM-7go;%BAqA?!zz-mLoGsXf& z=&mTj@JzOVuU+GrU@3Dg%yOp%CL@Z{QGc4zH?Ff7ryVX=x%u2l-(ew%p&*~iUj`K7Bbr4g;Bv=3*TyOwpT!nF9^V;d$+AI??2u*{6UE_+SH#Mw z*ng;^GbtvX(r%^0Eq?&_Ab8V`7W__)|D=naYqGfsz1;k*=JagK)h+3_oN>rdp~ir2 z(F7FhFa{x5C>UvFbj~UK~Pa$%DH{IWqK5PCZ<|6*BBk_rVMjB6jiyyZJ zdoe9;m~UxFHcf9a7tLay8in(t1D{oxpP%K#_vo9=e{4?Ub7tn4sx=_v4w{RPe;i(! zjW*Fw=c7L5z-IwM0(a^Z(2$RH(6f%`9dx|eSm4{E8p3qi4p72G5nH7{Z81xp7$Ct} zjr@aye#O>Sd<2hk(j4a#n9gjnv?+~lKCQXAuCZcy2fap{iMG>MXk-1vf2ZOy;7@8A z2H1O`Vj#tzlg^_0)?QcX2 znk;K#PHw6YZlS_b`p1KY>8BA=KilZ-Mqz+QHFqiXbO+wx+tu)=hK6a6VySN*tkRKE z`_q+D>(u9K#3$S|CF9!+dZpG^wdl3XJ()D3_Vn5`xAsT1=}7INb?D9PPqS%Ty^rhB z>3YA^qqiFDZ$NVzEpKEiQG;fC-uK|XHJmyc8OeQ(pMM{!`i~$A1B@A>L^i4Z9Fv|j zpD}4s`nh!4nsF+Fw$(aWi)Lmm$)Xjw&xkH$O{-0x)IC&}_GKT;rcw1K)uUG$ZfF=v zm_r^2vjoD}lW23TVNTLXrc>=N$=O)UYAbP{i!Z3Y_K$#`!ZC{m6~Td-Cse~DEs+5RkS8^eI}+T|EaW>K@D5b z>$TphWtdwuNgk$|F+a4^xy413(_c=f=@~C&(D2MzNH}wQCM~JEtZpFwbJ&||Lk)>l zm;M}s_W>h^y84~)@BMF zqT-untPbCVmhW}6!Jq2P+(cs&$0pLTjPsB%G}v?8!j3c({;fF60dgH%cw@pwEVYc( z5D(ANV}-QoNDR!J8>8s`sDn|oD{faj%}U&nNIxYlO{Uk9$EMKilzAyMCv{OO&Bbk4 zQ0@A3I+=bbgU)9isZCGUSyji=s)s?r_2#qI+yt1xAPnDrc?6qQ=et(sUQr({J=q0)ZE{X8vdZt$^iN@`e-!0 z5kD${<|ZyqL}PLcw%|u-5`=(0Q4{0SG5)uBnwI!D#wcgB4%*U&T02mq(;iZ(#86Ue zy5eT~D(QQ4s(!f1%Mq6#s)H4Eizbn^=X&aN8@-(LI;iYXvI0r?FipZ^HcA#V=#RyG z5<|blF30d{p{_n{=nDrg`E1h^JDsvnKk)AG($>U7i8M;gZ}~AWzZDK?!B^oeOTdLN^kJu{@C~_DC5vzj{--UT{WHlUc1i*n(Us8iBCTS z-E0zNwWF&$V%~JNo0i~KNP6GB(@nd)2fXx6+!0JM{Gb`U>7cO@-$l@>=#QdlPxQWM zniI1u1~v3(98HOz0Re9vrsVz`z33T>Yb0?+1C5EE7)>MNX2#Llxb@)Z$BOhL7-oSc z?n=*khDOk@-br!vLfmSQoYy7NleXhZcEenwvA=Q9Po8lRvQ(!4@b8x(_*yVVvxfKPD4 z?4}{N;1-JIF}OH)V~pYHZ-Gs7j7HFfG)IGOq5aXvqA`>9GTPzLV9#pJ>SIlZ>7O{m zGj_bpTZ}oxYX8W<)`dqM^BvfuHWP-tRKsth5BSx(FC7QazOU5a4)hMT>Ck6l=p6>! zSda4Z>2HOG=TV((S3Pnq$LiO57rl#6T_W+|#G zXcc{meP^D>Jh(CVbC{byt~KJe1;qVJ)43=moo4fb;sX4`nWp6!wolX1S=6dEjiK>G zGw7xNCgw?j{*Gp(c0wJXAHXJcwvrn=p%O4fgc*r_j&Grd#y^9@B1+`x;8pIywya-fhgu?S{Jne>(&9lCe-q> z&~S;oRdc{Vahr3Mo2GlvO&`Gn;#h^-6{+P#tv;u5U6hoCuS+Q7DXeDFa_2fsFne~w zB2p$Pi88S+dDx`mJo&c9vym6=4tQu(-IbWRd)UO~5?_L0zef~9 zxpiQe4!5OSZlU+YdS*yqANUO9l1@OHE4bX zEbA@=u>Ew!84pfj!{_fquoWr@C(D8i(tMBy2#HCw2^xe!vX|2FeKOa%&`E2YIM?!- z>uaPnO`~`yIgM)7p=Q_c65vPJuz)7yQ6*a*l(E1;PdT2&BCTT&D(dgVc~qQfcGMhH z&*AAmLo$u97r>5|DkV_>_&^x$7(sYg3CBstn2(yY)O;K2F3nMB5yaIu730sxp~RUQ z?xmzQbk(gmJ9rKmctXQb2jeIyjp{U~yesIC*a~r0$70v+RWV8S7dMwydsVWRz!trM90<&w2|X#j~K5 zoV*Ym7YTp^F%w)eCfh<_{-N;e0PZy64VAxtVQP$jEI7mOYb%0AiCelKSa9`tKo^gM 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 /* constants */ constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; constexpr ull MDL = 1e9 + 7; constexpr ull PRIME = 998'244'353; -constexpr ll MDL1 = 825; +constexpr ll MDL1 = 8784491; constexpr ll MDL2 = PRIME; /* random */ @@ -138,6 +139,8 @@ template ostream& operator<<(ostream& out, vector vec) { #define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) /* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + void __exgcd(ll a, ll b, ll& x, ll& y) { if (b == 0) { x = 1, y = 0; @@ -204,49 +207,41 @@ int period(string s) { // find the length of shortest recurring period } ///////////////////////////////////////////////////////// + // #define SINGLE_TEST_CASE // #define DUMP_TEST_CASE 512 void dump() {} +void prep() {} + void solve() { read(int, n); - read(ll, k); - vector raw(n); - for (int i = 0; i < n; ++i) { - cin >> raw[i].first; - } - for (int i = 0; i < n; ++i) { - cin >> raw[i].second; - } - vector bucket(n + 1); - for (int i = 0; i < n; ++i) { - bucket[abs(raw[i].second)] += raw[i].first; - } - int r = 1; - for (int i = 0; i <= n; ++i) { - // debug(bucket[i]); - if (bucket[i] != 0) { - cout << "NO\n"; - return; - } - ll curr = k; - while (r <= n) { - if (bucket[r] > curr) { - bucket[r] -= curr; + readvec(int, a, n); + ll sum = accumulate(a.begin(), a.end(), ll(0)); + if (sum % 3 == 0) { + cout << "0\n"; + } else if (sum % 3 == 1) { + int f = 0; + for (int i = 0; i < n; ++i) { + if (a[i] % 3 == 1) { + f = 1; break; - } else { - curr -= bucket[r]; - bucket[r] = 0; - r += 1; } } + if (f == 1) { + cout << "1\n"; + } else { + cout << "2\n"; + } + } else { + cout << "1\n"; } - cout << "YES\n"; } int main() { untie, cout.tie(NULL); + prep(); #ifdef SINGLE_TEST_CASE solve(); #else diff --git a/src/bin/c.cc b/src/bin/c.cc index 24c44f0..f65fa75 100644 --- a/src/bin/c.cc +++ b/src/bin/c.cc @@ -30,6 +30,7 @@ using pll = pair; /* constants */ constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; constexpr ull MDL = 1e9 + 7; constexpr ull PRIME = 998'244'353; constexpr ll MDL1 = 8784491; @@ -212,26 +213,50 @@ int period(string s) { // find the length of shortest recurring period void dump() {} -void solve() { - read(int, n, q); - readvec(int, a, n); - vector cnt1(n + 1), ps(n + 1); - for (int i = 1; i <= n; ++i) { - cnt1[i] = cnt1[i - 1] + (a[i - 1] == 1); - ps[i] = ps[i - 1] + a[i - 1]; - } - while (q--) { - read(int, l, r); - if (l != r && ps[r] - ps[l - 1] - cnt1[r] + cnt1[l - 1] >= r - l + 1) { - cout << "YES\n"; - } else { - cout << "NO\n"; +void prep() {} + +set decompose_all(int x) { + int sq = sqrt(x); + set res; + for (int i = 1; i <= sq; ++i) { + if (x % i == 0) { + res.insert(i); + res.insert(x / i); } } + return res; +} + +void solve() { + read(int, a, b, l); + set factors = decompose_all(l); + int res = 0; + vector powa(21), powb(21); + powa[0] = powb[0] = 1; + for (int i = 1; i <= 20; ++i) { + if (powa[i-1] && powa[i-1] * a <= 1e6) + powa[i] = powa[i-1] * a; + if (powb[i-1] && powb[i-1] * b <= 1e6) + powb[i] = powb[i-1] * b; + } + for (auto&& f : factors) { + for (int i = 0; i <= 20; ++i) { + for (int j = 0; j <= 20; ++j) { + if (f * powa[i] * powb[j] == l) { + res += 1; + goto fi; + } + } + } + fi: + ;; + } + cout << res << endl; } int main() { untie, cout.tie(NULL); + prep(); #ifdef SINGLE_TEST_CASE solve(); #else diff --git a/src/bin/cf-1690e.cc b/src/bin/cf-1690e.cc new file mode 100644 index 0000000..18a8f77 --- /dev/null +++ b/src/bin/cf-1690e.cc @@ -0,0 +1,270 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n, k); + vector buckets(k); + ll sum = 0; + for (int i = 0; i < n; ++i) { + read(int, x); + buckets[x % k] += 1; + sum += x; + } + ll neg = 0; + int r = k - 1, l = 1; + while (l <= r) { + if (!buckets[r]) --r; + else { + if (!buckets[l] || l + r < k) ++l; + else { + if (l == r) { + neg += buckets[l] / 2 * ((2 * l) % k); + buckets[l] %= 2; + break; + } else { + int v = min(buckets[l], buckets[r]); + neg += v * ((l + r) % k); + buckets[l] -= v; + buckets[r] -= v; + } + } + } + } + for (int i = 0; i < k; ++i) { + neg += buckets[i] * i; + } + assert((sum - neg) % k == 0); + cout << (sum - neg) / k << endl; +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1701d.cc b/src/bin/cf-1701d.cc new file mode 100644 index 0000000..d2832b2 --- /dev/null +++ b/src/bin/cf-1701d.cc @@ -0,0 +1,263 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n); + vector> open(n + 1); + vector> close(n + 1); + for (int i = 1; i <= n; ++i) { + read(int, b); + int left = i / (b + 1) + 1, right = b == 0 ? n : i / b; + open[left].emplace_back(right, i); + close[right].emplace_back(right, i); + } + vector res(n); + set st; + for (int i = 1; i <= n; ++i) { + for (auto&& p : open[i]) st.insert(p); + while (st.size() && res[st.begin()->second - 1]) { + st.erase(st.begin()); + } + if (st.size()) { + res[st.begin()->second - 1] = i; + st.erase(st.begin()); + } + for (auto&& p : close[i]) if (st.count(p)) st.erase(p); + } + putvec(res); +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1733d2.cc b/src/bin/cf-1733d2.cc new file mode 100644 index 0000000..47aab2c --- /dev/null +++ b/src/bin/cf-1733d2.cc @@ -0,0 +1,272 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n); + read(ll, x, y); + read(string, a, b); + int cnt = 0; + for (int i = 0; i < n; ++i) { + if (a[i] != b[i]) cnt += 1; + } + if (cnt % 2) { + cout << -1 << endl; + return; + } + vector> edges; + for (int i = 0; i < n; ++i) { + if (a[i] == b[i]) continue; + for (int j = i + 1; j < n; ++i) { + if (a[j] == b[j]) continue; + if (x < y) { + edges.emplace_back(min((j - i) * x, y), i, j); + } else { + ll w = 2 * y; + if (j - i == 1) w = min(w, x); + edges.emplace_back(w, i, j); + } + } + } + sort(edges.begin(), edges.end()); + unordered_set cover; + for (auto [w, u, v] : edges) { + cover.insert(u), cover.insert(v); + if (cover.size() == cnt) { + } + } +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1738c.cc b/src/bin/cf-1738c.cc new file mode 100644 index 0000000..2020820 --- /dev/null +++ b/src/bin/cf-1738c.cc @@ -0,0 +1,256 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n); + int cnt = 0; + for (int i = 0; i < n; ++i) { + read(int, x); + cnt += x & 1; + } + int res = 0; + for (int i = 0; i <= cnt; ++i) { + if (i % 2 == 1) continue; + if (cnt >= 2 * i - 1 && n - cnt >= 2 * ((n + 1) / 2 - i) - 1) { + res = 1; + break; + } + } + if (res) { + cout << "Alice\n"; + } else { + cout << "Bob\n"; + } +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1742f.cc b/src/bin/cf-1742f.cc new file mode 100644 index 0000000..6ce42b1 --- /dev/null +++ b/src/bin/cf-1742f.cc @@ -0,0 +1,266 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, q); + map a_seq; + map> b_seq; + a_seq['a'] = b_seq['a'] = 1; + while (q--) { + read(int, d, k); + read(string, x); + if (d == 1) { + for (auto&& c : x) a_seq[c] += k;; + } else { + for (auto&& c : x) b_seq[c] += k;; + } + if (b_seq.size() > 1) { + cout << "YES\n"; + } else { + if (a_seq.size() > 1) { + cout << "NO\n"; + } else { + if (a_seq.begin()->second < b_seq.begin()->second) { + cout << "YES\n"; + } else { + cout << "NO\n"; + } + } + } + } +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1744e1.cc b/src/bin/cf-1744e1.cc new file mode 100644 index 0000000..cbeaf24 --- /dev/null +++ b/src/bin/cf-1744e1.cc @@ -0,0 +1,262 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +unordered_set decompose_all(ll x) { + unordered_set res; + ll sq = sqrt(x); + for (ll i = 1; i <= sq; ++i) { + if (x % i == 0) { + res.insert(i); + res.insert(x / i); + } + } + return res; +} + +void solve() { + read(ll, a, b, c, d); + auto factors = decompose_all(a * b); + for (auto&& s : factors) { + ll t = a * b / s; + if (1 + a / s <= c / s && 1 + b / t <= d / t) { + cout << c / s * s << ' ' << d / t * t << endl; + return; + } + } + cout << -1 << ' ' << -1 << endl; +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1744f.cc b/src/bin/cf-1744f.cc new file mode 100644 index 0000000..29bbe3e --- /dev/null +++ b/src/bin/cf-1744f.cc @@ -0,0 +1,254 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n); + vector pos(n); + for (int i = 0; i < n; ++i) { + read(int, x); + pos[x] = i; + } + ll res = 0; + int mn = n, mx = 0; + for (int i = 1; i <= (n + 1) / 2; ++i) { + mn = min(mn, pos[i-1]), mx = max(mx, pos[i-1]); + for (int l = i * 2 - 1; l < i * 2 + 1; ++l) { + if (mx - mn + 1 > l) continue; + int rl = max(0, mx - l + 1), rr = min(mn, n - l); + res += max(0, rr - rl + 1); + } + } + cout << res << endl; +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1791f.cc b/src/bin/cf-1791f.cc new file mode 100644 index 0000000..d50ef24 --- /dev/null +++ b/src/bin/cf-1791f.cc @@ -0,0 +1,318 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +template class segtree { +private: + using size_type = uint64_t; + T _max; + vector d, b; + + void _update(size_type s, size_type t, size_type p, size_type l, size_type r, T c) { + if (l <= s && t <= r) { + d[p] += c * (t - s + 1); + b[p] += c; + return; + } + size_type m = s + (t - s >> 1); + if (b[p] && s != t) { + d[p * 2] += b[p] * (m - s + 1), d[p * 2 + 1] += b[p] * (t - m); + b[p * 2] += b[p], b[p * 2 + 1] += b[p]; + b[p] = 0; + } + if (l <= m) _update(s, m, p * 2, l, r, c); + if (r > m) _update(m + 1, t, p * 2 + 1, l, r, c); + d[p] = d[p * 2] + d[p * 2 + 1]; + } + + T _query(size_type s, size_type t, size_type p, size_type l, size_type r) { + if (l <= s && t <= r) return d[p]; + size_type m = s + (t - s >> 1); + T res = {}; + if (b[p]) { + d[p * 2] += b[p] * (m - s + 1), d[p * 2 + 1] += b[p] * (t - m); + b[p * 2] += b[p], b[p * 2 + 1] += b[p]; + b[p] = 0; + } + if (l <= m) res += _query(s, m, p * 2, l, r); + if (r > m) res += _query(m + 1, t, p * 2 + 1, l, r); + return res; + } +public: + segtree(T _max) : d(4 * _max, {}), b(4 * _max, {}), _max(_max) {} + + void update(size_type l, size_type r, T c) { + _update({}, _max, 1, l, r, c); + } + + T query(size_type l, size_type r) { + return _query({}, _max, 1, l, r); + } +}; + +void solve() { + read(int, n, q); + readvec(int, a, n); + vector> effect(n); + auto getsum = [] (int x) { + int res = 0; + while (x) { + res += x % 10; + x /= 10; + } + return res; + }; + for (int i = 0; i < n; ++i) { + effect[i][0] = a[i]; + for (int j = 1; j < 10; ++j) { + effect[i][j] = getsum(effect[i][j-1]); + } + } + segtree tr(n); + while (q--) { + read(int, p); + if (p == 1) { + read(int, l, r); + tr.update(l, r, 1); + } else { + read(int, x); + int idx = tr.query(x, x); + cout << effect[x-1][min(idx, 9)] << endl; + + } + } +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1795c.cc b/src/bin/cf-1795c.cc new file mode 100644 index 0000000..3862c7e --- /dev/null +++ b/src/bin/cf-1795c.cc @@ -0,0 +1,277 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n); + readvec(int, a, n); + readvec(int, b, n); + vector diff(n + 1), res(n); + vector ps(n + 1); + for (int i = 1; i <= n; ++i) { + ps[i] = ps[i-1] + b[i-1]; + } + auto get = [&] (int l, int r) -> ll { + return ps[r + 1] - ps[l]; + }; + auto set = [&] (int l, int r, ll val) -> void { + diff[l] += val; + diff[r + 1] -= val; + }; + for (int i = 0; i < n; ++i) { + int l = i, r = n - 1; + while (l < r) { + int mid = l + r + 1 >> 1; + if (get(i, mid) > a[i]) { + r = mid - 1; + } else { + l = mid; + } + } + if (get(i, l) <= a[i]) { + set(i, l, 1); + if (get(i, l) < a[i] && l != n - 1) { + res[l + 1] += a[i] - get(i, l); + } + } else { + res[l] += a[i]; + } + } + ll acc = 0; + for (int i = 0; i < n; ++i) { + acc += diff[i]; + res[i] += b[i] * acc; + } + putvec(res); +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1808c.cc b/src/bin/cf-1808c.cc new file mode 100644 index 0000000..6da2aea --- /dev/null +++ b/src/bin/cf-1808c.cc @@ -0,0 +1,311 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +ll pw[11][19]; + +void prep() { + for (int b = 1; b < 11; ++b) { + pw[b][0] = 1; + for (int j = 1; j < 19; ++j) { + pw[b][j] = pw[b][j-1] * b; + } + } +} + +void solve() { + read(ll, l, r); + auto gettot = [] (ll x) -> int { + int res = 0; + while (x) { + res += 1; + x /= 10; + } + return res; + }; + auto get = [] (ll x, int b) -> int { + while (b--) x /= 10; + return x % 10; + }; + auto getrep = [] (int digit, int t) -> ll { + ll res = 0; + while (t--) { + res *= 10; + res += digit; + } + return res; + }; + auto set = [] (int digit, int t) -> ll { + return digit * pw[10][t]; + }; + auto work = [&] (ll x, int rg) -> ll { + int mx = 0, mn = 10; + int tot = gettot(x); + ll res = 0; + for (int t = tot - 2; ~t; --t) { + for (int i = 1; i < 10; ++i) { + for (int k = i - rg; k <= i; ++k) { + int tmx = min(k + rg, 9), tmn = max(k, 0); + if (tmx < tmn) continue; + res = max(res, set(i, t) + getrep(tmx, t)); + } + } + } + ll acc = 0; + for (int t = tot - 1; ~t; --t) { + int digit = get(x, t); + for (int i = 0; i < digit; ++i) { + if (t == tot - 1 && i == 0) continue; + int new_mx = min(max(mx, i), 9), new_mn = max(min(mn, i), 0); + if (new_mx < new_mn || new_mx - new_mn > rg) continue; + res = max(res, acc + set(i, t) + getrep(min(new_mn + rg, 9), t)); + } + int new_mx = max(mx, digit), new_mn = min(mn, digit); + mx = new_mx, mn = new_mn; + if (mx - mn > rg) break; + acc += set(digit, t); + } + if (mx - mn <= rg) res = max(res, x); + return res; + }; + for (int i = 0; i < 10; ++i) { + ll curr = work(r, i); + if (curr >= l) { + cout << curr << endl; + return; + } + } + exit(1); +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1933a.cc b/src/bin/cf-1933a.cc new file mode 100644 index 0000000..35a741e --- /dev/null +++ b/src/bin/cf-1933a.cc @@ -0,0 +1,247 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n); + ll res = 0; + for (int i =0; i < n; ++i) { + read(int, x); + res += abs(x); + } + cout << res << endl; +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1933b.cc b/src/bin/cf-1933b.cc new file mode 100644 index 0000000..a630e85 --- /dev/null +++ b/src/bin/cf-1933b.cc @@ -0,0 +1,261 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n); + readvec(int, a, n); + ll sum = accumulate(a.begin(), a.end(), ll(0)); + if (sum % 3 == 0) { + cout << "0\n"; + } else if (sum % 3 == 1) { + int f = 0; + for (int i = 0; i < n; ++i) { + if (a[i] % 3 == 1) { + f = 1; + break; + } + } + if (f == 1) { + cout << "1\n"; + } else { + cout << "2\n"; + } + } else { + cout << "1\n"; + } +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1933c.cc b/src/bin/cf-1933c.cc new file mode 100644 index 0000000..f65fa75 --- /dev/null +++ b/src/bin/cf-1933c.cc @@ -0,0 +1,276 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +set decompose_all(int x) { + int sq = sqrt(x); + set res; + for (int i = 1; i <= sq; ++i) { + if (x % i == 0) { + res.insert(i); + res.insert(x / i); + } + } + return res; +} + +void solve() { + read(int, a, b, l); + set factors = decompose_all(l); + int res = 0; + vector powa(21), powb(21); + powa[0] = powb[0] = 1; + for (int i = 1; i <= 20; ++i) { + if (powa[i-1] && powa[i-1] * a <= 1e6) + powa[i] = powa[i-1] * a; + if (powb[i-1] && powb[i-1] * b <= 1e6) + powb[i] = powb[i-1] * b; + } + for (auto&& f : factors) { + for (int i = 0; i <= 20; ++i) { + for (int j = 0; j <= 20; ++j) { + if (f * powa[i] * powb[j] == l) { + res += 1; + goto fi; + } + } + } + fi: + ;; + } + cout << res << endl; +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1933d.cc b/src/bin/cf-1933d.cc new file mode 100644 index 0000000..589e389 --- /dev/null +++ b/src/bin/cf-1933d.cc @@ -0,0 +1,268 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n); + readvec(int, a, n); + sort(a.begin(), a.end()); + int mn = a[0]; + int cnt = 0; + for (int i = 0; i < n; ++i) { + if (a[i] == mn) { + cnt += 1; + } else { + break; + } + } + if (cnt == 1) { + cout << "YES\n"; + } else { + int f = 0; + for (int i = 0; i < n; ++i) { + if (a[i] % mn) { + f = 1; + break; + } + } + if (f) { + cout << "YES\n"; + } else { + cout << "NO\n"; + } + } +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1933e.cc b/src/bin/cf-1933e.cc new file mode 100644 index 0000000..c220e86 --- /dev/null +++ b/src/bin/cf-1933e.cc @@ -0,0 +1,265 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n); + readvec(int, a, n); + vector ps(n + 1); + for (int i = 1; i <= n; ++i) { + ps[i] = ps[i-1] + a[i-1]; + } + read(int, q); + auto calc = [] (ll u, int p) -> ll { + return (2 * u + 1 - p) * p / 2; + }; + while (q--) { + read(int, s); + read(ll, u); + int l = s, r = n; + while (l < r) { + int mid = l + r + 1 >> 1; + if (mid != s && calc(u, ps[mid] - ps[s-1]) <= calc(u, ps[mid-1] - ps[s-1])) { + r = mid - 1; + } else { + l = mid; + } + } + cout << l << ' '; + } + cout << endl; +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-1933f.cc b/src/bin/cf-1933f.cc new file mode 100644 index 0000000..c43b770 --- /dev/null +++ b/src/bin/cf-1933f.cc @@ -0,0 +1,290 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n, m); + vector> a(n, vector(m)); + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + read(char, c); + a[i][j] = c - 48; + } + } + auto serialize = [&] (int x, int y) -> int { + return x * m + y; + }; + vector> ch(n * m); + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + if (a[i][j]) continue; + if (a[mod(i-1, n)][j] == 0 && a[mod(i-2, n)][j] == 0) { + ch[serialize(mod(i-2, n), j)].push_back(serialize(mod(i, n), j)); + } + if (j && a[mod(i-1, n)][j-1] == 0) { + ch[serialize(mod(i-1, n), j-1)].push_back(serialize(mod(i, n), j)); + } + } + } + vector vis(n * m); + vector dis(n * m, INF); + deque dq; + dq.push_back(serialize(0, 0)); + dis[serialize(0, 0)] = 0; + while (dq.size()) { + int v = dq.front(); dq.pop_front(); + continue_or(vis[v], 1); + for (auto&& u : ch[v]) { + if (dis[v] + 1 < dis[u]) { + dis[u] = dis[v] + 1; + dq.push_back(u); + } + } + } + int res = INF; + for (int i = 0; i < n; ++i) { + int d = dis[serialize(i, m - 1)]; + if (d == INF) continue; + int k = (d - i + n - 2) / n; + res = min(res, i + 1 + k * n); + } + if (res == INF) { + cout << -1 << endl; + } else { + cout << res << endl; + } +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-455a.cc b/src/bin/cf-455a.cc new file mode 100644 index 0000000..5a72d72 --- /dev/null +++ b/src/bin/cf-455a.cc @@ -0,0 +1,250 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n); + constexpr int N = 1e5 + 10; + vector cnt(N + 1); + for (int i = 0; i < n; ++i) { + read(int, x); + cnt[x] += 1; + } + vector> dp(N + 1); + for (int i = 1; i <= N; ++i) { + dp[i][1] = dp[i-1][0] + ll(cnt[i]) * i; + dp[i][0] = max(dp[i-1][0], dp[i-1][1]); + } + cout << max(dp[N][1], dp[N][0]) << endl; +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf-580c.cc b/src/bin/cf-580c.cc new file mode 100644 index 0000000..194d5b4 --- /dev/null +++ b/src/bin/cf-580c.cc @@ -0,0 +1,266 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n, m); + vector a(n + 1); + for (int i = 1; i <= n; ++i) { + cin >> a[i]; + } + adj(ch, n); + for (int i = 0; i < n - 1; ++i) { + read(int, u, v); + edge(ch, u, v); + } + int res = 0; + auto dfs = [&] (auto dfs, int v, int pa, int acc) -> void { + if (a[v]) { + acc += 1; + } else { + acc = 0; + } + if (acc > m) return; + if (v != 1 && ch[v].size() == 1) { + res += 1; + return; + } + for (auto&& u : ch[v]) { + if (u == pa) continue; + dfs(dfs, u, v, acc); + } + }; + dfs(dfs, 1, 0, 0); + cout << res << endl; +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/cf1744e1.cc b/src/bin/cf1744e1.cc new file mode 100644 index 0000000..cdae065 --- /dev/null +++ b/src/bin/cf1744e1.cc @@ -0,0 +1,241 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/d.cc b/src/bin/d.cc index 97db525..589e389 100644 --- a/src/bin/d.cc +++ b/src/bin/d.cc @@ -30,9 +30,10 @@ using pll = pair; /* constants */ constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; constexpr ull MDL = 1e9 + 7; constexpr ull PRIME = 998'244'353; -constexpr ll MDL1 = 825; +constexpr ll MDL1 = 8784491; constexpr ll MDL2 = PRIME; /* random */ @@ -206,95 +207,48 @@ int period(string s) { // find the length of shortest recurring period } ///////////////////////////////////////////////////////// + // #define SINGLE_TEST_CASE // #define DUMP_TEST_CASE 512 void dump() {} -template> struct sparse_table { - _Op op; - vector> st; - template - sparse_table(ReverseIterator __first, ReverseIterator __last, _Op&& __operation) { - op = __operation; - int n = distance(__first, __last); - st = vector>(n, vector<_Tp>(int(log2(n) + 1))); - int i = n - 1; - for (auto it = __first; it != __last; ++it) { - st[i][0] = *it; - for (int j = 1; i + (1 << j) <= n; ++j) { - st[i][j] = op(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]); - } - i -= 1; - } - } - _Tp query(size_t __start, size_t __end) { - int s = lg2(__end - __start + 1); - return op(st[__start][s], st[__end - (1 << s) + 1][s]); - } -}; - -auto u_max = [] (const int& a, const int& b) { return max(a, b); }; -auto u_min = [] (const int& a, const int& b) { return min(a, b); }; +void prep() {} void solve() { read(int, n); readvec(int, a, n); - vector ps(n + 1); - for (int i = 1; i <= n; ++i) { - ps[i] = ps[i - 1] + a[i - 1]; + sort(a.begin(), a.end()); + int mn = a[0]; + int cnt = 0; + for (int i = 0; i < n; ++i) { + if (a[i] == mn) { + cnt += 1; + } else { + break; + } } - vector res(n); - // sparse_table mxt(a.rbegin(), a.rend(), u_max); - // sparse_table mnt(a.rbegin(), a.rend(), u_min); - sparse_table mxt(a.rbegin(), a.rend(), u_max); - sparse_table mnt(a.rbegin(), a.rend(), u_min); - auto find_left = [&] (int i) -> int { - // find the first ps > a[i - 1] - if (i == 1) return INT_MAX; - int l = 0, r = i - 1; - while (l < r) { - int mid = l + r + 1 >> 1; - if (ps[i - 1] - ps[mid] <= a[i - 1] || mid + 1 != i - 1 && mxt.query(mid, i - 2) == mnt.query(mid, i - 2)) { - r = mid - 1; - } else { - l = mid; + if (cnt == 1) { + cout << "YES\n"; + } else { + int f = 0; + for (int i = 0; i < n; ++i) { + if (a[i] % mn) { + f = 1; + break; } } - if (ps[i - 1] - ps[l] <= a[i - 1] || l + 1 != i - 1 && mxt.query(l, i - 2) == mnt.query(l, i - 2)) { - return INT_MAX; + if (f) { + cout << "YES\n"; } else { - return i - l - 1; + cout << "NO\n"; } - }; - auto find_right = [&] (int i) -> int { - if (i == n) return INT_MAX; - int l = i, r = n; - while (l < r) { - int mid = l + r >> 1; - if (ps[mid] - ps[i] <= a[i - 1] || i + 1 != mid && mxt.query(i, mid - 1) == mnt.query(i, mid - 1)) { - l = mid + 1; - } else { - r = mid; - } - } - if (ps[r] - ps[i] <= a[i - 1] || i + 1 != r && mxt.query(i, r - 1) == mnt.query(i, r - 1)) { - return INT_MAX; - } else { - return r - i; - } - }; - for (int i = 1; i <= n; ++i) { - if (i > 1 && a[i-2] > a[i-1]) res[i-1] = 1; - else if (i < n && a[i] > a[i-1]) res[i-1] = 1; - else res[i - 1] = min(find_left(i), find_right(i)); - if (res[i - 1] == INT_MAX) res[i - 1] = -1; } - putvec(res); } int main() { untie, cout.tie(NULL); + prep(); #ifdef SINGLE_TEST_CASE solve(); #else diff --git a/src/bin/e.cc b/src/bin/e.cc new file mode 100644 index 0000000..c220e86 --- /dev/null +++ b/src/bin/e.cc @@ -0,0 +1,265 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n); + readvec(int, a, n); + vector ps(n + 1); + for (int i = 1; i <= n; ++i) { + ps[i] = ps[i-1] + a[i-1]; + } + read(int, q); + auto calc = [] (ll u, int p) -> ll { + return (2 * u + 1 - p) * p / 2; + }; + while (q--) { + read(int, s); + read(ll, u); + int l = s, r = n; + while (l < r) { + int mid = l + r + 1 >> 1; + if (mid != s && calc(u, ps[mid] - ps[s-1]) <= calc(u, ps[mid-1] - ps[s-1])) { + r = mid - 1; + } else { + l = mid; + } + } + cout << l << ' '; + } + cout << endl; +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/f.cc b/src/bin/f.cc new file mode 100644 index 0000000..c43b770 --- /dev/null +++ b/src/bin/f.cc @@ -0,0 +1,290 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +#include +using namespace std; +using namespace __gnu_cxx; +using namespace __gnu_pbds; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + read(int, n, m); + vector> a(n, vector(m)); + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + read(char, c); + a[i][j] = c - 48; + } + } + auto serialize = [&] (int x, int y) -> int { + return x * m + y; + }; + vector> ch(n * m); + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + if (a[i][j]) continue; + if (a[mod(i-1, n)][j] == 0 && a[mod(i-2, n)][j] == 0) { + ch[serialize(mod(i-2, n), j)].push_back(serialize(mod(i, n), j)); + } + if (j && a[mod(i-1, n)][j-1] == 0) { + ch[serialize(mod(i-1, n), j-1)].push_back(serialize(mod(i, n), j)); + } + } + } + vector vis(n * m); + vector dis(n * m, INF); + deque dq; + dq.push_back(serialize(0, 0)); + dis[serialize(0, 0)] = 0; + while (dq.size()) { + int v = dq.front(); dq.pop_front(); + continue_or(vis[v], 1); + for (auto&& u : ch[v]) { + if (dis[v] + 1 < dis[u]) { + dis[u] = dis[v] + 1; + dq.push_back(u); + } + } + } + int res = INF; + for (int i = 0; i < n; ++i) { + int d = dis[serialize(i, m - 1)]; + if (d == INF) continue; + int k = (d - i + n - 2) / n; + res = min(res, i + 1 + k * n); + } + if (res == INF) { + cout << -1 << endl; + } else { + cout << res << endl; + } +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/hack.cc b/src/bin/hack.cc new file mode 100644 index 0000000..e12f3d7 --- /dev/null +++ b/src/bin/hack.cc @@ -0,0 +1,65 @@ +#pragma GCC optimize ("Ofast") + +#include + +using namespace std; + +#define Abdoo ios::sync_with_stdio(0);cin.tie(0);cout.tie(0); + +void pr(vector v) { + for (int i = 0; i < v.size(); ++i) { + cout << v[i] << " "; + } + cout << "\n"; +} + +vector get_divs(long long n){ + vector divs; + for(long long i=1; i*i <=n; i++){ + if(n%i == 0) { + divs.push_back(i); + if(i != n/i) divs.push_back(n/i); + } + } + return divs; +} + +int main() { + Abdoo + int tc = 1; + cin >> tc; + while (tc--) { + int a,b,l,cnt =0; + cin >> a >> b >> l; + vector v = get_divs(l); + sort(v.begin(),v.end()); + //pr(v); + set st; + for(int i = 0; i < v.size(); i++){ + long long ax = 1; + for(int j = 0; j < 21; j++){ + long long bx = 1; + ax *= a; + if(j == 0) ax = 1; + for(int k =0; k < 21; k++){ + bx *= b; + if(k == 0) bx = 1; + long long x = v[i] * ax * bx; + + if(l == x){ + //cout << x << " " << v[i] << " " << j << " " << k << "\n"; + st.insert(v[i]); + } + if(b == 1 || bx >= 2e6){ + break; + } + } + if(a == 1 || ax >= 2e6){ + break; + } + } + } + cout << st.size() << "\n"; + } + return 0; +} diff --git a/src/bin/std.in b/src/bin/std.in index 42f0b53..29691f0 100644 --- a/src/bin/std.in +++ b/src/bin/std.in @@ -1,18 +1,10 @@ -8 -4 1 -2 1 8 9 -3 3 -6 2 60 -4 5 -5 1 100 5 -3 2 -38 6 3 -1 1 -12 -4 6 -12 12 36 100 -4 1 -2 1 1 15 -3 5 -15 1 13 +4 +3 +1 3 5 +4 +1 3 5 7 +4 +1 2 3 4 +4 +10 20 30 40 diff --git a/src/bin/template.cc b/src/bin/template.cc new file mode 100644 index 0000000..1ff12f9 --- /dev/null +++ b/src/bin/template.cc @@ -0,0 +1,238 @@ +#pragma GCC optimize("Ofast") +///////////////////////////////////////////////////////// +/** + * Useful Macros + * by subcrip + * (requires C++17) + */ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) decltype(container)::value_type + +/* type aliases */ +using ll = int64_t; +using ull = uint64_t; +using pii = pair; +using pil = pair; +using pli = pair; +using pll = pair; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ull MDL = 1e9 + 7; +constexpr ull PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +/* build data structures */ +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) +#define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +template ostream& operator<<(ostream& out, vector vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} +///////////////////////////////////////////////////////// + + +// #define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 512 + +void dump() {} + +void prep() {} + +void solve() { + +} + +int main() { + untie, cout.tie(NULL); + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + solve(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/test.cc b/src/bin/test.cc index 19c94ce..cdae065 100644 --- a/src/bin/test.cc +++ b/src/bin/test.cc @@ -216,31 +216,7 @@ void dump() {} void prep() {} void solve() { - read(int, n, h); - readvec(ll, a, n); - sort(a.begin(), a.end()); - auto work = [&] (vector pattern) -> int { - int ptr = 0; - int i = 0; - ll curr = h; - while (i < n) { - if (curr > a[i]) { - curr += a[i] / 2; - i += 1; - } else { - if (ptr >= 3) break; - curr *= pattern[ptr]; - ptr += 1; - } - } - return i; - }; - int res = 0; - vector> patterns = {{2, 2, 3}, {2, 3, 2}, {3, 2, 2}}; - for (auto&& p : patterns) { - res = max(res, work(p)); - } - cout << res << endl; + } int main() {