From 985338c05c8c4b1634c231513ab1503e6c8703b5 Mon Sep 17 00:00:00 2001 From: David 'Digit' Turner Date: Tue, 19 May 2009 12:10:09 +0200 Subject: [PATCH] Expose the Zlib headers ( and ) in the android-1.5 NDK sysroot. This is OK because the Zlib ABI is fixed and stable. Also get rid of the sample zlib sources since we don't need the static library anymore. --- .../android-1.5/arch-arm/usr/include/zconf.h | 1 + .../android-1.5/arch-arm/usr/include/zlib.h | 1 + .../android-1.5/arch-arm/usr/lib/libz.so | Bin 0 -> 174756 bytes .../android-1.5/common/include}/zconf.h | 0 .../android-1.5/common/include}/zlib.h | 0 ndk/build/tools/build-ndk-sysroot.sh | 10 + ndk/sources/external/Android.mk | 1 - ndk/sources/external/zlib/Android.mk | 45 - ndk/sources/external/zlib/adler32.c | 149 -- ndk/sources/external/zlib/compress.c | 79 - ndk/sources/external/zlib/crc32.c | 423 ---- ndk/sources/external/zlib/crc32.h | 441 ----- ndk/sources/external/zlib/deflate.c | 1736 ----------------- ndk/sources/external/zlib/deflate.h | 331 ---- ndk/sources/external/zlib/gzio.c | 1026 ---------- ndk/sources/external/zlib/infback.c | 623 ------ ndk/sources/external/zlib/inffast.c | 318 --- ndk/sources/external/zlib/inffast.h | 11 - ndk/sources/external/zlib/inffixed.h | 94 - ndk/sources/external/zlib/inflate.c | 1368 ------------- ndk/sources/external/zlib/inflate.h | 115 -- ndk/sources/external/zlib/inftrees.c | 329 ---- ndk/sources/external/zlib/inftrees.h | 55 - ndk/sources/external/zlib/minigzip.c | 322 --- ndk/sources/external/zlib/trees.c | 1219 ------------ ndk/sources/external/zlib/trees.h | 128 -- ndk/sources/external/zlib/uncompr.c | 61 - ndk/sources/external/zlib/zutil.c | 318 --- ndk/sources/external/zlib/zutil.h | 269 --- 29 files changed, 12 insertions(+), 9461 deletions(-) create mode 120000 ndk/build/platforms/android-1.5/arch-arm/usr/include/zconf.h create mode 120000 ndk/build/platforms/android-1.5/arch-arm/usr/include/zlib.h create mode 100644 ndk/build/platforms/android-1.5/arch-arm/usr/lib/libz.so rename ndk/{sources/external/zlib => build/platforms/android-1.5/common/include}/zconf.h (100%) rename ndk/{sources/external/zlib => build/platforms/android-1.5/common/include}/zlib.h (100%) delete mode 100644 ndk/sources/external/Android.mk delete mode 100644 ndk/sources/external/zlib/Android.mk delete mode 100644 ndk/sources/external/zlib/adler32.c delete mode 100644 ndk/sources/external/zlib/compress.c delete mode 100644 ndk/sources/external/zlib/crc32.c delete mode 100644 ndk/sources/external/zlib/crc32.h delete mode 100644 ndk/sources/external/zlib/deflate.c delete mode 100644 ndk/sources/external/zlib/deflate.h delete mode 100644 ndk/sources/external/zlib/gzio.c delete mode 100644 ndk/sources/external/zlib/infback.c delete mode 100644 ndk/sources/external/zlib/inffast.c delete mode 100644 ndk/sources/external/zlib/inffast.h delete mode 100644 ndk/sources/external/zlib/inffixed.h delete mode 100644 ndk/sources/external/zlib/inflate.c delete mode 100644 ndk/sources/external/zlib/inflate.h delete mode 100644 ndk/sources/external/zlib/inftrees.c delete mode 100644 ndk/sources/external/zlib/inftrees.h delete mode 100644 ndk/sources/external/zlib/minigzip.c delete mode 100644 ndk/sources/external/zlib/trees.c delete mode 100644 ndk/sources/external/zlib/trees.h delete mode 100644 ndk/sources/external/zlib/uncompr.c delete mode 100644 ndk/sources/external/zlib/zutil.c delete mode 100644 ndk/sources/external/zlib/zutil.h diff --git a/ndk/build/platforms/android-1.5/arch-arm/usr/include/zconf.h b/ndk/build/platforms/android-1.5/arch-arm/usr/include/zconf.h new file mode 120000 index 000000000..10d4a1e6c --- /dev/null +++ b/ndk/build/platforms/android-1.5/arch-arm/usr/include/zconf.h @@ -0,0 +1 @@ +../../../common/include/zconf.h \ No newline at end of file diff --git a/ndk/build/platforms/android-1.5/arch-arm/usr/include/zlib.h b/ndk/build/platforms/android-1.5/arch-arm/usr/include/zlib.h new file mode 120000 index 000000000..d9e63a4bf --- /dev/null +++ b/ndk/build/platforms/android-1.5/arch-arm/usr/include/zlib.h @@ -0,0 +1 @@ +../../../common/include/zlib.h \ No newline at end of file diff --git a/ndk/build/platforms/android-1.5/arch-arm/usr/lib/libz.so b/ndk/build/platforms/android-1.5/arch-arm/usr/lib/libz.so new file mode 100644 index 0000000000000000000000000000000000000000..f50a0ff83029843966d18230cefd73ca6132a8b1 GIT binary patch literal 174756 zcmd?S3!EI)b?1MpA2Y31GnA~6Ez4slJ-{*u++Za;ixtxX0m7E;)&meQK`rz^*aI}u zIL0jA^t?2B%!mQKh%7(;sFo^$Sb-FvHl_o5{iTb5-Se{nO{=x)n9jG525{l1uq z8IzcA9FySLd(8|zFWz#dWg1733OW+h*Kr&gH~hVJmK7aI-PrZ#S!&e}n|F1z)Sq){ z$~DjxuKDp^$mmM5!O=Yc3*K?b$bvfyT`x9?xQP9cZaGcKZZ~glq6(hOkoN0RL zqNeMQa(zzyzMb>M9A|NSm?O`jzjty><#-RrWgI8|onJ2~a9&cs{x6&-bF8S}H=i!y z=6&^o#mx_zuB8L?7dJJ^d9OF_B@xIpIzWH%2K6+aqkFY#%nRo%9!{qwoez2r~#pE?1*OL+e<^k~rM;d*`PD%C%S`mzuD zQ-3b4KYx^aJwKOrO1TDoTFvKx_vHVm={n)p&Ha|9`vmtnnEo_y^!$s!$j>@Xzh%H{ zr@r*Op5M>?s|=(X{;lT6_4cI`)c#_Q9tK{vUSF6>-n(c=??1)8${O{50KC_l`uh^~ z=20nC$7gmOeuLkC&+}WpZ_F?V3EpQzrlI_CD=WR1pg0!e=kD5q~6}Q>hE_&&ujic z_JW$7RDJ2TCsAsLBKWQ5=k@wEe6X!2(CbX#HvYuF1Jr*FdEOGiZ#6I0-*3=gs){1h z$D#UzC%_9Ry9IqUm-7^~EA+DZ8vGof+){baqqY>wJnc>?|ypKu@JzVi&r ze1N**kHh)ZX^a=nqW6>Zr^Mi|@uSuJSMG;%$N7Id?cMenWRSD!U&`}a-qn!*RKk*9n(>45m z6ZoamkMnC9&ojfo2QT&SPw1z*bX&64AG3OG_qvTAJlCvRwR+v^Yp-AR=^H4s~szj2-6T->;B)20h<`t*%!C+^NQYuBysUfr|q(i^YuS=G2{ zoG+s0b?bUot=YI{RnO{cyMeNC4NXS>Pe8uz)=%F^tu^MlTi4yRp8wZgzj57~9xm2& zuUoxw-Nuc2vT@^08_lMkjos^RG&ij7?!IY_?$#7P8=Y47&=2a|c$02xm2XwS4V$hr z>(_MOv}v8W{>BK?2&r2?v+??#b!L6-blt7RPxox16;489<2sSTtlzY5-KQF_EnBx~ zop35{y#B_X_2zdr-B`a`wQ5t(>NTHQwPwSoR;^!seK&|4FSzd0t2eHFYZ9LWFhCYp zZ(M!DrUu3GwL5iPD6g+0w7&b(n>LvB_0z_6tJgNr65Y>TW!A5~sR&`#_pIygZoq0h zs^hsnssVMQ^QL;~b+^`wn}M1e*4-e=3PC8qU9ImC^y_YgSt3@%vrpgH5R7JwCM03` zx}L>gyKZ9xsr<(4Z&=s3S@CHEt1dtn-b91-Yu;LP{hFTZZ@O{y#)-n3;MHr?xUs5d zajFT1$|G8>x)wS4lv#z)T-UP!iCeqQtXg~hCPXs2q~4~Un>Man z+o(vv>h9~WyRm@@^@^X}c>Q%7kT0I~0ROY**6!=Cy?ouqP2d+@U&zq7zI)xp-K($L zWNy7ElGM7e)w)~1xnzPE^@8P}y>U(cCgiC>yNC#lhi@W6qmVZmmFq*Q{sh_EGy&%V z1hO_F>rYi6!Ed^4TsL)*eyurs(@lo+rk=HH&OEbzbA!%|uUoEPdy9m7V>H^LyLA9v zwQB9^p4E*9>vTiewVO6IijH5eT2+6-d(n0M9E}*Yd#jo{jGsM?;9xE1cedb{>x`e= ztur>Ds51dukIoKyUFVtTHl6372X#gl4(NO~HdSW=l3|_a<8$l05PhoiMffN><6G?4 z`6KuUI%62`)%jz_d{yUV#yqI=<;INZd?or?=QYIgIxATH|Jh%{J1b0h_k?ZU?Oy7Q z$HG@m#ln2|_F&3W!@(=#hr`D83r*KgH(fv3bbYw#`cTvLgH6}>HeK&;y57}vJ=}CX z&~$xU({)eNb$8SC+NSHSrt1|=*GrnN7d2fkXu6)y^&1P%`muSf>|178C062GEc<73 z?<_9+j~Rp2URwEM&L{J{Y|OsP&nj0wVEO_)BR{YEk;TE~H-XBS172%Xw=b%bYSgFB zB-N)*hB|5LC!AWH$<%MF!^x;VbqsY9cAs}r?!_?f^m=X7&)C3sdp(QyP6k#YJM3k+ z7RjO!u)G1UEjR4h`N81n@$nhiS@(pO|A0Qb!@-^Nd%Zi``n@l_tL%U2 zzd);0*^kfVn00|?#d7qe&$CR)yZm!QK?eG?dDnW0T*1p0hk`@n7IqqpW{sg^_*O^RP z$LU4=2EBlBQVzHVdO*82>KW0_E_o+|S0Y=Zo!S+>Z1|n9ckpaw#Y8mg^=$h2{dzx9 zhiT)KE3M|aDl`vLW|?oi9nf~b`zPr7vU^XszrEz`Kc&wr|54fh;`_>eW_sC=b#k10 zp_h5bLN7+&Gs3}J10A7doo;0MDkl5vG|MSZje9$6VA{Bg=~nxATUJwB-PwD>@pUKywOhf*>L=6-m`~;Ht1rRyg#1F z_5IxB`Vvlw`(^(4ybJn%?p)9pOO+y?l0B`6w>OtsOU2w-KR%4!x%=_Wp7~zczwe5& zKW{_XPcG&-cafKbma+U=Z%;DeIjORL_Z-@oi)>ZP{`k|IgEnX}-dzfQZn%afvv~Ff za%gQRS7Pokm>8K$>oES&>w^V=>&BRQ{J~-ZLvI z$=ssY&&S7)wPz26DmU59;mdkP-PbAaArRW~t?_Z$0^@p>jBuviAB>N`o}nE>I~n98 zW9|v#+1oubH&GuCz1uRQy!XaMXZ_e&3qOWig7K$KkeR>5%MRQVI^F1-Ow^ud3d@32 z>2~y;2M6>{A94~I6H_m{*=FTwlq~rY^ z<0F&x{MmD8uOmi#@gS3c?oXGz_&m{P*n4B}+pnE!F0Ukt3xjXN>#u(4o-kqW4b$Eh zFO}bm-k9gjUc&oMJcwC4yu^_m-t5`vtdEp}+32sPLUf@=R_gdTl1-d^TfmRt;x69#{>Wr`B<1 ztVTGW3a;QB!H;0aYOo!2b_4dAeZU6q+@0t!U;{S+{8^%h9h-nXs}6e>I8VR^=i{)C zT!+NA!T^4*I>u&*L;V4fx=0>^rd&(48Y=W_woFsmTg5 zI2&4L;Hl&zc4UV){sAj!om>hme6Tib&-kfv6<*2g!+Xb|RZIJqJB! zkVDCRjQb0)HF2)V&F}ka8TrqCBa;6F_2SfsPiJYj6@8Pip9znT>6zGuQV^e_aoroyCG+G=?|(6_Q|O{wnsmxQ zzjWr(z<6a}xZge$1j49y(dh& zTf9VmPiQ&3n~eqWg~Q&gpOpPsacH?W0|6G4Y3`krRS5%PaeRpY`+IwD=ok~zwJP|KuBUjQ3vuSHK?Tnvlf;P2f-CZ?H zWJ9ni=y=mfTTh~AjN`?T%{c93%q;K6(U`oVvY0VBpEl%wv}9kYMq>b6A z4{03yJ>zi!*^lEe%aCz6$yYGMw9n%ux zk9W5HMW;pwQyG<`; z#3IBY#3E#}msPCng~5hwZ&-AC!%nw%+5)#XR2$5Q;bWV0SN553qgk%@QPcS1JX;`p z7vWT%%Kem1XS4>_0N0e`jrVC_;{BCoG)XyNYA^&}_nq!&m=iqY!~%EqsWV%ew!kTc zht0EoA?sESXOH-T`37>{aWi8jpAQn)oz~**-fz)HXLdLEEa%nphbbI$U|Tj0mh z=z4(hI}m(D*VN6M!I1S6=@s_wa1Ukq+-}Bs+5Z!+&&wi5_@(OC4DZ4qk#(yv=jqV$ zo(@~=GP#J|;k|l?b3%3vUN5#~6NkKiW^8YX+87P{buN^BV*6urjBMTB>U48Q7{v~b z>U-ea8^*GGtG3x0Dt0)`d~gpPvHxm(JS*KmoFaNzc`rU2eDelBx87Ivr2}6{^n*6= z>xJ+$T%X3Z_#TZ34TJ!YyAx*pRJV;iBjn<0W5yr~&s5>MU+*XN3C|P4`>5 z7p;akOWs9;EHwBC_wuLSi+q{9HrF5y|ybbIQD#=hz@wvR(k(F6z@w^l2qDsP$>7FZ)v9UUH@9 zYpJ_I???{7n?Vrq{S?Q%u0FS!vwp0Y_T|Do;mg=d>*&XVmcs2`y0oX7l5EeAj=n3L zgRZk?z*l#~OL)VKw-HaaHSYc}Ocm+>F^;P^KH^nU?v7wCc{ADd*4&~XnT4kL;i@SS zUxD}7KO>7Sw!N)fY0KjKJ4=E%ITZBTHo=K!|AIa*uS}*d(ramZPt`ha1RF?<2p%zP z>?G)yqEFUQ#`s0V>|9HirGVcGt+2KJ$KeC^^VmMxJB;>P%h;We={z!Bcx#zPPt35P zpT?ZVZUUI1e+w{+(D03^=2%0P8?r8$zL$0)na+Ast#_9zo!NnDwmlI33>>0%3;EzO z;B{qRigba-ymX*o9{c6^G27V_eg?adAZHN=KkL$s0eToYxvX+2=MCDQZ@4MG}8{Ey%%FIY&(>n8;lgJE17~7ODPgS{Ol(BCS$3UHY zB^V#yr#}BF{a=#b6XtSz!f}%%hA#V`q;IFa3eQYibiZEr%1asIf1Y2VrpXm=H5bJ|tkitaDhJ-IGD8#g9crhDGi{U^A76q+qI#2xfA0o`--ZwciI z@=^%JjKwz3&@r~NnVjzC@axpK>bj{@@6iu(I_akh082D4~ewr?Ki4d@cpk$gzzYWx@opFCOos67+!q+e?M7&y+4 z!ax!}*7#9q;z!|E`Ee9}Xgr7iH2!)gXZ6iuh1ClYjkt$K$%sa~!ZRg~YZd0AC@@Xq8)2Y)^uQT&4>gaiber^^ms82{T(ZBzFB7KTA z`dEca0?}Ud+}u?EraJrydX`>!HN{vo@UNvnKHvOK1tz3hOO(+TbWEaO(_gd9G2tH3 zh&mRy3$Fst8tuGP?}J6I_O z;vhcsbF^be?VuZ`s4dAwEb=D?!%krT^dHAx7oJA2!Bw=-cudw|FUszoX6p1XyuVQ6 zoIXsnkyT%&*4il7+W0N%n6g)i;?&Y^#>9-uCurB^d~VeK48_-x%-{=5$PDX>CdNcG z?uy7W{b(LT*rtj4Il+MTR%ua?C^1f5@>j@9Lq<~BvL%~Dzr$Z(yAIOVi0`F0)A1?F zoB3|QBjN|+Sz~ZQCY@&xL1HLmx8zx3oUB$QLdaQACiq&7C#eO9fVek3h09( zcohc2Kjc0Kj#jb$p8X6wpE4o8qW2(uzKZrDSrUDlWNBj^j}v9-?|+Fbm73rdUIy+v zBe+(fHa7m2I)ZO?V*?n!t&k?;dTudxD<& z8_JvMwqQaIe^pP7+cm!TLL06tzYE+adH=2C>Xka&6XoisZ$sCM!I|mCN+`%Z34IEP~{$082H zv6v&nVRIxnavYr;3pmztY~bh~|CY7V`>M*Lk#pXM^am zdE~+r?`j@(G0(bk-wWrs2cp<r#HJ%lTe1Yc2>@bNv~!Z0cvo zdyVHz(3SljJ^(h^E8l@Huy1`WZiuI7X9L&d1L8@pmvJ5EI>xo-JRRw9UEh`+VLo8F zUqPpK$Ic;Sq7hFq*=t~?$-1Tx4cR5_E zoePPbbHF`=x`{0C?KM&R1$#@_hknRV{sOt6oA43apli$>@;bd*Jko|f7mRFv7!%yZ}ALZ<>8sb&-Cpm8BPfhvZ`Q*Bhg>NaJ z){;Zk9BhX@$QpyP|Ch9cSp zsOBjKLYw@@Gd$}iCQ}ac2V9%%k+8^phFpnVAm`-Pa&?x|OTO!3VgmW;*u~MUu?#tw zZeq9%f>js@CzZ<?czJ^1U3iZxskJU2yhVc^urg;~V8T5m-POqw;_zJ!$bOrEe zqD|sOctl;+H6&EWe*V==L9)no&lXSkKG0PEjYjdjBe?c+uUZSJ>kQBj2Rherl~AIxMPpx?oXnqD_x_ z9(4@5^Iymj@V?$dSI20HS|1* ztxM2e(p>9F#v@rNm;H^r*J*1E-pm-hd8+2nG+tEa5B`^Y3UDYid{uBI?)f9iH4YYK zcTGcnfeW3;k+D_`ACfxg@&)kWa6vxsJAq3-WecEDtiZW25PpYt_r48$wfk1^@tvL*`F&w3R3_M$Hv|OR?MwO}A-$+YxP* zi{BNtI%WSN+KYHge>Cn}3fFn9ZD)8Q_zyCt{Tgh@1*FjUugKi#UB`cqJYUMZS?+1YgeQNkJ zj$W2uT&mxf2Eu!|k2%o6VLYjBQ{TSCGwA{FQ{FoKXVt})g2U7(cTLV1Upa2&G%k=a z`e$i3EcuzTC(cvRpcSm{MVg(;0U3B*__sTQ$gXWi%<3oQ;?Istz zft;|#`qIwq=4paM{iD_-<|v)=LyWO6Nf#=AT*3bnY^}{@F61e44aYX*_Jn`TS$M4l zUn{pJ!uJXAU1WrBzBYD%D;iA3pMJYG7SYC8^;}QAjTsLCTe)%Oh>po${A7dA54IKN%$M3(Z4tsh1 z*~isl`K z8#+rqP6Q`^M|cMQ`9nR#@=5gd}E;{LCkC^6-U7=ts`d6Ok z{*~vQ|H|{`_HG6*$t|=3PY*r}gwhe$QO>ie&qI^@P9_Fm4l|C7KMs$6$aBr1h-UP6 zYBY}mpU|08k<)lw{3>`F3yd#fA?8jx^6K+tnmf_Fil3mrC!52}A^bkao6m8x|Fx^x zdl5G~UK6geW1^1(eM~VQtc0E#m#Wi&U-F5+9e;fu>w#m)zsU`SjsB^=$~(0Fj|zQ}Qw>qU;PmqjtW za=Wq%^IUKs$207}W8q32<$Q9$>7(pa%9eP0qa6Ms%63pTgR&HLGSp2`_D=58tT{sC546$Z(sA}><)$I3&&=W)9^fQOTIUgMg?|`?mcZ-N^`PkY0K zw_h5>a_qN2){@z^rDU#r2YYQwdJjJMFZ>ODeSUA)of`_fI1Kw;R+jgMD|mmg844}u z#c+NJ`WB$mj9K0yZ!ht@<>^^mI-RkdWNlrHxxAE}@p^%4pEui^q7zrJ?PdY{YPSDRY=-*++!}p+3D>3zC<`2Gj&T!=aozMNO+5KLU z{x|fC^gtFL;AGx|hH14YeV2Dt))mG4(qn(|w>3MpXf?XOzFtY|6`J+U8`3xA|K#V2 z?oL+MHM-A1HZ(Ssr;Fvvm3g_raJnP8B#&Z8^64Ar+Jn=bp|49;Zzdmh27ZNnA=@4b zng2t+c!#4MIwZ0~^i^>RV;uTC2oDT!vpk=h8wzC~Ps^Csmp~KAx@5SYdc&&k^`Vc4 z!h^Yw`!VN&XdZol_Xnt(am$sp*tDG)wzzwny*8)hJ?4)32eZ%lk9g1dhwSHwpO86+ zHHP3Y><)#az`D&F3JcBZ zXXy6b6H1<=wL2wjY8lxs5FZxFd5s^_-BgO9Zc9GUr*u_p3J@F zl%J1f%TFYnkr(aaC68mvzhl{#vae_<@$O|iS=Tf}_2B38$jcM0ddHNW7tjBaXOk39 zyF7EtPuzF@e*Y+C33D|u8)d+K-~&71<4DNd`i!||U!-59OKUoIAH2V!GN}k|_zel> z;F&Xz=E7UOtwG0!%YH{|+0T3A5AdNa)~DUZTG2`N)?fu?JCF3Ca}K;_*}340$iQ@W zAnc&teC*0fX8>Oo+M=`P8OA<*?Z|BlO?d#Fy)SIEKMxzIT#lYMmoK3__ZHoD2>ngGY7d~l_k{`IG+?)SyQ~gIRh{E(3vc6oF8)Q%FxDw^DC?nYK7Lx({0TCu28k zd*n6dS6{cmOTLlD#mag2g!45|fc*E2j)vXkQP!S~ApeXFY;Zf*@;4WL0)HzzfIo1h z-%qSPuOPjBaS+Qd4mLyE7TQR9&^AAUJ{SqlQ~Z$Ii(fB#URK!v9h2-C>>NWEIpx{- zlBgHfI5=gCU?!b(Hn6V;IrC(D2k7tJp=?P&&QrGKuQ;cj?cOBQ2VS)`U?2ZEIw`x0 zT=TB5XLN6vH2q!@zc>Y7qqSw=G-)5MRZvgdat`Y6qf9* z-a%)nZ$|OOsFTp%L36o3`>ygG`0l~M(bc~4Q#oMGL$|dUtuq?_H@zd?h-NJ%?SrWC zXb-S#;6(k7e7`HDCwKl1wC5{j6&M09uB@ONx2fOl^t&BC>$=m$7TeI(Q-8L3vHT0+ ziUR%1?G2}#eVRAl&{jU?4I(3l3U~WC>ZY^C>vzlkLxo|#y)Y6UD(~J;cx zF)O=uO(ljLu7xJI@T_1Dg~=RqozTAoOs>K4GXGxWNp`5c0RA6X5~R&~Pqrt+kDlwn7dmpwy!ciHNmPB`TL zv-m~SoeZ5=KjckzpRLC6RbsjFl(<`-!kXS0R(88*<(AXG6;ZkDM-;Q=nX_`9uPXoP ztDe?|Q>Obr=RTI-5?Ce0RqQQhUWs`S#{4q>eb~boWeLh+^|D!%#VJct7O$7Rm$C$9 zEtDndWz%I#DQl%HSudMPSqo(;%3A7W?DLt?O4%gJTI*%xIA)|MOH-DjELGYP;iGt6 zHhMZVLQnY5vF>F$G)X$EJ*(r|AeLpmWB4NKUhT)&%d5P=T=zg&G(+gK<$jW{fThOR zkD9wWjJq#aUb^@ zT=i3Q_1H7jbasPx)o+(8PH9Jw!vCL6zZK`sDGUZJdFFOA+nLK@Ejsysi*c$sondgF z#eLiw^1kkD_bu;&Ad~xUb##mv0KflG_Rsvb@6oT)Hg6vLfvs|XFpeHORQ|pnFDwpr zf!B)r*dGdw(xdyUR`yS;r-M(5ynp=2koQn_zppsSDQyd^e1Gsze%S9}jHs_2hB9Y+ z5b46Py;V~Jx6!refJK4yuEwoJd}ZY>Vq9L1?2_L>zrDkl^Q4a#yET0r_s|>8UxX{5 zr+oMhXO=gg=av)m`doZ;dp~+udL!=jXUqPW-S5jjJyss}7du0tayPf+hC04^>Cqt-&Gl zN|gWTkc^Y_IOII-$IE-GZKJ%K`w0HqmHz4AB0M5J4?RT-_1zj>81baB4mbrZj44;< z%U8kAwF>ZQ^ip_CUaMU8H$b=U!VtD%DE!4QSW9lO6?OajmA|gVbJOW-bGgCSSDg0_ z%FTRa%0sW^@2)=ho5Xwaq-BP0igz zJis5qC-CF&0RBciVE!a++w9|Y(2wAF3Am}g=IlDSkGbnS+tqsWt)Be8cKJE@>h07? z+v~g}dHf{4g7|2Yk8B^M4t~7WPNk^Vprwu9Mn3bHDbOc)Yh}w*{s|f?mxi8BYdny< zKW5`62oK>iN4S80hPFCfavKI*pieT}r|&(`&VKd??2mAYYcN#~s z-5y2<^?A0vb6U#TpX8iu2ZrqoCs)zl2Crr-wMMQxk3DAGTy;{pa@7yWsbC`kAHLUmzCl4-UCc`Wuje zE*HK5--f61kHt6U*B(kbd{@98E{mTD*;ryrXcPbW6vh$tyP->my_0=|epQ4B5Kn4Qx&lH!f>Y8E=pVqcW(sOFqwHhaZgayHog81^?& zcm;Xx4O;4UHePrZ*?5Kez1XkI{aMf@K|S{S(SMaKi}scz`F=wy?+uHP6x^1fUZjK34||Z&0{TS0)p_{w37-ArF5+u^Da8zv?9t=?lzFxq z`BKFjmGyWo`pChD;@dE%zZV}W2T#8+ZI^RGIKTm|dt zEq4%|y3Lm#;AFQ(I=P2F6_AlQK0v7~zh@!ii#aA2UFw$OiP3_WCZ4g0D`bxy+EYAs z3N#RH6kE%0%9Ze^3dkFJSH9K!9I#9-D43cbHaWY^lP?gnpO4DZ*@V||`b=yfJ3Y_= zk2!bv@~@1ONJbZqNB7XyjA94;he8)trA&Uzx|<*Xh)KM-N$O#GH05=IprfG|$SnMDeD4$SCG? z8Gk13mC*f)mDRt)g+6?%Dfr%OUo(u@#o{5;l@+>iz~}bS^l>C`<4xRxkfRy*y62>{q;A&U`>rKS6m5 z<%xRv?0R{U@>a@|^>W3Tg5N^9Y*|aaoKJH`<*k%YqP(?U&ID~#o}xTWIddd|a2KvA z>R1JGSJct>breq~iP;2SeTw>4hr=9tT63kbtm4cy*g$;n?hEMiNx_!i%bG%xd z*#?}HW$qV`TJSI9(7eGbE7ujq;bGi;sVcsSXX2gs#(d0qZ;C&2lCu?+Cx1DhuGvxh!dlDKzgX|)7jaY{*eyR+WJWMfa6NuHRWxd;tA;q zJx{wYR1?lNucnL8KQ=b+!kPHC#OfyDY0l+mz-W#i?)XV9emLcX@?+RD#TAM-%vAL3 zsK&%-!s;Wq1Jjd``s4Iznky$M1D6hfI|!*pM1ja?gO_{ z*zmhGZ=^V&o%d?K_h{sM+fFGdKmA81#7~Ub$`$o^;4;pg&?S?{9u!`vCcPK%PX|0} z7`sD$Ax17ESs3sXt2O-7#q^=etNGZnjmm!=_pxup$KFv+ptl;lkiMPHzPz{ev5Ax7 z=q~x#@w$(_7#Ww|OK?uP@~4mc*gwEmO~IFDA6xTW8t<0-3_5zbulWP{uhO5&9mVs{ zgw|okkK2pSz08k!y}@O`jxoj(IecEq6L}8a{TStO-bvyMC#i?Ni*&`Ml-K;*XTnzM zYfR=Si~L*QlY8+$%zfnBde4wgTju{J_pN#STH4T9*4*KLp)3uad^-)lR(adyzD3z& zXuy2Xj8uU!n^`~Mw|)V?wc)d7kfq3P#jaL~bDLv?L$B9k1Y(ycMj%GD9mNPG*IC%>7s)2umikXd9@-?&3~wn^?gvwOab3_hIl zuEo~%mb+OuBAL)$^&XFXy5Pz4%FS)E`Fp}{XHPT+qdW?A+li@V-z;MIc-`jT3$FzG z9@-L~!fBoXFJLZQl?!6zkCa1$9_LNqK+Ztz#_irHXK-1gJ>H+l+t7!0)}6dvd;PR0 zT12#g9)F0fpI6=!F1+U>L9BRbu+7CkbZTqBO_BK!Y&HlSQ@^wZQS*7kIO$gW*UmB4 zZcWT@Tv?e^pWkR@{VDTnzcRm}zAA?L66X~28;bFjUumVicOrKa@do&{ntrdfX?{a> zl6lQo{xH~5wkc%<uy`mF$7qTt$xg4W1{X`Hidm*^BG*8@c-Y2C$;Mq!AD5^Be!lJK~LanjYQiHF%`? z4f*C)_R|5f`9Z~1lqDu=aXR%(nT45PeiW=OOwyk;{=yY2=kA zayi%(x0Y8rZd3SnTVzxAkjvRaE{C;lF8U$L<<#s+yQ^GIDfwaAZnj~&>+LCTr2LTu z?QLwAv%P|!$26zWY_GJIrCE1h6w#0T&i|9{uF){@YjpRI zXis^Ko@t+(@H)JoGlb7D$`=^NC^5`2p(rJIg zdQ8cg`rISAL>H+1My?ai-tfNLnIjnGJFcUw-Eg-sc9;34M0{A9L~|=E*U_e3fB!Dt zIfMN6Tx<&d1%3eQqzXgPKGch7v)$V}?W@FBmva3<&R28(&6r7F$64#Bm7~%aDRCX? zQsA~nu^K!omCwl#i>S>7u{w{OUDIUawI+G4I~47^@35JhG+GCikJg;9t|a*yGLxY^ zmQ_rSAAy~ojSbQ|IOS~HsjrwzZN%zrkT*+pAY zw_{vrJXnUg} z$T&x;*{tT9@pG|nv)QxV<~&{HTdYC5Hzd99FU02*ERCU?c_(3pltVt20FLGwM(D>9 z=G-M0F?)B_#z&jZc>c8N&|WnEAL->qECXaIHM|d_NU)UesBd^ETzw3Shc};kKJfEKb72Y4$iNDHw z>BT(x^!~^n6VJte#t1puUCBs4!hgwu>alm8{$5!*LjR`MX>PIR<|KSY+3AJgn)M{3 z%=<&@v)NZ;FQYg1!Bv+p)(&j(Q}7946uiPlRjj!KdkqGZ(7=qSG(0#L-wH^F?L$EBP8p4dz93aceNCqui(ELKnu2WKLsDW9lUMt+jU=Q|!w=rgdbD(aLw>iRNW< zcKLbsZXG2*U2*O5)Dr8n7{AA)dphd62R$=|wcIn#Ob?b-ud`$!Z*@s zk{6fn22&TEc}`nhr#%5az^uV{m4CR#r@d(}(S}tbPYBG0?zHM{u@(c@lW$otFLWpI zrRrSm!nYD@_S~Ux&I$ef8~jxDcaHjN#EW`=;j7@ZmE4K`YMlML{x)#a%arlXynyGroLye!bBRp7ZqIfBysoMWjWU|?Yo$?ws411zAPqO)O)<7vg zk#ZF)-i^;Iy~H{wcY`N8CR?0hoTjpONA}A$JJ1`lT|20^BS}6kqEka=SUVBPCwTpe zeD1|B5!7r^v>m@W@`ZVB*|NdI=wjwq@r9XFr4Kvkm+F#K1Z-W+Z2CN4GgoL~TZRVLKAE(dHhhb~xY; z{=y}J4>3D|{V?EXQ!X4`m9r-XUu-tEB;&Xf&y*K#<9mq%z-aVklKdv#oovb$h@`g& z2Kd~9T}&9h&t_;7JR9{he1k3GwQ%9RM!EEe`iV{6v>ewpXhbk;TK2548g$VFFYYr0zB4bk|!w9eDzl11P)>$C{ux zw3BZnew~ePoPt*<_gWt-a_^3>2w{LvWsJw0=!_n$uQpW%zh zKda%5Ph!BCI`U(V*Hii9k<6)0;V+q+?AGN?eP-Ms{6`b;Tr%E(5r^Lv`A@|M@`)59 z2*wxxg}sX4r?vF*llxr!AJ#7%%xfL}lHlRL8h?F$y>G@XAK_avPccVxEdRaQ?^S;F zm*eAu_5~^J(|IFDJnA*RHX=@joq#;>UD(_!CpYrZ$8 zaZW&)o*$1|Uo&RlX$n!w>U2;C}ke`lu{qotN z`%?eVq{n%`FVJ^IPiHQTfNi4Ex|h}^0>F4S52;5c{o?{RsS{MWYC3& zb6fqMXfOR%?<;(7QuQ;e#}Iv&@Xo_tUsOL@vz{yamws5Vp_vQco&I1R^&Q~P#TUx5 z{==e;gTRb?Tk!|CRt-mnL;GGHe3ai{GA86(J_1j{RN^gOzC z>Na#g`^*vjWtD$oe?yGE#^D1pRAGNZsQiF&h^LuHihI~E^3GPCIdSBo?HqD~W6$F| znfoV`Pdy(w(fZy?xSwQg_QXeW0)7g<;IAG#{9y11^Z!Y2PgVO4Y>kgM?>})p7Ke=8MAf18G3zuC`hqJ;i?h#RU^}n6rY3Md#bj59eA(s zkD{NnPOK9-IK=*&F{e&TcTafA{J!Y-f3!Yq7PK6TXh{r5ofOZtA7B>tE@7iP>$J3; z)xk9ZbaWR6t=Nz;Z?m7uLWlfC!2|yt`7aFxqUWQ_J~OoVDYU=`d5k{B znI~yCd%`IT`qhkvfpp?!55C13j=cE(*vzY!g^5t6N(#e=V z2#%s5zvmK6>FP(eH&+ib4*1sJu?NsuQGZm!7V<6WU18ZyJk~#fWY^`V^IydBBV?y*`?(3;${)rx~C-CnF zjea2a2fcsC`24@XP4fKF6L6Dk#ZSQPK5&zLYVaC8irkG>+aD(Ph0U5w3@~}@cIMc$ zZUuh`{rTo`vfH;h7Gk>>22zsx_T) zPuWcB+S%@48DoDkzT0E=AmeqA+}2>^dqi~ic2_5p&tUHDsMhIrVuuggw9h&cwfoKw z_hPfy^9!s*VI-XO8sB2^Xx}?hJ*@UUtygX6o*z~d%+n=+sWN`^%D0^xgW2GtHkXpu zn@kLNI9tP`K_B6qfwrrf#{sYtta%d-Q|9$Y{fq%mefzi2Kz$bujs9m&=)dd~bM;3D zzJPyL(t0@7!P+lZzv1jA_d=h}8N{dQ56FWAkFeIA?`@&icLa8OpKl2^c5D{7d;^*) zp7@3bEufQ?8x9nAC{N!49kgDmJvT@kePfX4_cu;*KOTI;4EinZV3l=3X|1D)=)n3V z+4h#)?#QNV-RDWHw~={Ruulb9YtwV2Tg*Ehnv$ zJj7lMs|f8&->Ig{w-e`YuAYp)pPISZ8^ympgr8VjM}A~t-H~M8;oG}0v!@!zR$Fe4 z`K+bDWgY?_NU=$YJ(22j*2eEO`>K|sdY3@=XSl{^q#diHKZw@No}Q8$AR3pz+vBSc3<_uIP*YLo(WF}X3FKgDVx2+tanr%_^|2qHJ@j*KiP8jRWtnF z-rsS*;%jeSYZ1|=Fce6)%)f|l#!0`RTM}9H3i>5l!;EjMJ(zSRZN|!#_aWmM#%Jry z8f~popLdXNmo7lYT9G^3tS3HL;kQ`F{jrCXn!!t z-CfyM6~TycyNcs3btfM+ucn&<)!>bkk6Vf*)NtR2&W8QvzyrzEsir-o9Cv|GN z;JA+``0XzJbdKA%7VMk)na&PY_g@H(jJZUC+|3c(N`kLq&$&Fj5r-R(gANJ$l0|)&0dEh%1;rn=1 zIwaDY`0?|=H}O_-;~+P7Urlb%FDowqH`$qDFZ5);67>8Oval$qjnf6i{-CYU>$QrW zM~E}(^h_7Jy_*~KL_TD{BDu!KymLoguIu!ajk3t+9WK@IYk_`qBYGm&rQKC$L!F-4 z4Z-E;b;+&GelN*$0vVScKWu7pF4-1+FJaA4rih#(a|=q?$4?Cf2a7Ke3qeEtZ26H( zn`k)Zz4Yd>H>W@P?M~59Hc)ytn$Myi5e=~sv+Fd}_aP&hbl23!-i1MHee9(edk4)+ z5zh0`KN)oJgx{?3fN%I1d+i>AHwkC6m!|&Id+`m+gFgOGI@ zw744^%Wu-c`*(hP$bU39=r7mv5slp~fyS+#vtP6N&i{_>D`NZPAHG+8=?%u{Yprd? zDuYq1BHQzAV01lL)2n}n?b*QM;v%_)S2(YDwf5~!>Dfp>dZSh8S__+V68=)GfZv9G zD!fUaMv*7-PUNZE&#vobhgB9`<`2EmG ze&~~AM>cUmPWfkKnmmVm7va|F3Z+Joz8}fmLLWy!*rIL7OsncQ`X4|MTf; zdy#d54thMdJJdMNc={f}a4;YHZHmBWOpJRi^&As+96Dx-gVmV#BzeQ#VGB6R-pyoQ zHHOYtKXl*bd49}OZnSnkK7VE~yMwyevsUKnW5nk2|1=lW>f#GJ`i{&i=oISHCi*1M z@2AGhk;q>BJ${S6W2$@(>kp%NSmU%4Kj&dXpLkzmK)Fx(R{Exx#$V)89PfPv*d6ci0a0jakitwo* zJ$`xRO7V#EM#cKb$b5XGxFJShtXs}{kM)-o*1rQX$lOdtFsEKT z>@V<;3t*1r2H^+4tqVUi9v8qj^|g&X??dF%8unLqAkxM3@!cQBRxoBF+eSafT>9rW z^{>#>Kk2yw{j=8uSIVxr7Y3;UIUn`!B>GpNe+AYGQ_n`8ekbbR^2$k~?@y&4ST|#K zhthSCTzRFyF#j)o(c%J|u{WFXlOle2$iPSRhh%L&zF@0SK65b2Pl{F=OJju^uiA=R zJkjFarx52eh8i>;vj=_A`OC<7)V@ReF5}mueef_gFmw3ijHiRZipCgv{q*_J1D%t= zCP}X!1de1}xrs>6m3o6m9pn}s#EB!O5(7x)9`y$Og6gQRYKt}^U6Dm@qrN^7wbLp& zp|5Hu#r_ic`mKe*>gV*X`o=hw?uvQ(9tZaPbnIn;-y%V8%}MF|obbqex2E56z%HQo zutnlQi}NHgehIrsT$tUAz7oH#4X(i_JE?F%Ap9dfAsZSi4f*&C>(HWcjZJ;TLC3q$ z6nO7GrO%h#J^~GzdAmh4{h0bWa9k&XtL60v8oP1#2zC#eQpVgxrLiWanV*WEq*D&M z>Q9ZgbH8lNYkZhMF}>y#9>mX{Pwbu<-5<`!ZY>?5&C!vtGj|}oeHF3GnBtNZ_yb#l zc86~nWC!u9DKB|^UuQe9@%E}2WxgQ4KkO-uyhslDs9`>&$0IL|P5Gv?%NI=BRsNs( z&Ei&X=?&=X;^*IG9CF&kgVPyPJ!WLuLFbPw%X#8mR&nSZon`s<+wHE&ebX$%n%d&_ zcWJLyA~z5)PeUwtS!EjX|Gk(w)&s6_Yr7|%h%ZbVFV4+x z4!XWy3Lh$MC71m9>e92ymFeZaU~-W?t{&gpMc&f*ok?$db?L{z8QRCp=c}Tx)`?rh zB38Df@3J24fmZXuQ7~-uL!!7XYy;*OR`q({aYVCam0O5cej9qkR&V#d{=?18CkzJ# z;u!ML{w*c^QEclLPjIjCb7qA3GxL=B!d8!YonviNwtHPyv&N-BKH5TW4>`R7w8k&Q@93;!M|DMl>Y53H2=AKaB^SA7e zV3U_tvJT%AvA0(XXKp8^C_hhb^k}SitH*UEmM>SttK>Pn_fdY&6j~ni;8XEszYSd9 z2cHh8pErn4vKybT4mzyuh7U3EiEqW-2cME8g$_0`wqkg{LA0|uNt6dN9 zEhTVj^TDYAPWIh?mw0y;W3af{8!Nj0ZP^3i^b+GMzs;MRW1UUmMf{`}(4PnRUXZ@8 zv(!&u^U<%ftitAV$L*F`9Ou3dzhqK*hc}5Bcj<4VYiu{POM~d~$NhuZr_g!u>!a{P z`I1uk`47UAXq>|j=9i8okBDyjC-~7-I1r8zn}{cKq1i_pJSlF*x2o|ZMc-;X=?|BS zC&*BPCw!mtt$D)uX|co;ji1q9;fbfQBUv_*Wq3loV9L)`O|-9mX~YwFuub^Y_)^1> z+}IhBY+{2~dhmj=WRTGX&@(j!InJ@ywxsoaS5>+`)Elm3Jar+{$lFoPYb`)#iO-H@ zUHHKmi^eW%A0|8eex}FREj)|Qa=HJz8cV-MHdiv1B%4}GyV9=lcDjL|^u>6L|1#@D z@O@ajT7&a8^n5^Ypr?G>!uLNPMlxsE!;7rxHz?-NFRMfjYUXxto?*XwX(XJlet)Ph zoJ(I6yU%kDgb)9|e&Y|_n!B6a)AlOAM;v^ed06FzTC)6hm(#}_tnx(o;QT&bKF7XK zo~5D5{QQBao$1`?fhBu?7PN`aWE}=&Daxe(R}?g#N*kWq;b6Qdf5&eNBY)d{VhiH0 z?S2fKWbAU~EcmPZOpC|2Ww1?Y<})++I}ZXuB_*ALZ=02f}Z0PT<3LlzFd2OqM$k3hokbBzm^EG!hDK zqRclT3al~8j{@UKe;%}pXFrer>t_=` z=lTNi>i=-|E^swv@BjEdm+q%Jl}LqykQ6795Kc72xSW(*6HdvskTEl145ynCQHU6H zjB74QiI5z*-&05~+2@=N$(UR+E`xsWXP=ts^Z9;0-~aFT@AcZR(_VY;wVw5?=eC~b zS!>CoF^5Hd2Xi)w&BOUpg7)~uUV=Q}oc7Ez#vaLWa>#aNa$f#2vI#=Km+%2#?-Vik zCjjjRpbkbpjU`_t@*xO!(9iHEGG{d-nQeEC7Nk{>z2pk{ldFCN`SR`DjOHToh#vTC25}yb0f&tf;F%=SjsOVpPyJSSJD{3hufaYun(FX>&#^EtpUGz z*hhqHSy!Sx__F|EERjWM3d8nu<+#bUe-=@42zG5_J z6lc~bAmh+B`B8Z|gA+Ke%^$c5KKghq>%-TFs_7s5B?> ztbHV1gwu;m&z{PLg+W`R}{ld*0^ zhW)+pYsDn9xqjsuC3HcaO}VBEekm3kHw$Bjjr?|%RtN$@`pdDt{Bk97e2 zC~J@3+!Hr6Cw*>cFrI9@1ns%q(9FWKC<%Bn`-Y|n&x&1dXpXMDp*gnrhNf^f-k*f> z;V6H8Lz8>;h9=J(&mC{jdDbV%Hiaxfz7pv<>>Z1Ilsx#;$v(6L?&Ba|_C=>c4<)j> zeC)A8@=ZeXCd@IC;in70cS;7dnGARXwJJuXA-Fz*ANDCz;ag2)f5Uz5U>R)f)f(a% zS_?}u39cW zg~5Kt{I$%=Pjwsb-iB>|H}pla{)l3w##OmmYYI8e={d+R3uX=My_}FZR5da_wm@2nlp2`qY1^wIxtmT-0mtBUQC;I6F*?q(cd$_@$VZ^93 zE0MdE*VYgVqx_{r+#fT$t8sS9&}YJaqPhhva*9~w6iJX%g!vb50eqB{KLlFHQ(w}Q z0cQ-xoEHuGD#QNMpbgBkY8egUbKN0NS;#%~9lkmCsO%=_80XcCk$Z#ssBR;YCp1q( z8+1=PlG=g35WvRcd}v51Ge=(_(})MLZrL-Lv%T`vE4aSe%2ak31KaV?BYQ_f*TY|S z400T0!0%X{4W5s|vjYQ>*94hIvR90<5h!!BM46g+KU8OpvTsnfzgZphy%oxlqvhy^ zn5Gc(#ilweQQnu{2VADm!N+i}Bo`Y)IqY9Yw*e?;;aiZAt_#*#pxlGr?~Zz)tD4$1 zM>*_7N4J-NT}H9iJ9s}(XNL0j^gh9jao}>}QAX!eWTTFz_DoQQxtnA5AOHHjG0LH6 z9J8$mZo-$L4kMIfp5mB2n&{MkE9$2ZMEl7STFVG|i8IZ%;GTjj4f)2cdGHH*kRJy5H){Bd zur~zuRM*iZ_2KPso(ESADcdG1K)AuQKKT&6d zd&oJ*qN{WtN^*~*=iC=`KZVO3g#2+l+Mn)&kYlQ{Lkz&tNJ3){J%_O-StbE2ATINw zk=S<|G()g_0FJ4gkwD%;4!YBM2o%$q+vvk@q_wr=gKkD^!e+Ea{!j8_I$LDuU0=Wt z2pt9cMaz?{;bed3QHk0XIERjCkn$5LPofKGP)M>HGTa<+(laxuO7k*_ad+MO0&FL&@t&5^g(w-0>37{;mHzNiu;qU!P*P%JIb%k zS0@;9YeAnPHcnftPBi4!GN9YhhWD`+M@x1Q<<=IlhFo0Yd7{PPZSkun8_yCCQ zr|g=IYQzy2A2pI`IIEE;eF9AA3k!5EwzBI{M%m)KQYA=$Zz_$ z9~H5r=CLKpM<<^t$s6DezG9kBqdv%#BKT;z{1V!~9Cg2=cn;p<;yH{VhlKOHLpE{i z?%*3nj_SYqoH3^4x3;0UM-7cthQ7NG#bFXP48>uI#;jgNMka*im5$4GAe$Gj(s`?N=U zJitKhO+kB2Z5dNrOrjpLsa64LO1|V-aEOYqAGe6Xo?%?hMm$S<^6yJwxbsWKF)AJ1 zx4=6sC~t&OXz4w^c>OcjUeD;667T+icqI=siit>VI-g+=;g{q!o%I6#`X|qx&KptF zI+{>!-+rQHKF-2{Jk_+2tk#3abU|%bYn`z+8NLs_6#UkLTO*}}zd{AuZ#CxntDzfK zV~y2ntkqhrcg5w7ONz?}moKg;@oK#s7oBfHaEP1EQz2LwR`>5`sfa<#;PtD%4D$13 zv8)8Vk9?ODg2xuVA|I?lqkU)Td=)#`lnn5KIH(@64EVROe>m!QKt4UmE6}-y&Zyze z1%ZtS`9-#oqY>KW)*0Y^ti{6~?}0jQ4}AsMSIzg(X9Z~6ToRq3cTgmv&I!5>;13sy z7vLM%#^#-_tKi=xzJfdft@pt=P(K9>D}W!^oMe|X#+s2uoW=BdXy_fvWnob##p+%GQ>6r*UsuhZvA^GlKY}SCy3WEe8@83R$~p=DK1Lm z!(h(m0Ul`1MQ4=sLjP$!BE8piPyG>~AGH5I zjS=CeseYo{=4bJkVx1MAvD4uj$~m`@h~w;~(pY=EX9HW7qve137Ir_?N3bzi<6#Nd zKofTKzAs|$I4@6&`(D%z^#SkN(HWdHXCV4$s*B>w&I;*-#PB&cKl6p&>5X@UYMT2) zJ}H6!e>;1o>0XFEd>HH*Ky)SqjWg0UXd8JpjA0FZUM0?Kk!;ilS*<`n$I^VQUnk!c zT6fqCSZ}0(JWr7$2c550ut9BMFG&?Fe15Dz9m|fyIu<$ButXtmp7gg!qJZ5J%SJKS z&z$-|x$7*&Hj#JV5pou7ZbW;)C(brV)O#tD^n^F67i({7h48b`J@wTD^kASrI=7J3 zQ8{;h3(gVYrGXDs&2UfWwuYeegF;d7I^ zOIP%E1?&RMpJB&uF_)}l`S2-u;oMsR>K%qUUGcv=omC5-AUuks$=rFSBFGqOUx@ci z(7rF;MGTJSZ8(D=Q;+>@Ir~Gz#-sf?tQVfUtCBh0$e>Qd^>pwNJ5rs*|3r5Yc!z8j z`Zf&zJ4iCYTXKqdm_s$_XdR76O6@{U;yr;lifxPcIGkeKrR)kl;gWpL&Wa3u7JfzQ z3_Z~~!6^cqw)8&kr82zBtk4(Z9T&BMZmjT5TjYH-$s!5KBESioMdO8c*8*N=HOU4R zwu%7{B)=Jj966|?wERXH#Mujw8_sf~({YXGW6}SZ>);(<^uYx5B4pV0Z@IH^GW2cG z4&ry_zJQm`JZdAs9GVqrZE!Y+N%VCcomGPITTkcG`-l^9u4E#{O_e@NnwWt(-xkQM*ihjLR)rNgux5dWw42+uwYzLh5GNk@^qK%F|&0X?qbk$ym(oZf-m z3)zJ^8}xSL*xOP61cVQ)V?)_`vK_fxQ>m&WPb%n1JOBk^ZiV<0`H~v&9>Gj&Z4l#v z{-m?8{`ns3!)s>&9^^dY{9NE#I)&P@V=z9n2OPCSb%Gyw7;l~gbyGk8hD{u1fDLxJ z0XD-o9Bk-2H!o}k8+4U9BY6ba0{;vJ=gV%<^K&_V)X~`s6sw_l zj5CeH>$Pdvf1q}#kg4qe`ru<92n6bDPvSlamp!g?0;aYazsSSES!hh{0$kWzwYC+? z%@DW8{H?Y#erMwvfHH498-wc(u3fm?P<9*73UJLwJ(0L(;-WQQVHiI;SAv)OEp$a$ zwRq!7mSQ`m@G)7VKd{ZWG^ows9}U%s(^B+v(P!7TS$ZeJw>kwfjLw(9*#+n``FyC( zkyI!AcZND28R|rzsZPofqB`42%(U5jm8PpbWbNuW?XX)kKTp=SlaP;gHQMHB$u}v) zoQ3wVq}Wubm}1^3`Usp$({&T(i&&3f1l`sabb+y7FIKD8&tg(C09OV&vn8R;e}+@l z2q*CUU*T-m2xnK!9U89lwOxHzvkf9MEfW#Xno%BG8s$I&2MWXmffoiaNz-sfNE*pR zI$J4F_bbr{Xp#|gW3S=e2c5!RaA5F0`XYsnHS9MTq}vaAl#rh#7kjT@Jj8hBD&2xJ zn`mua66zyalLT5z0X?PYN!Ky*Er|b*BmYZ^7_{mFoRiPb4gGSKZ$j+Ppd+(|q$BD7 zMjc5!1vuQnCpLpgN7C6@;6F8VB-JB@|5~PC>721&gv=Hx1K*B9!5TwPelLWc#2RAK zQ^w$10p$O>3Y6hD4p|Mn;QS<03C>WGDj^SO%!BQmr72tv zp_nC{PtnQHR}py50q-{HC;kKIJ>Z=1ZO&||@x?O>jE|E1SCDgJ;EnJrBRL6Jjbs~0 zcXB=k+SdzoD4_Fnd5C>byY8sxHTGz5#W->DT+9lvXRFcgm^Vt)1V^Z@tCz|K^4k{k zBYUv|{4Z*$vofOnC!tdmu;)Q13}7dIQ9`yjpx+$7h)b(&hzA)1zckUI1a*idR5#*a zX)EmcB3s>h;G5_Va~d7d9nlok7uCEzNolohv-+BNx(Ut(iJ2|IiuoJ%e*6bkife_S ze%jxT+7JS6t_{Gv5%L6Nfwts26REMSgBm{7^~iNmT(kr4+5ZLq5@HHE6Pm{W9<0Ip zN5-hjs-2t3m~6;!p4dz)NMpe3DbP{an-DVb7}~gss|Z&iu0yzpHWz|-0~+}YJ_&Q| z;iQ582qgcVt~<2@csV>u9&!C9nM3&z4v;^PJ1IOh?AG>Z6LWq6W5)JPS7~IjEqY@` z7-I1Wtc*=TJ|*#Nihd&SO?)C}x9Dw32u`e3!8eQ_#!rek2vZK8sd|7hC|RBo@&aq5c;X>i zGc}LJ+EmsQcC9;fkW_{oC<)+Dmgxl?99Tn(SRCO53ZKKtbI>WBMMH6aDd9#|UQPIE zfid8V%~((6YVLd>s?!Sm##7#Igsc3SsSG?0p3jrrCR-!LSfOD1g3f3TAOoD%ViDgS z`mS##<{^0IFH12B5T_V{28?KKW9nd#zoZ+GH^-tJe3_(|5uY%`J96Dwz(;b+AGj7_ zUPAl*dkDxj2hYH6h8)#E4kmg@xGRGvRwxD1FeM`mOXD-~N?d6&$Vu8mvx9(1p%_2e zPZ(!UvSlUcy9{GV`%nucxCj14kXt-yX*EwW7PijW>c3!1$j~0WLoi|O5NnHmQO*PP zWf)*&)C8YOV*}Wm=npU({W}e&622vkG}uV%f72l9<7kjk>BK~XYMg~5HPE0x+9w(m zV9fm`DS8*c;*K)v4}%yg^@ZkgEurH8Q$`MS=t1v)^qW9}JpllpgCt2`gEd=LX`o^7 zEt8g_m!Ur5UBVN|x&8w9_hi5a#uj|-X#t!IWcZb-+LNy$l=^`7g}{?DvrX@K5AqZD z^gXAeFn1(;5G|9g5=bMkZZU$DNmF2>#jzH-5gaTM&?wnX=K;?w^d;25x0;r)t?Mtq z&jpy3knbcb$c}B27rxDLC@rhDYbGy{L&2KBb|AWl$A0m-UCwEs^Yz)_V*%^|qElOp zp*dtv8rDDwS+oHj!8wk=AN;Q1|9EiDn z&hzA9Z+zN|f_NM@JICX%z8HAipg+nv{lQ4gIKJjLenT`!-;peQ4IEiRkFAlWq#@3| z4l*zuw3h~4rq5ziGLXNpMU3aBpc5PXcET^#iC`}FkE|`HHUT%+CS$Pis116jQP%eB z3z=dp4r7<63A7gKm0A*Bif*Kp(JaSYzo_vV)cxY%^h}= z8y}hzk)KwH@h0BR9fmPyktYf{L}LeDs5NDYwx{UcVIMq$o}_(N7{}MJc}X|yZH^isVSZ?kUEnPnjAc_>pfShRYK*Bmh4aHvJE_zTc*TI1 z+lF?)2ZWm@T~78D@ipz$$MH3Iz6I)b#(0z6$iw~w|8Cb*(q4pwZ}249HX`8lI_$0{ zyQZnn(B-@aUje_XZ#>iBZpMeL%Hw;*GstIS9H@U1*d>r7*HGWmo>_VcV0A(t1dM@R zah@C}qp45#u&I|z9IQS zbsV7YSl|afGT;yMg746$DY2F~qazr2;IU?`6}}@HXXso4`W9o$u=k2adPzFSp1 zV?`7rQ>GXRfbUmKTPm|bnHXjEuAm>{1D*`?R?Z*nr!`{*?7)$b1<(&IK%acl=Q5mA zK=6qX9|vvF**mt4y#M+$V3dHCnrN<3Uh-sStk>_!++5BIbur>Nt{wxdWzVP{%6FnV z5nD;=E5bW~**GnVHB&&ALuX1isJOj8C4f5zITAAbT8pjtcF>JYdj417$QSX5|1_3E zY2Tn&hEc-_J_`r^xgzOUh6|^lG^F8v5q=f80`R{nejV^j`vkFgUyA>|v2o5Zl<&j+ z2VA)*E5-E+ml*WG?bD*hc)B@jr(o|rqRT_T2LpUc@SMhu=t!iz^NfdBw81C4p5rki z$ZMHo3+7nsA#1S@4Cs=tJljXcq`-8UsIy>#ZQ#%BCkD^(MK-!w=s(%$+%xDmp<2lj z4Wxg@nIou&_CKLBF%Zw>Y)8IGtb-%YvB}P+_PG2o2^TBSpQW`MtU&9|u11~o4e$?I zuYj(#P?JxP_#E~;Xq)COZ~rpPt$%DBZ-adK&-3*{&j;YsAkDYHNhq%!H#Srsoykb` zIY1{pL4DLWS`*B}Gk!NaEd&FH!_ek91Z@!x`OR?XEdB?F5@x+#2L8gF2R0Sfs1OdN z{~3qv35OhS1HXhrNjyiNGQuJ1p#95fzF|T*1fIxlAv=6UGx;t8?V%4w+P@mGCdnY% zrOk07E;G!ZFdjtfP4k^qBJ9Z|C0_#0^1*xs_Msq$ac0*7CJFE$2ChX6cpCDTk+OCa zZ-AVKE2gckEAXP~&`wW&kgo9iiG)ga9c*RVmz05xx&w1Vci8Cb`6B2ixuy;3w1$mB z>!R}iYH;kj4lx)8XA0wcT3b)HiwgdUSGI<+5yEb1?nj|9ioy5@q^!;rGGILZ=gaZG z9C8)^lWjmY#~T{MCcH7ACkwF-^9Gy&PxkP48rXB5f<~JT`6uSoPwF4}?8Jy)knJME z|1Big>sO4ujoE3eVQzvvPU$=)Y{PV#=aUR3ot9aSy#&z@!V`@XU*xQN1RAF?CHt8h zQ{aV>Mqn*UDr7ds543X`IQW}K@UAiFn`j=q#?kjwjPKvHNc`N*8Gc5?xDdQzNvu8b zmJ#6_G;tp96R+oi2L7Hm|F?NAa3M=Gz|kTt-X87PgXZl;3c!E8rBxJ zp&#*`P%>Ogx^E=#8jSbkVw$5GaERRcT1zRu$1{k`TJq5}`9R1=6OOSv4SJ!yy2)oz z`l-RZ7;TCa244=@`o? o`cva9%pzrG2MGC?`9MhxvyCo^gI88DtpzIpja0Ir$pA zOY)Y++C>s?U&PJt=pMdPiPGMT;9+sjDC+WpU&spW7*So449sCskHk>VQq<$Z!f%9r z5Y5@aPw$HQDTX9@MQ|ggDuu5_nrbAG#`77JdohX7!zo5XL1U}YAL?_{+$90yMlzIg zL@aAI^jUZ)42g zV9#h#8uo$(KABux7++`5i9`W=Di`a(KtDp1lP{RySPmFkHG}DA-2XTF8{0^K)EA_CC^WZN3=mb9OK29f~Pay=ub@*hVo4O)z zVSx08ejs>Zkotz6_=4Ibp1?TjJQ~}a0$7mO`7d*W>!7W_?WX@SH{fgyMHuIQ@q-M) zT!bxdS*{U4ZVJ?K+OFUYI=84E{L?fhj=&dB4jRW8k}S*vyn=sg`w+E_G2`^3x|H)Z zksjdYC6HUNOaGpim?#8jYlU_v$A^BHW2toa(H@OE5A;X<6~NA3U)J!#1$MtA4f>rm z$N?9O1JTJ>f{y`AVuSvEcBkP5jU$cKf089n@SOSs{ln22(L$4+|Man;_IKB2W7AAu zzr{1Emt<4(vEWNox~r&@>Uaix(7b}|Ws=GCjObRZhA&x?%K43P&Jy^=K)-6#$zzdI z5(fE&Z(1lIOB(wz9)0Fyq^PwHydyA!&ZPb}hnMV<8>oY5-3dO=FCQDsgKnm15o^>% z$x^hzkWV8qR#CW2flqEey$0vFGKTpy^oxd@ODjRs!hfAhzcTv=56$OaN6?-^yan@f z_)8!sV$~_E9DSb%xfdbXqK}4torrlm)y+pcP4&k%)(`n9Al(TXGI|5MA-LZ^{LltaSEAP40{m-vN#GHQ%zGtzSSLbf4?WGt6Mg4`9De&eCztGuxC5^f6j#dSE|nPl*)3lDM6QxlIRV32W0}A5LOCM;FZm$ikMR$T{R4CDVCX;Iba~wKX{g>!rT!1Q6lG{AA^{mKjZ*UrP4Wy>6=H@Jgo7j z{kv=vlUc#PeQ%1jR{n$+_+y&ts-yTf;K1C_k#n`B=#pWTjpO|0?!SYVKcUlUVY>=3XNIT@u-| zTPQ!s8SVDyj$hD{JH|f>Ypz`|R_+)_6Ug#l=q1WK8i^}dourKxCjkcR9RZ%_d}jFG zRZTpfT4O0N=!;#Ln@MoK2+3b3HTkht!B!@n8V4DV{j7oS|3tr7Bked7&&Wq*dYR<; zV6Cfzgms6Hiu_{-fVb;zs8@}80Rz@a!pDtzkADs=DYu@-A@X`8v(2U`^BuW1i z&mnucd6O4lb3h-3khfw6vR91r6Vzl|uhAQ1K&Zx7vaL7eb@?c97NIm;>I=C>c8t3; zsrPr-H`_sJutiCpi4~c85!NL#$mQ`>V2!67{%Dl>%5m1J68kg*w-?Elg?#f#Q1Oi9 z5l~%8Mzhc-iZ7we24!ND+3$hO6)}iML4Vjt4f4fQ&1Zc#q_Ac@m4?=BTagbc4Qo`@ z@If)Rk^7AGuZ^;X23K>pv8gpDuhLhZGpmA^ANEaAC z9*rNy%|QyfApAGd@>1Z*T8Z%k-l4Z^t8q?lHO}lc!#C#aD%KWwF;ig;c^c+jEa(z- z$W=-DiD^lwCrOWZL*u*)aTokg=gdU|7hY(C=Ez)bAb24jeW0-xLKpmmHho&a_QCiV zDI*{gXR|WY>$y^;8I1Ap#dq{97~=)HK>P}^eAH+0L=yOSKsS`DWvqx` z{m~Y!r>6E~@+5BG0+LU3rU>yT=@!y4P5K3A={YV(pCq7H3&iEoR~z)xUX0i>#U5c` znajHTcm6cSw-&^ga_}zjL^>bxT+g7K^spD`iSR-&k^SJs5}gAF62xLKPL#t+cFK16 z1=29Ch;>311?uQLY~t&-XrJ~O0Ifk58gx+r@XGN3^bx(&q?719(n+L4sL#kH`j7e! z{zk{afR6{bG1ibnL$s!84C@10m8r1zx;%_ElclgS8POlw0zJr4ZfAyfWiqW$ZOV!? z$PpAHCJdjkImLv*uT6FVa?uR>SPWk8OZAsk^JGIfyMT1rzkkp1EAT^O-c%R*`@h-+ zwxDx@iQpr?* zd;@*P*)d4bI|hk~LP%WQ{pw4S3*xgTUxiVF26%tv5b;9Jsxd}cM`dvXnYiCZ|E4r50$ z4Z01!mBCsb*<@#F+#X@Q`6F)3;HT?{wKbd#$&(>Qpr&^bzsJ5q)PEa{8D|SNe#iA0 zIHd8SI-14`If4I?-Y6zUun-(@uh-K21a=)_e}TF)=%WpO_uh4uIt1JG~3ID+SI z{3Exd(FUUDWREZ5;u8P6O}7&GA-t0P(S#?$s}gy&Jeg9P+Y0eL(D;#Ne8&J!{=j2% z{-b@_(Z_xq|EXbfH}Rho_AUeeQ6p>||Ed4)_%9r=@zlr>A^wA{O}dcyk30JS{6{$% z{u0<>Xv-b&8)P;121Q(+$3#KijfK8rwj9J>iJa{~GU(rIgD3DAkSry+&cJpexkCAa z>ws&jmt+w6=s@q#8Mr5W!_SQTPmPy!TcVeGTLvQuQ{p}3L&Pfuj4DeaS@*fcMttFWV|Bl`rGLGaS$;ZEC zqWT|QHWD(J;HqL=VXO*5qz7(1Q?TO7ULGDRx8KE*hGjt8|kw zW`brk>e(nK46^w4-*W?wM$x~n&1jT#4(T2`JG*D&+=k{IEXIi6tWKIE{!RDD9ciMi zCb|c2xRGq9dHjE}H>u8RsFP^ENv@E7Az!>wl?30{1C4-%U87o~bp^fgVP_vE{K6MU z-aOqs`0H8OHmS zA?8N0Hj2ejeC-j+LUB>-ttmFwJjTXIHo^8Ct3$p9&WeIw1m4M3cU5oW?4yyO6S9Y* z@N0^B8pV>yPAB`k6JxN?A#cqmGVT5=FE|sPp?4ket4PE7(kk#3+E^)0VvW;OI+CGH z_7>GWk((EgzY%m;rsT*bI@u~z}NUjcrP z;rfG%r6Hd|jlC3_R#oE14u_OQbpbNf*l;+?RUuz!pF zFq9Ryrm{et1&cB^)t>CjqAOGuiX0h~p$+87JDz+_Wv~$&+wehIp&6B7ElXn?y-;?n zE0vAKeA&Gh+1sVqom+}H;A%Q3I9U8BY}Tu_$V*sid#jdmz2t}(O=`;+SjWS(P@ zsi9qa{C~3X`EJD2TF6Nbs&q2YIU_|JL54g$tQX{o&*_Dda~R)qWEbm8C9t#Av#@)A>&RuP+Q2k0PN1d&kD3t)Yv9y4C}U2?PF0^ z+z1oFiM%lTr6|j7>^FRk$U{xFk3m^pV;_wg>-!#MM;mcw+*sdSlpQlO^wFfTK8i0F zHr8j_Sl=|1oouYntg$}CxgCod>!a}__$HyOxUoLiyc~SNC~Hm+1Rrw39rLbIyP-PE z#`;E}>}Vq`AEt{rECE7t{3j9zwy#&b|izmMcfxQK9}RUJMK?5J`cuoSKJeg z()Sbb+y(d4Kl)yX=MvoKq962}{D#iBhYr-_f&P`uLN=6i9Nue*@}rGqv|k*RA;vvI zDV+|T8>F-1F(-dQzi2Hd<-N6^NNao7uncq)1Nu1m^oFJ*;vh7CW#AVm#(f9;^5J7( z@J-S98yZ^QX(eCD8sVD&$efP&&Fyjnei9{Xgm*`RX6c)}XV?pcVlDVi4nA*>-(b9t zbEVj$eQs#z`(yZyz8A1Kj||^TZ2VS;_vzchRyQ>C{Ykvv9M(`V+BGGZSF=`^0T=3V zuK`@h)8nJQ;t4l2w2xdze47hd#)Awx<_dXL19|3fLqj@44;>zkoMxZHJT8R8?5Yw$C-2R28Xo*C(5D%LVUtQ_hCE;)i`*yV z8q(S*7rYmtK#UXhaPWWzux6hpLTnEEa#G(A-vlqgzKI8Zi8lCBRsX{0KgB z`)J=!KI~#Xf&h&e*G*h$ zxX4CyPD|7K!bUVjT@%^Ouyr>>Uc+A;y-kn2ca6Oj#z_I2wG(ogW$??gh&jnA&jGPv z31S4k{;*Bvu||*wJej|ia>Ru25AwwD)iA(A?q>Ug9_ z{0F&ENm{#Bh`(TOLE9BL^HPEJ>Qc}FV~TSp$ZvA{nK@(*PhEyFkn3oVI+N%qmSQ=W z`#2_pk7bNlmxup}-kZ;lDPL6p+AvouS#wG0GoJVn>KLmvi4NoD&g6?&1lkkhd-%A_ zttDbD@JMrabF6oV9sFmaT~e}=_@Cr2;fKeXvOaN$BSk00S;-Swljv}k`n4T$%pJI6 z@Z9Pw;&^D=0{e6FB*=?q%K@ucNAJ?N7;yLs#S||!Kghvv!>zOW7x)=I zr242XF=L~n`kLwj{b=Av0ql&HV1^vt!V~|gw@D(L;;f8j{UDg}zD{gQxC37!)+mBM z+)9o0Oi~5rz@dNFD-=hieUG}F!4D!9`B$h%4WGu}b1AY-;fEkU{3`T^<~3H3n+)iR z)@j3*js@+yPD+Acn#KCdxp>%2PoSMeM-6R#)@eyt$D#2Dc}#ZgS{q1*dGG^ z@ceL1-wqc8*))tM!XX9SEU|usFq-6sK0C($5S?!lG(N^R&#vCQ^aW}aPQpKQ=H6z zC*W3%d)P{R;FDqSKjD_)aGOGS%>!M*AJd3en;34_O zlfKd${5Tpttz!|&*04tMd8`n=D6El1JS0#ff$rw$2C|2AF4-(n!liT`OMWNVDC~U1 z=#1pyL{H$yf31^j1Jb!h7&D;^-!j`eO~c-*^e*X8I?I~gAzjXsYS72A8p?qX%3uS_ z6&x&t7pVmApiQD*tlMG7qD`s;^!q>Bq}aI&@*jBOZO@%(Tw!xC5{v`lZ;^PmYXrj_ z*uQ^&bKeE%kMZo@vpeRg+}}p2NsN1#)gLDV%{I3_Ki6b!{ha9DyQe+hnGvzQXYxa< zU4@Spw|#z>O|C54)NSN3v(rnDEHm*ae3stkOj?Bac$+tp+&KXYPQ0!1D^B?3&I896 z)sN=}7Tl@7lvo}=J~PTry)QCi$;a?7zh9Z2GA5MQqB6>O+Oz@IpWa!Tre2oJ>pw+2 zdt|kr;_mkgX8v}&THrhEj_}(riI!!N1?Iay?JMXVm6Z0!V{4w;& zH@7VBJ(@J&_JM=a%Fg|msz7C6#pRY^rDqE2kGAi4K7ah?jFY#lcb_iYUdVSfO*WdE zS1G#a^4#J`($e`oY(~zSc%V(#*#RCij-~lM`pI~~Ltc@jEYnSVw{B(Pkp=Avjv4Q+ zK9kk!PGQY&S4@(ZwkZGkkWjSZL$AGz}o1!Apd7;yu)(1vLhKEHt-ZDo{U-cYvLiqA z9d@_&a7@`Y`_2!A@hu-Mw6&O~OXwf5Vc?v(mit2HEU~y{RlTjjY<-s;#{9^3lVAMT zTfZvXX__?a4X^Fj664vECxpMhHgmdifp=8vXU389esa3=mF-r(GGxgE@%0gpXU>0e z;^W7<;x$8xkGHzJCRb6j^WME>>u>KkUvl4P?3*WJUe7#rd*+0qJ&%nG27T+D7x18) z<^7RP=7;|rA@Ei#5&E60Q#={>WahrQHS;_d7tbELIzQ~1WBiOFRoVPb-r8AXGh#&7 z1;Z>(ooLDL(4(`_xZ?gNFSuHq&RZ99w3~2Fe(2tYiW1LTr3I_DSGu>!sroLrB;wc3 zZ>Igeb?2NP&DYQ6XB(Ss9pr8GB5|h4_jVH)qqq@gGFmJt)aGX zb;H&E#xp`Kcs32&r>~uz6aJyRAu{ZnTTv|+Y0XuClv!2;#|uZ7UexIP6qU;OXPgO0yl{f5pLxI%!&FRxAB`2>+ z*XIZA*?H8($h-99dgF>4T_;oppP53J6(?9Z7z`9;=Hf7k1g^JjmF{wXKYvu|C9o5bDB#A2?Gv+Y~& zp-=KmCSP0-9Q{%{J+l7&TenlkN<4r2G2MBkm&zpVucEA0CsPxw7FT6=@~O-7ZCLzv zVR1msoL`(S`1!h3O*9&__?7>%@aIV$V@fVM2S4Pc*l&=XvPzAw>A0t)(&voj1(nap z`cv)K?%im9b7QKV8FM`}z_a3;RpFoJT@BL21W!J7(mqPH^WLD;JK9@6i1u;$)vx1#y^&w0KMi@h zw3FGj2@yV}qj%<{^R!th4(+e+?WOoqgA5_|P z=(4|N#Z1@!xp+{I;{h(-KRB7S>Fs7Kd{Y$kZGLLN*yyV1i#_X>DZaja`s_@}m#<6H zOYaU)UAz9tJ0<>=GmDYu6!ymOTLyP9y7Uas#R3|&>Mp) z=dQLY`C*7{$Xk9#zuL3WQD>EYG53d6cyBU(>apfR0kbN0Q9Ru88xkDZx;woK-UAkTPJT6oT?+d&2ET3)DsJfXhs{D!?Hb$2&b z{`tJfBxhf$^YO?k&#i8CZiz1!M_xS`5M4gsY4V5eZbLO1@2VLplMBnI1=j?3nErN@ z{%szAS4pSA4o={ZvzSz2N%C)PxFlgzd(| z79CTMU5-|5Tj_TyVd&(J0+T2o$Mb{iJrk|0TnA^4nJLH)UZ(!EcwFqY@R98<_{2`B z@0hu5uT}n|jrRMUm|%T~=a|o%!^11?2Q9wYYK&(1_+_8u86Fis-*LVkZkLkkG4|9( zuk@Nz?Mf?E#=pN^Hsw&s^kMVT1EPAUf_|*=w(XZ~V%Bj^u#0K8>4R*l7w_G;JD_Oo z45##6UEESmvqjh5>_{zr5nlC0-LdXzcN+4M@&N4o4?o89TFXI+;o-+6Q% zIV!y4&s|g}W zr*4UU|7_xdoJnmLZtnHyd*@E;W4etA{OSAGt$z6C*SkM1dbD!cm}B2AZ)s}zOZ)I! zOLzUCT)e*R;6+ze!X;m>Ui>+?dr?%9|FXGNpM2&&Px~}4YDGchcfZHX;g9v4)!XOo zY}4h3!w1>Voi^h@x3Ivo&lPtn_Dt8Ej)*uZ=rAL7Hak;tts_C}e(2#>#>4&`E&JxIOPs%d&l`RVCtAzgo(><}X7#Ee z@>#EgXYzZE8(8$?1had`$FEj@2s*XD-&k#nrSiMWiUVuk@1NxLR` zrN5Xg_^WGZ$T#z+%q=J>sy|Xe)Ow)P?5zK8>vW`mE>7LcNjYl4_q3 zo$IV6)qjlN{@d?i^@^9(+8#CK$uFO$cprFiI&^mJt3takm&$H`-X68-Yqs&Y26wUJ zC#NO%{~COL`^O)1LO%pNXWlN4FL~2>K*B4V2}56R@H4C5+3ni9PZ_E2Z#0bgQ!#l_ z<%B*b?^~_>{GhLH;KQPK3#wLS@=R`j(pX}&TCjL6*LYEC&&o6U(aB;ZI;nMZ-6H5N_%{cd4T>06I8XNV#!=tWc zU092ex^nrojm4E8O#H78nY-eKW4Zd4#|i#T*~Y`^F`wtAbsyYqU2E6p>$eWvv++Q1 z#HKg39WpK`*$p2q6=mHzv~2rEJD;sP7Ju62GQS|x&M0Q{h*O@w{&M^67HRL5sU}mu zT|Gr(xn}mNTWf#crc8PGe(L1EX>MEP?FWxygRieon6@V{ zv7bY$B+Kvbu27X~vp1cT?7JzPvH#<|T?dvfdXe+3ZP&xL2j?H^bn(zZhuGJ9d%Wni z=cjQ$?(!RSeE0dTA5?FL^xLuj%hH|OHWmL?y6}9#v)0B(i}%Wot-KL;T=eipUjHN3 z`Qg^XkBpnXDtA_gic?bq>`xm18C2-GHT}fVl&Ye5*7@{q{`^bBUrvAQ3`)X2R z(kA_Y+es^?A7%SJ4jHrd)*#njF)PH?wYr#zV=eE$l+8L5_+iI~Zm-T~Z3=Lcb_f|W zVY~Lv`NNm5H+^^Mm%XyP4(iWyN0(;x?smLm>IH|5S*qo3U0M(Oa&oD}kH2nhz4(1i zz`g+!Tl_k4(7ukx(%N{Izu&QP&aIzXSns=fP-C*ZI6-mFxGY*V<#;RSr;`e^>wTZt zk4$`4a+_5yn{CzO+Ru>zG3S1>w!C&}){%u>FA2j&stPOLWzP3cYbgJ`Og`fer#=tH zkLq&5%2j4`>|$N+uARvuXUE)!vCAuF_Dx?@)~&wXy!C?jo%_#7+Y+BVs7LzCiR-%t zEBudontTvF**B`~$y=}Y{QhL!*Oi6cht6#EYcM~$%kQTGUM;BVG4hI3`SIbnXWvZQ zsu~pe@lt$wt6AP>zqd|Ve67#q>KwTyRMrqYx>IJ&p9_;$<+QBp)AEBXPPnbhz#^A+ z&)fSg8n^jy1-t5MZfLLm$0og;a$7$xcbR`9a{g%<+w`u5lbGOZkpO62bxnzB#QoL?o@j?Ltm~>vH8aMk5NBOTlxBCYG?mPHGUr=0vGrA z=+$<;--9EagU;OB^5Xf$kNK;2d}9%A^{TbW?2$W)1Ap~>=-nlu_vUpQlrH@Wk7d{6q!z;@ZW*O%NB{jeeI#EjR*MpeZBF(%TD ze^`aNZ#D}&X)^bG>*zW4YoAZs-FtgP#!jn;$vqc8D%{21ecpCcS!J@>v60=D9a(z% zS)qqX+L<=#ZH|j0=HyD=ygjiXAfec=%JIRSU*@seFs=J<%ned;ga zAD5&|zw&zvUg(%<#!;1@tOra>HMM-#f1c#>$l2m4cNKoszs+3my|1A9_P4@2!^$iZ zzw9{F9 z&yY=5-AV0`}hj<-%`Y%V;#+uD_1xP7Wovgt)pW!@2s=Po_wFHM>_YoyKDur>#d z&F~oT(<8q$-opjPnPrlqy1Qbx1xFHB8XqfYmvyFkcTM4)UW-hw{ASI3^x9~)Z;i$( z(_#4>%TuOv2Y94ML~VLHEtD4-8CdTe6&9X2U3&jbI5RrRIOC-gZ}-n}ruApvS)ZRU zJ-70r?eXXGRmFw1pHCz&4S(F`iTwkQ;j7D+zWwXY$myf?F+Ul0Ydb5UY=1fkPUre?id1bxcKgo1wSzF$lS+k8xzP=BiFj+Z$ z=C#&Q-V5eM8bAAb$LXh)<=t5EgC!v|ACI{H@x+t)Yl`bWwmM!sM3KAZ?!9|EYj)gT zzs%=;$@wu)-i*C{YUb-bMH6NYDlmQ=kmvpFeamhS4x2lT^cIZx(@(fW@kCK~Zr{u& z<2>iBsT(@Gc=5Hc{MAJ>;vGB9FH?=3rS-lpipe--F-*{b-}1ybqs~1poa|qmciO_W z+tHA9q4{%!B^3>O3rcT!x>s&r^<7m?n_nYJa(|!prt^<;c5da*U2neC%sBgnmG_|U zO=czhBg?E`3yY+~VPr_AAQE?!3OE9X#uC z{)cuC;^)N{x4iM^iO%26&yCSI93K{wY#Q>k!Fo>g4CDS+ZFm-;Yo~8-_z<2mJ1nxH zyk*p_Z&c>mMHQB1e~cE!2lo}^m+YO{IjmIC^8N7H!$u997xOUZ_M8!w_d*`Yo>^5EB{692b$^7QNJ9Uj-sBj{X2 z)CJ)$G4D<>vcp@ff4$;miC> z#&{$>40gV_!9InTYIRDsr(;e08K24$AJqlR_NVGcns3~@)-HA9&Cu(N**6uQ0rNhE zuZqzGT|Iefa_~-7lznpQpnK^Xtu|FvWXdmH&$jtp^Qr9Jr)%rK53dM~T>P|+EV!U* z(wKy-mR7bCt?fIucJYaRFrcH~uhYLo?p+E8z=UgNoko}XMDWscb~>bFX?yLx-rlX~ zi{g-r=J3%$rGI4E#(S(V%Zs`a;Bufe$iDWkWkb7ar^n3dF=+9h-Yx;h+n721AhdPs z{cTXuo3R0@`HQDlMJtxoc|Lpk_UqR#C1>uIrZ2sIO*J4s#rxBibdys@ih>vI+dI8) z|M<*rJ7i{?n-zSzBF?#%Jhg7}n4$GiR&y%{-T0xzYW3R?+aa}n9rt~I5>;7g?=hyW$a~q;E>0d>2Qto&Ph>K- zs(8k5KyKd!&f@_b$Wgu0Tw8~&`^csIwS==pKy)O}k$t0EKO0Js{t_+@!? zz`+lbo#tzXx^%jDUd**m6{E{EPpv<~0l-!yq#oXAJK|VsM~iK$=*tPG{8kD&P9Ey$6J_FQKj^%x zl~v-*F`0vx1!oJ!E&ik)8GbD`*5^XI%#QU_@~!r6+i$<|5rUsipT~HHRD_3bzPUK) z{&3BhR`O5F#{XR5kr95~`Hn|wik;WSQ)Anms!2CiRhCX!_V)K-(@PFT1*FgWF-X;; zpRIRIM>CUbQj+qide_1dC<-MiAAW}HrO>+5 z=g1D*tXC<6uJ>B+@&zF^?15e~r;i}v&OH9m;z=fE`yLrzD|sPIU7BY!re&g)U0|X0 z?fz>mHznQ^jjPj`Iev^Vy}v%le7lFaMd+{r&YgEgx2e7|tle)hZQCl^bam=sanSK) z*sl%;o|LqnUGUDf_nXUh?=u^0j&$B5UN|z{-Z!L0i?7m-EeqEyX|<$!l+UQ4Y~Qu+ z75%TQThq_t!-+xufA|hukznDg?l*P-Uq0P?N~?)|w*E4|_k(lZUJltj&k1J|q#1Yf zdzMGm_OjtUc8S!db;@45w@aPp*Ulc_UFjG;YGemhm!Bn1H+N|7^48vM(NWiKC#%|Z z{j3=3I?#N9#{%bi_xzvEb$@qxOOHOk9g5zPs$MYh+53fUC*^$qsMqG0^_`r53LMkz zhgPq@|MBjx-z;1CXwmX-kB#}o(zNB$TjA{&D}UIvXmH#0ON6ScKVQ81C90@>NaH6>NdfzXUWI);?JD$W6{9z$M2a1eNe9++i(9V z`O+5Jz~W_hL$rNszLNw!nKa|&iix|Dj!b@$?iJegFTs@g--Jv()MKuux08~6zu>s` z$gMwg3wKvO_011`_O&unUpTX8^%6^?y3Qkf{-~B%|Nh(d@h=tiVKqIp)z4ohm%ljR zol-kH^z;|I!dIVfmtFe0DQbJeIOFV3j$-$}?k{orxc&U#51~0fzGa>VyeWxa{wiTW z=hs6g*wmZ(ZFqOB+s^l?8K3?f({Q75(PYK_lYJ&U_`K5U;XqyAss-MJ5e_wQxTsJl~l|JYrRyx7w4UBcU{o4v}PM$aj8ah!Z%%2)CEtsA;reBie1 zl7nn`$%OIO&t>@jb+$b2H?>Vo#6~2dVWX0A#Zms{j&eJ z;!WEM&Mz!IYTWwSG1=bY<8e1u=G}NG%C|n!|HyFb@Z43?$DOL^Fzcj!z|_K^KaEeM zZ}lvyN;!JknTZ;Wn95*7g=><|_~ zKtS0-b_q#L!YV>o6jVe|#}yG36%_@SQB(#|QE}guQB+(;a74u&SN_j)s{7sq@pI;# zneYG3_w&N(s&nepsZ*y;RaaM4cOKsH<(d25KJf1RyvfB;r;Tkh>AFKV<^1qN)OB$K zw;ny~-LrS^Er0TsJLcB;20izDP1>LCSX!GE9pAG5=KFtK760PKwl5s&d_(=k1Ghhs zxYf64*i)OjZR;1mcJCQ2`jr3q?p4N%{;|C(uQ)uzI(N#E_fP)Y6{||mTlLc0y${^` z!o{bYK0hzL|KC51I`7oU^FJu~bYJ++_lvEUdUrJS5Dtl`|?K#t?&Q()*VwuwS2el zOOGBrw{l72fwQ0SM?5xv`0QuGBX6j`tK!Kb_mf@zx?|I*!8KQY^V2KG)_qnscFAdP z_G}mNK1Z(w;%ih}F_N4MRmS()XVEv`l9l!3A_MN%n>UCx7{ry*W zxpeZU_YR&p!8+>A?J#=FyElLF!h^qD^6ufG**ngka82v-!<}ngXB`>-&{L!Q@4WSW zV@~mqgA-@>-?ZVC6;FQuNRNuv3onSQ`*2#%XQsY4_RcXAjum`+=*muaUbwoxRnN~` zxtA9l-Py16wMid$OucI2f&mvEcw<}M)a_4yI_17T6aV(o^kHL{Y(I9m&1)%ap;PUdDS0zJ1-8t8aR~%dz{m-`L>v3g3@$8UZ6*tqibH$S`m){YI<^NY$JD7x$&PskUYihunNLxRz_tfY6R zl72>FNoiSCQA25>92iI(R8zaKuClzMAu;!)le%Yh%gO1USXf$AomEvcw>EKDQDs%t z!bIjbl*@FxJ)RK!y!iR-U#R_SaojKLxS#bqzwqDrMf{7u$ba!?7*WwNF|o06__f5Z zmHlgN|KgAPwK?wB_IG~me&?6)FaFy9i$7_9PYBvQG_*yFurM|!n~cpu(?;39X!{pq z|6=VQ?bh^18#etp_H;tWu14=@z)1RxD?GoTFc5ug>|a=>YT z*8x2M_W|Ysz6C@8)&j-=o(E(D?gUf=J_B?BYy?aPyaVV5*acVu_ywQ<%K!raj{uSY z*8_?G?*XC#>jC2cF9C7^cLB} z1bh$h0L}#r0Xz=q1h@%M3iunKCE!nhiGbGt-2s0F%msV{2nSpQ7!7z1kOjB{FbD7{ zpgrJPz%;RMN-h;3nVLigH z5PpR)3}G0;3lUz3a3sQ!2%kat48jbA83=Djcss(`2xlYw1mPzL+aYX+@EU~IAUp%% z83^A(_!h!G2>T#>2;oBr&qjDQ!XFX-h|r7Bi*OafRS1V69ER{ogij*ujIcApTM*uY zupD7I!h;A8B5aMYHNqV#= zgcl<`1>q?OUqJW*LO()3!fgn*A*?}IgYa{NpCjyuup`3j5MGCH2ErK#-$nQ?!u|;R zBYYU)!w8omT#E1*!ea;xSfBuq2$%_o0*nRZ0BQj~z;Hl1paKvNm<;FzSO9PX1_M$7 zC4e}<1VBEZ0f6(!#tOh7z+-?Ez>R=nzy|;W9vmfJ?15|#&V_1L$fC~@LO53qdl;xQ?$!XD z35Kl<*vCM-8E6{=?PZ`%474Rqdjn|UWowKrvNY$&6O*>bIZyqiz`d38xrS~&Z&V+{$_z%S{LN3tS+vZQ(M$fIScaVmDbgxeDaZAS65ox zkXTV#RDvAE6{W?q4P$Qg?CP5N)rrhiS6WYYh;OKx>=S&}%vvbv;Zeqw#) zqEd2>f+MG`h|05)l>;vKu&Q@NvX}- zOfRRLS(OcrsJhbH(jrH3C%vk&p|q~3%5SR>sG5`R6z&Lj=*{!NtR=dFPP&uNN%<9> z6)h{OOPp22=4sMy;t_VMHKp4Iu~YE=0>(l16)*Z)h>V9}h8z9HME`POY*4tDM0u3a z+M`sgC)#M|QBlzzjEWxRZs{3dwD+ijD358xdz35AlVl`#RAP)L6ra6QzE+-PMu7)C z(Bne>Wys%#`QxKKUgi&J=_z9VnNc1$^P6#=T;|V-@q{zK)yngT&R-lo98v zH)6baC)kH^$cO$My4#5IVtnw;1SA6AgpgHg1QY;2fOL!pzR3WL1EK4TSTDXMVt2``Kkb!z;__D0BZoFfFDJE zjGewy0Wm25MwFj|IEDgWH>B@D`C*990we?9j1XgsZ#iHf@DGt62K1c{z{`Z8m!bSY zh%W;42L39_k45}UKv&@RBBVVp02BiM8u`(PKD=Y@Yh@ImDzV-?#ODEeApKdCkGq_& z43GwVD?-})Jit)khmjxSxNkb31Mm$fzZmf)fPTRDqkMdG#)pB&mkoR;!U(`xz!=~^ z8M^)PKD#d(^w%*kLZ7hPpEgYaeltSyuK)}J{t@!C{m%fv&Y_pv?SD4#KEPkM+aKeH4}Kkb zA42-mg@BR3zeRr5XA+=wllGqvyeHD1x7)uQcxT{uB4l~10KQK??Om_x)^W@@L%lq|E>Q22;{T=G z_*HiMF9zNh_+RbzuL7P4`~id(U=3gt@b8hI?fF~%|8cwhXMraf{5K(V0hR*>0{$K8@N4b%Ujn=z@VD*uuLhnC{4WS20BZqbfdBkE{r@q@r@lpiB=Fye zPyvC|TmpbhX#kL&-h*zI45^e#xh2O;%6A20&=SIE!y{H^}~jNSgF;OPYZ z+Y!=U=K_WR{{;Ej{?h>MfnQ^{|2e=<2L6`a{&Rq50e=W#IN&0{Xy890KimJe`u~%5 z`xk>J1^l-lB>xJ)Am9g)pY4AJpdIil?Djt!cpu0=oNp=Qksuaf6P+;n5FP8^~Wsb#7`-I%u@7IYB_wQGse$t z2)%$+fMLM@^;rs@IgG^0>fhTh9$i#7J8?is6&BUFHmUzb%M2$5Ys#@$hs7!b{C#szA-8zE1g0NIe`~Vz4qqeH@(}y{KChc9r(nC5NDF?l`qD!k|GU z^2b8!cGyEm!9GhK_DTj}|E3swG%K)1|CsTC;llJ>|CZhDT6WirmEP^!w`0l=eGdMz zbo=(LjU|6)cw1xoCk(eY<}SRV27I--flF$_#MJqjmE7<$#+}hW#4OjCqkCclQyC)v zCWI_+H*wT+aZ8=PMZztOM;RI`8}nNsgueN$k4bs)ZOC_LV}4uBznCH9J=+f9Hdo`; z4hXlHjjuA?W;OQB(BYaM4Bd_Hz6_1VHHBK<>XE=9Z~rKr-Y}k_t8w#b2w~^llQcbX z8bY+whtnC}*_c>Nde_DcwG3U2GZ&J+y|LlAaGi}e3sJAAMdaVoSj7IuOhxnb1UoT}oS7Wc`2)9KwR&5}CYh%^547W6HVYn@(G4oD_T^on* zU>MP;z3`9g9~L;V1*(eIZF6IM^#S50GtPZQpB)b|67f&d-7=PL9=UFt4>8i6c%#v1 z#}g4V6zPm%6m;vj3q!OK#dvM2_1hW&6|L8ATZeEHU^`$pU?1QRfN2Wq#<^wd%1E%o zE(ke@UWPErt`4FG)^njX_Ve&ik981PoWgpEu>px72`|$WL6=mow#O(@h2-xGy(n)CexKGrj5Ao?%D)d&Y8d=?=WL0=tY7>5z= z9s-|6_#qZ#v5s!!4+B5&HNy?#kP9}%LSGK(n-SJpXiEs2jKQI*7&sqb$ zA!6)0*a?fDuU-o}4Ql@eBgEfx!g6TyayH$p{cI;fvhP8ditvz)AF)GQjQEPnI5g&X zIY+^_8cdD1pluO;h>$~7+^u?iOhrigYJ~LVJ$8sgWpZ|)@phC8J8r(iFh(Ifg3+Td zTGjcnjajbS^}@=3{_`jeAJAjp!Hq0olE1uC%gfj=mtrS>S3TqDfC>K;8o%luK^Xsr# zZ=B&JTkYJ2dgDqbT5Rxxh~Zx}m+#Ibdib4racsBd#kn2V-9Cx{P0)prI_o_RKsP{W|m!NG$n+ky$&A39>x zusKgHqY^TW0Vsn=LlKT-8`om!BBqav%#hQ&dCw0LY@`3&oHD~03Rk!Du*H`J(P06%*&8H|Uszo{wgz3nP_VO|QGDZ>AP$FX z;v3JwiEKvZHok|i*tk?`s8ouB;%g8wCaB;*9A?p;@k(i1yqO9+=VdDKu!*v6CwA_pkZf}71eWmG>n;OS9Co5+^o8xF2ZFLar@_z zLC&MHfSZbYn1*W@FJ4tZlG{5Q`CZFN@~QEfR7TQGBt@tsk`(6<23{JVjd9=xKXtOA z98ShK5##SIK*#`GRBt9xeJ>7m8LAIcETz#q$*9QQhjD*s-axp^iwS2=Ivj+sP`)OQT zC^m#5ndVXY-Lfx=uVZfhv9i8QJ!#b@1)(43?>E$eGy zlQn0Q^*FI9nlmn(V}yCe-6AvIs)37|Q(qM1%Oyr6gJfEMW$#;Yvxh%8AWv z6fE89gU)Hrnj=`IH2|SmtV_tT*rCi4jo}2YoBrZ;m*E$s`}MPX#)14RQ;{zT?q znAV!M*#uJ5y+q@gau3l}6xHS$pf3>>$!#h5L!$UA2!?7$vEKoWxf->K#e966^#Z^ zBhGoXMgytQ*+32B2MBfHSa!hqpGDMh{@W0D*@KE6NX+HPgMp+E1GiTOl4gU4X*;%G z7^H)_e4bqtryf=_X3TB!Rq;9+BNvHDPaH!Ys2e7;+YO4HZFG21hgUnJfE zTDXj3If`k!iOWEitElJKz$3t&r_KTvgS$dx4~ouLABpN?s_9x^+mhoa)77V~&O@}-B3{^IVrk0O z9NRxa*47&k;Ro~ii@ynoI#Vgd>2sUy#44J!W2MA#v`)=dBf#IbZM&N!qmh6=9t!4p zN-D#O@LBp0BkzM&R~ zd9OxFha)Uzp`uiC{h=itYf4HCwaCHGNu=#QMDgi~;5%PUL5FNL5wun#a7l7f+7$sy zJ{!dy0&g67t5pg|=+99|tBVkcU4Tn#R?mg8j6ac0xm5tQM*X?DY$qisI}?19$!p7Q z2|-%+I>VNo-c&Z_ZYBREDjM}`qPLS0lwAwH4dk_DbHLTIw-~nU8b>zkc`tYmkpD8( zhq75$&A%HlyBVd1hryMJ##0;A70tD9Qi56>0dE3%Z7nVeXt57c#d`PIT8Opt!8?=u z8&wkxjs!I@Qt9!}qufrsbTrc3ULhTHNM1=eX2e~i-~yhbpnJ?ipP++sd^R46LW3F4 zqiO8v)whT`qhBk;T`D98e9j=~^6Vs0k7SrXaJqzHP^MV+DChIiTb!{`Pchu?dqKm! z-R*^>o)GBe6v&lP&S)4kF=J*T>T}oO8hSD=bfp$GxG2NR#a8#gl|Z~ajO7`_#IPq2 z^?4?Jh`2S~0(ml{ytNAIbNGz; zhG)J;eAXb!Ss){Mie+_R(F-*e5k6y9nc-RVkdzT+EnxM|*7@SC&BT_>k+cM>HS;Y^ z0FBcCMXa%}V5!yz#FkAJEZv$-Z22m|GOdq^ovTa837;_+I_%H@ zD)kj=nXU#s+j>c z^4jxH@2R75=6jhy+XcLuBB%s;&|siP}J&p*Ahv|H%;r?*&_py!|75{>1< zB>Ry^&pf?jS(3$>r;62?X|tXndO7j*meLy0i->o1v*(6gflGtxg};_;STg%NX|gD5 zSe##~-daj8s}6jskH-319f|d2CRa*<^#l}9Cl?7e*y_c6{WLaQ&uaQ>Wk<>6Toq{J zjJ4>aYJkQjSUo9ope|vu^?5k3L3Bk|%2cbL57^+Dg3S!C#O-y6MoPkK=3;_2RAUv^ za0(fwg;ZIChz-|REet`|^||SOUe;TUsG%j6BI>GK2;p(+6e=I$l8(n209Vr0G|sNr(kJu43|!Yh8~?my28wUydM7JXD=yiXaN%QoNeRrMY;?y4YmapCO8w zmza_{PF+v6*6M7`!j*e9jf;3X+eMNsElg*-SZ8aaK17w&kES9!7x~pRF7)XvKS-9r zc9x%XmbR*xCB0)Rc7JB!p1>q9?FwYvFBzAE7GKV4zHKsX6L35*sCP{^+`G2e16r)l zO#>xhj5k!NlFCyq_ZfJIn=6hjQQZ>7>gIvcULG;ZgcA?IZPgH{qw;hEFx#3=_(Miu zXq^h3c^Na`sxvd=VZeDv`XG?`7Rh`UGs9W7h_mbg*1j0%Z7vR` zuKK0WgR2JW4Bg5U!+n-Fz?cX(*Ls{Tws%G7N=y~&CIUm|dzg8u)`Jcf~>FvaVGeq-!z>QG$z)fK8 zScAy1NUY0!&KCMiT8u?=Pv~2)9tBg9xb`RX?3R&0<>~S;T_TU@Dk}3S(Q!bNVc^f{ z2Q@&9l+&5GM^{S?!7Mgaggq*CNp*owJtlg!79AgVaro_Y8yM9SnhtqS>Q0z;8FjqI zREq1;TF_M{hpWyD40W~1;ixqRkqsu5flX(yZ6DGN!U}PNYdO^7Qnqf82cKL`7Idv?lr>N(fQ)@{br#@^>-9+l?>WAjky`)Z3QK+%jESLHoA$5Y% z6eE8E(IUleMiX(@^#@e)1!PK+d+Kx!TWNTzPLkW`45EX9b}z%j=1lth0$|C~nzM*r z4z!2#)?%Vh6P4atLi86h*J4D!7)U~#?z&~{xS(+HPZC> z!A&5UL7sx)V=I+^N0g`HeD=5koLw;diF*54;$xs_-QT9}@39!p{M5VTGuPjTH|#kw zaZ5=gXBoZJXi9!XBvUFkpVhQ_aA>2vL`la2f?p;YgOyz)h3m5FR#Ux50o*u~=6JAviNRA-&yRPzPmw}VZsSDa6^X$?cucMkAz}Hc8(^NBou`wD8(AG%fmZEMDLk92;*s_X$o2{oz@?J)K8F81i?cKmR zA#+RXpH$Hw!zJK$h{=18W6UUF`v`1?|5>Db4bUm=OpZ2@ZIFWbUk(+j*9uXYH2^h@ z+nQRPI#DN?+-((&rxIQ2Vqj$Cxrpva;?}2TZ!aVCOwhDDb#RgQHsaz=9c4^D2E5%Y zLnTRSd+d=ycz+82-u6`p=3$DVNaDu27JgKG^(@fZ!^wY;XE@jTdZTv)E0KK#7^D6K zS)uGQTY*WJ!zVx5LbR{@1E44swE=-q2@aR>E#`Ul^2McK8HEJ?-ose;$Iiw73p*F9 z=~Er$>74Gwb2lsDK4+ly_2Pd!F8*%^NiY5>?mu_ocY{R0FPe074o0_14%9P`&P5xVDgu0?kI=z}DC%n9klBW7Jui_&;xrY0iIS zYwTu`>1>TDn9P;pY>h348qU&$IfK=3mL|-Z)X`a*_~*CABDgiSyOlYX1zLwVK+K4d zvT@o8lUnyoHZvDqq&iRdSwh(nDIvjHO3rf4nP_qH=&nc-&Qz;CCRpxDoiE+uyUy-8nlsb-h~-slEXSHi znKc^AxBAfU&eFQ{vP|YXTkF}^`i#0X4g&|*M;0;dJdF*uI#bGOEoHdH1$6iM8XIM$ zvb+m4HrBd}*o7LKV2z-Zi!?UbilCIs6s}w!8BXjfoi@|Dl=i&3uasV5olNW+UB3$J zL29-^b5>csDDzs4)mq$&a&OdFgEgG>+oZ7t7PmdzH)(9K^$xMyiJ2*l%Hqt?eIJW3 zQ&uXAGe`IR8eOfd7z%noGp|vWkEQI?sq2(gNObpT@R%u=DJz@kBSnI)jB+B=62v)NgtQnq~1p-2JW2yFJU=%hd0*8uw;dqlx~~ zN%HQBsx^Vw0-cs_ttIC|U0$ZeXL@sy#&V31_gVbn6jUJOD5Fb$ zl-jXI_IU|YZ*)Y>Ev_&;{w&&IBV>4TA|W@5$Iv{vIV?i&l7w`F+jzRss!?;R$_-E6 zcw~uox%*dv6f+-!-33gIc^O)|2QbRyK^GztTY@ud?!lzRa^~e8BFSO=%9q>S?{3h; z%Zjl%G8!?MIlQFGa1W(mSBlFB`IN$kQBX)Mqht0W8g@SF<#vyu=jz4V>vipsv<^v@ zdu&?<z!lPo z(a8mw5dU|YI8g4&V~KeIT~|W(eMei zL}P9%i{&rXScsJi1y$pB5Qn2EM#vA4rIsOv$@K&fv6U)alCvP5JXX`FU_0L9)CGz+ zIeyS3fp-CQq2et`jWgOS9$Qma>a5Jh!^)k&$g_w#^PeR1V9?qvz~H4WmttlSucYuR z1aAZmab2m&vsxTQ@yzo^B=IPt7Wbrx`wM6ZVu`(yU5!f+OFX5qQxn7zPit&^f>`1i z!CdQ&4tO+rPSMCHaRMta&6G5j_Ua&@2vwI@CM6C6EfELrDfHwp8=yb8= zn{4juKuVXjq_^1G9}|`3y8T4?t*Z3LDd=sYorpfma^4|2hNvt&y-Rcs(HF^lfQ76f z>SAr*W9m;pyFlv?=muRm{Zk*3UX=(`T;U)+VKY!PLoNg)mm%6&ZDx5dNj+GH&45S2 zv@TGO=U9(VLDKbjo>K85sjbTk)Fqav=<*^{(|{T&J*eu}Zl$>5#g_QWEiMZ8_{LoT z4xFWOVpvc6*3CI#(k`~rcaom8nzcLXrpp-_90}BJ-9uDzIM!Cg%72k=kSZ(ryG-6u zGi7PwVN;5b^?*ktZe(0ac_D7`P4yN;P%F1+mH7_SJZ`#aQap?DY8{@Wd3 zg-X1G2yWqKb(0>WwZn9r6FOz-crV7owMXq~ryGMI1e;?&{a3@jb zkL2knaU-LY30K>S=VP&mieK48@vC$pqU<$Il-jeL5V^C^LHG*DNl^18ta4;SmDmurY$+)1WXU`(gmzg0yrXpg zRw1FD1fF}8Tw4&^ z53c;X5y{`l%M-l3j7ujvZWOED&yyAkcS-vhgtRYkkr`CCmY`LnND)v6$mTH^xyK?y zpO7$^CaoVc<>S)BN$JMjv=*r-`7}iOF)|C0hY`uIMx@&!T;2xOle=lI^;JDDk+7oY zMhQ!L-X`J9p7%*OwcDcz8#*E9^N8Go2<-=@Q=vd2_uA^jeEDfK1kF{;8a0HBpn^16 zF1wkStAad6uf-E_`vR0X63!I~w*(|?qJ-5U7b9Ja{vc9vcY`QWJ|LgbiT&#U8BY#L z`wsE6PjSgL;0N7Il-jy8B9Vx^$w)gydZ#1O8IfW{@XO-lNZsxcucOEDg`+Ew_IE7r z)9Y^a(CZ!pMSId?cZa0A)=%&!LW_ymDbfD*wuk;T5PaId z-uBSHCIZ)fFv71!#Tfe2k|JR@|i$(c=EYaTG$wJL1a zDzRN_rtMl&ZP%JCu5}n0#I-WAsIGrFN?MA-#kE}G7>!KHV|!Onxz{{52A$$?1=hKd zmKdiUqedL#Nl>(7)Jntu4fshsps410_{53M)v+I4Y@VR*9J_xUW%-wR=3t*knj#qq zxx6Ka4h6t$#$J?lwTIh9!dOYh$qwTd&B&o=0U1|%egLC(pmk)Dp$AOA=|EeU?bkyO zpNhqS+T~Ie+iFM1e62?msYOC=6lPkY@mkH6awP}AP>l71U?$!`ye{^iR4kGETyl?X zujtt-LqAm0s(h#Ke&pwyH+qiLMQ#u8gQjiU)isAYbVKLiTU;tr@O-^@OQ_=;Y?L^Yk1>0Z)SH7=P8Hk-pz=-0-NPYB75U9c z{JN7f|4gj40@OiQ4y0*rhbY|RggcMkvJPdcQ_PWM>_yG8aWT3x$%lHS1Jqcv8p%0K z-ie%=MXI!gxlc7Ob&AQ|4T2Q$rWDbu0r^)~CB!ulhE36 z%WWIfaqGLWyT;|X>3VsMU9rGrc+$YJy?9GZ#v;6R}p>7ebkY30d$H(L% z$d~7NZ16}oKEDnWeA5IL?1p1-bfi8_3h0N8Xi6o=*7+f_@=rc6Y9NJV=TwL+O08O$yF8`bQ#{>T#GH9@A%`<>+e`Z) zY7`RqdkhWsZ&~qo^+N?+QK}9??H7?;_rsN4(dt}~?3a?9mt?L4DX;#++&kF7Y=(H2>1ZXMFPJmDH{UbX8I^RFP6QFf*b^^4X&Q1W=#DY5k8vFO|1hkR* zop>kU3Mt*$3DEWXkM0Dph$cG$8vU)E0G%4x3D^QbtFxKFZs2uif-7EEpeLgXA*#)joNb=tRs}#*J;-gjzoX7}lb}z&E_Sof z1bj;X78JVC{!3>2T&WIqj9iPC%dSH`EwY?O%s3T}&}j%qX8qfseN+4#*5 zKPFe7BZX_MOC{47P?8pd)QgSvCzX5w;wfW+q+W(t6_WAmR6#*syA*{iZp33Kvw=oI zU%05pZJ?xeppY+JY}dWS*|6#>7wd8mI5qr6u+EX>{8r+glQ7%oiEs6tPCJwJJ1X&7 zq;(<_<0gf+bKrmUqJag0`fKS8{tpc2eQ^(lQXt1flDuSbkRh9I~%`FH$bo& zfn)uRczRp`KLwp%f1t+Bo$@01HSejK_g?TNEO%sUVz%%and*Di#O0O_O9S!SI|Gn-k!_@7 zVx*a%q{-5&A;Z8D;E7mxQA*IeDXmi>jg;?J6j5-2VY~?H04PIS=elX@A1P)fo1~kY zy|Yb!;91llPw-yAJ4-R$MeZcvU0F;I8Hlz5&8or?)Si;6&gd*7RxgbeAn!m3RVNAa zX~4T2LGcslM&j%JC1Dd1GWw!7ZUSg~>x5lMU|UAwkv))Su;h7(c~Z|q0zl`{37_jc zImmNwz%PeOo{YWV%~=K8OJCPS$e#(`Ljn0?gx56y@*BXr51{4igbXAg&jRF$3bw1{ zN!bgcmVK%a(Dp|`(si9Gq<)mUV>S5BcjW4XsUp|tFocb9H@0Y&KspEUJEfu8$!^Lv zw@}4)+r`LjWeMXhU7UW&zrzI-u>m6Z9TkeWMnquTKZh+_VJbRp(@f__d{nvk@*&_|qM|VBv+kl;rFQZPl<_P;8$=Va z7D)di`S691S#2ht1w6TwmnpoQf=kj$TzWyKy2qV-3F7#57~2B)g{Tz21H(#P;8bcl zwOe8;R)`;@N*IWWAvY^^j#R1-C|xQ*;%Qs0*a(qwr3F zkdzmZpuIs8=YxpbCvA8LNou8OAxJIIQ}u}im`ZK$VZG)b7p4S2ch zoyl!-#*7YAXxL97f-gf*#3x$BwWJ>wYPyK~OvI(jz58>?oL)knBZ^bNbm{3|C{6&= zXIP+rsd;3!_mwWT0+R(D;~ihexZ|ifxyq%!)$zfU@SWy>vmM2j1>{~#>i0s$TxK3> z*P(=@Ay`8F80zbK50r^UTTyh7-2U70sFfP*;*(DL9V}+3i!-})8Lo!8M7R_`T=+R5 z86mM8-FQp4Ii2KmL^d$e4UsPx>5E9@Fhtn%)*+HR0g=?{ zxa{j9k6}l-(DN`V%N|lseUwcRKJ#!In1$kpqZiIH{?0s;@xNzYaawt12+mmBXLd zBgZgMk* zzY&JfAFHJtpsyC4hk>H+I@icurxdup>uiv_&NWPzyUw*zuNQ!K?$4@SC+VLOe~4z& z_`pKoVuww_zYMsa)?7fR+hH!kN^J5%;3-=`$X$V$pH|$*c4T|dlYroVxW9Ln9Ntj&Uvo!Hr z$ETa6YXIl9CS~vx73JBN4Zo=>9lVb() zsL#wyWYbTNjUdR=;}Btz+x(Se`ogqt^YTc23Npwec7o9(FAT{i&jiI|j*3%8JpD$v z<~m&MjUFw@RdAkg<+lV^sl#=R!xdxnI83fVTZJpN6}T=W7oXW5X~OjsxrV+hT)kN0 zUF71U`XNN*$-bj9dYl7i3o*YJwt`5oz2UG$#M|mau`~z^Dd-4_$J`wYu3x~_!?Zx1 z*IiScO7&Pv-m^yvb*oc}9{f{rY8e+fJm#y|8tK6YKebX54v{dN9IG_pClI7Y{1l$p z@R-q)8yq2JH-Un!ih>Aeu>x^n;|KDjO2?GZle-=vBc8MQu%!`y8{)=g3X2yqKeo3t z_*e|jl;4>4Nc<;1cXSXr@q)rs1Rl3bf9|9C2aiJ39Vi2zlez#r^e}!eR88}`*8%4r z$udIK>*Pq1FWfM7k8tcnQj5VJq$K+h1>4PJTP1?Xa!A;yL740G-Q6nZ8t)s_-5+7X!N}K4D5pNqaaKK=rUCihqqm6{< z8KAc}LJlIqlgFCHJ`PGwC(r0RF}BI4M?7O#EgESMLeD94#AI%H$;dNSV?OI@N*Jdx z%i_T3u@B@&S@jU<8DAjz;;agCP8cs(yv372o{1Vukk^Aer(G|G$9odwoUHSuT0E%c znWC|Dt0&V=*I1@iMa|C8SdP4ozSpo!Sb$$r$l4JtrF^4Mx(e=Mp-VH-&3x!u~t`>P@y>|Shte1Qe%^?GGeneHr0B7 zoK+f|Y5l~sIT|amdNHk9V-?mEVl@v)c~w?>VzmzoR%>l!zO!BdW~LnRSX^xO)O{%E z_7?Dce%CpUKJIn%+LDg^B5196>5sqI>-GwbS%ijZMoV(?9KH~a;SaAXo=8-cawLNH znZ{eNCNl=BaA=1%hj399kD>2<3{u+~3?S-Erl8EjXpDIE8gs9d+|2nQzA1F4NX4lkdB%!7%_f&LXlCjr&6&lTD6>T}c;djw3R#JF4W7o@@TWkBkBO5H>; zk9)y-2|0HWeUa#;WZX|w&MRNWR1faA?W6*ivyg1we!cFah{{on1jR*I^{|x5^7zGX zHEk%w>3ZyBi35;J7x5PsF@dNQv5Q62QD%GfcM3Y!Es`i@HDDc*xNp=!EV|N7VcS6K zC>ovTmU<_uE#b(zOJ`-aJ)#7^!mBgxl#I_IW6~nF#b4yxlxmz7^ROdkAjPD3L<5T8 zSIX5i-qf|2WceoKCxP-)JyL#qbv83*>x|6A&zgsh!%hsd{sKWNQ?jOm)2jD?kGhJ*K}D_)^RifPw}chX-l#eo9}?%qtrQ}ju9>qTgIIVTwa5? z)XlVR#N{=J%jE3#Sm3&5my30)fu~jCqY_uRIo5QhWw!H?V~abT53g&G-eoN!T@Qeo zaWi6>cjIy!=$X3^c?A*tyzY9GCSMgziJ{fsvbX7;1UZ$1gxcq3ypyb*{?$#hb&}=K zH{AsgkXBxU&p_>$ct;K+>TQWbGLze@r${@ZEx_6z*#;_fzO#j6fzQPP!$Hdu!Cy$u zGUEK;)R$7jl|;q<8ovQ}w&?Vgo1$FnOLUWbE%x#A097I$BbC>~N184-0Pk`+FBjm_ zwHJ~y??h}jye0tDEKUkbuGM(HrLQ|8m${xyuN z!KAxPhKr7v16l_;{jQHdjsdP~pY38{$M zr$g0Zitp*-O`s!h^QxD`b@QJj`8I(ss}A37SG`?x40Iac`THoRuS>W0gzn!{%pCWI zyRpi_4sazJNY%Q}g0;G^6X*`G7t~C4fTS}JVJDc$2s^>~h#)VU4}atg?+Tc!nD-gt z`OjjKruw;FlLk5z53|c%i!G?{T6iR7!w8klC?3$!h}%vg?}E%K#26#)am0<6P^Qb+ z9vyhJ=@c1!w7EMKiGMuWpc73Q23z4JSNoIF&EK2<*lp39k~l=t$4AYnMh+6 zq4AlCoc!w)LXc;s)6vsZvh*%a75LYCKE^HWQ84MJh4!2+_^=|WpHDi>L7(eOR3^b4 z*#Naf<#8pE`PLGZXNe>-Uk_A26Qw+dROq`Gfjp{s-9zAY?bK{4QK2U-)PR3G=n-Ud zVV<2Jv*&V|v>X7sE~p?>gf^xc8bT$PgX`pJw19*2=^wT8u996 zmh_!emxb_;5B&n6Jh!E*`z5Q}bsA=VoH%~P>CXsYZQ_{m>qeAc!9K357wnwQ{l1!t%rCWz5TI{&-GmGSxB|sB4--R$# z*3Lp@?JQKUop~2QL08`8NNu66X5)93FBH@9;lKiWdTTGTozHu zOu3&Z7eZ7@I#ORFdL3-3QvZz9?j=B_y*oVubRtnMqNp_Hy$Gl!4Vlio9}}&|Cpc6W zqBBZ?&Y|~qC3>l#ML38g=nFu@zoEt%O#OoBM?^D;_Adka9?>kKONfe7W}gi7L83>P z>St* zOCz@s?fVTMa2V&h`A+cZ~bugkiddNjmSfHeIG@_3&g_oEf5W^Sn zB_-Qvxth9!^#KJN9=)JUbQ{EtabCEi@p4?C17$`9JJ2;=`=Oc$h_KoS}2n=ihD^HwMGKo~{n&boFzP+Q_$OhZJCdi#XGnf(|32n$nJwf#Gb3Bqqsp zaD=qW`r!#OlPx5sCM3w)wQwwGC~Y@f|U>Fs4!Gm)&Ts5s9K$W>}iR zz-p4*;(w|rWkM~xN+RCtl;dlus6F)#^+=H|NFg2;tIUY7Fse=zALrM#9TD3Ls)Pfz zt3@=zPKCjUMxMYpEhr_bxpAUTz$ZqGX<{bGi*0U)IBlJlC(3<7D+OE7Y}&F-n-g@q zKCo3bs?O%8Z4#yWPBV%}uo1~DNT_4W7TLzHJOa8qP1#gt&|AW7_kbvR3tqr?BomFa z&0wcS1yS7hPE>o^7@x^;szMpDVQM0RI6E)>5L&ftuX1B2hD;8d0^exmF>;Zybv^=S zi4W?kYv0ChHmPviFpNa)$ctz8fD&S>V7>5hL#GE(VuzsSEWIO8+kiw9sSNW%9S^IJ z6oxJtgJP1Krr-gWic(&xQrc@fCBbX`s6(1=(;yfI@ZUOEE&1hov_mNDczLsm;i7E9}57cR!@Y8P$yxQt*|c4h&Y!TMsyxoLW^ zvtzt)>dF!@YD^Sw&2h$&Ts`n~a|WKgp#JQ&`Fb4c-gJ;5y@xaWU?jkR#4#Y))lUjq zjVZmGW^UH^nTo%&?ASmL1t%wAIOrD?p{f0wvN7KueFu*LxW5Maj`mL6Q?)+_XN!0h z-*ItFm4Xg|J1C4A@Z9#^=>jsY)5e+qh7Vo;#;n4tfl$7ugg(LR>y z_*kc)=%5_*6-P_T=^S(bqUk{t{lxKN_7PiuGG#bUnb}m;rZb4FCK=#E+08xEAJm;b zp2MkSuI>Qn9|7%w|>Ka?dc#M?SAvYz`o<1cyb@S z_i0}U4VWP~?#RH|BB&c43G4>62O2Ao$!TWE!bgK9<77nhRu4X61;<*+7Uhik(T<O3Yo z25IHo23tD@!Gq4P9@%8Db{=@_7HS(boILtCR%90lJ^~%r*>-@D(Z7QxrV#YdJrZ(*a+7$E*P--rJ9dTqefgN`Mx zp3vMI;kDYkomT45w3QrRWxqhPICmnun>cef8$JGsF4&}afN$b6aG_33+cz!flDsM4 zS&mB$P3}i5x{KphC-8J;ri$Xu5(2G`xwI1Lbm$%^Y0pv27dWtUN^PTT6^HjKw-Nk8_5xmO(LpjO(1D zH5=E16Q185)#*{rT8Hhu&P>g2j`l$tvt6A9Eu>%gVD*lL}M} zjVqN|fcH+#M-2szkuEoA6|l9-82FEUnYD$~fmmzg!$W}7mzq7bf-X+{^0Cp;=gHwkb3#%7md0G?|$FD+y*!p;^$B z?{TAWbdIR;B!*y@aT+cDf9@6jx%GAas+wZ-lJc6G@~TpQMa`U2e@SI|WrM${x}>hA zvcx~9sIuB$Jh!&EXm)9U2&bAgx3a3iUsYK>cR|*IUOoH`H8oYm6=W`|o0C;qG^;Wz zKf7CYu74It+1cQn*u&}nY9t7-0IZ?M^fDc*l zhjE&X4#8fsXl_GgRj|YGPhp#@-6}hu!-H==I%zq_3h{Mx<|9mB;Z@ly{h2GAPQkxl zZLR~6-Nor>{0r6Q&mj79va-tkjvuWg`E9Qn(>1#r2b7!&U%wS!v77l$F87=Dg%z94 zxy!Rgx-9Mc{HxODhc1F{bO79F9^fgcrs#b8}W=xT-63MyWNOAmM(GLKRkwaO$v=#4R2* za@0eP0S=S&W(f7+NZC+U)ir07zl%R72RTQV_;W^NI3gR4=<%+_C;mDy(NY_qcP zloi+d&1muZMI@c+OZNLFUFT$}?Tjq=h79Wwo(*eMnxPnk&=mes|45EQ9COeP{M*Im zgI<+8$_y*>XPJ#lvR9ota^#4S{?T3iqgU-T-&KX9%}Ir3SKn6iv_kWqCBD6H`bU`G z;oDwomK2(i+33B2QgP`R(y(U03A4 z-lfb?4yD;<3k<4-E6t=rb6TM}rp)Y#78#yx_R7YUBT&{zvmslo=b*V@ACPVK&&CxT zWmz1UX}a?`In{H65fS;E1IP3Mp{9($>82# z63c$xSZ@A#Y1vW{u-trLspu6@1nCc=oaN258w)kAwxyd3n`@2?h34H$vxhcMrwufx z#6+G{ez!UAxDuZ*9vp2xxU`TeJ#TD;Fg7-0e_mRMDr|K8mw(RKJYc|O%FOwNW@w=} z4*jQ$$N>Ykx_;^FBh7Gl0K5QQcO-@({zhiyGa}1V%QJ zk%T2I6NfrDm$qt3C6dsVwrWdTZbN09Dz~H|ucVi@)FF-1l2&bLOMAIC=~G*!dEdA8 z>~jvtirxEqkF@yKS!?gL*IxVQ?DIPr*=lI<$BNBwc|7N8_tfqw4$Pm&oqQQ{{HTGrLWs80FUd(#uOF1imiuMG80iO>u>IYQpAgVbw z?3$8-NU;YCEHeiK;A+TxSHgVftLAT>xn%w!=1=oC&Y)MOJFo7==WNFOg}eObpV^)3 z%lN?9ub(-0KAk~zdo`S@0PgX`QO12V(bqiHH61lKF(=ldt@l4?{_L3@P5ZgKE}@hi z9p-a)orBQn5$3l&SIyrw6XyCe)#jEmp~eXnUo`#Z(BQd1N6iHcqdg_QlHI{Q!Q#N5 zaS2H>OU{{}Ipg2fVZC{FZ*fz9Xc_B>wvc(M64 z1KkLn@$=^U6M;~OouTN#&pqiYD)u4pfj}@6#2BwN=P`srwZ|rdmxI3jn10cD0_J

fH0gb+C{Puw)JLf7k3n_Q^wg>& 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%0ARs?#E7@;)qPvj7E()mpv`Q6{2B z0^fmvgI>3~Qq)!m5Lc{QTOpz_ftg)L2bxyeh@*|`yi7bM85#+E$%1ipt0zQlO#-GA ztF=tMETTrjDhQdghczAZ{u#fq_8k0%Dc~Bu-!? zC?+Zo;{?`<;x{NS%PBA7DzDHfFXAe%&}o2(ZU7iAWO+UiZu}6^dy)Hj{b-r=Ln|j28>N3S@ElU{?Q6pgpgdXH2^5rdePi4{xkn7;#i0sio(U_#N zM*~IUBC?Mdv^_1NM#2n;otP+}c{NV2Y7fPa1xafWsCOOMX=zckVFI;?ggwBQAPYVr zvKVpMk_r&gNs&Qq%Sd`dEH!M_Vuj+&*& zvjM`)=OnaU8h~a}v=PFRuwf?56^qz+99j{FqKgQo@*?VZ5p{~Tjk6LPlBb@P$dpRd zUq|+J5SoslEY&-f>K#k=uw^LLLsBooO<^O1LKsGE33I|)gmk>hQR1KqofkEUN$na~ zqW88au2L#>ZeRqHm{4GM0+5AC!4*)}YF%m-%Y*}2;!BJW6tSajTv%BW#So zfM9MV%!-FGc7sCkFh&pQ53Zv+Zq>7m85>CH;gGQP1l0}g&SRi&WvaTqakX#Smh5TM zRV(^54-+Vduq13fAt@a;Oh^e^PZ(0t5y0*KyPRf78Bf?{NOw5R0Z}eRg}VT%R8+$0 zet8np!<&Ew3E5#E681`-!*pU;IYO8gwvM3K!?R%Ll$0

|w$+B_$L{)DAoGKkWE_ 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 S?2r;vAD-kqJ$e6l&;I}pyY4># literal 0 HcmV?d00001 diff --git a/ndk/sources/external/zlib/zconf.h b/ndk/build/platforms/android-1.5/common/include/zconf.h similarity index 100% rename from ndk/sources/external/zlib/zconf.h rename to ndk/build/platforms/android-1.5/common/include/zconf.h diff --git a/ndk/sources/external/zlib/zlib.h b/ndk/build/platforms/android-1.5/common/include/zlib.h similarity index 100% rename from ndk/sources/external/zlib/zlib.h rename to ndk/build/platforms/android-1.5/common/include/zlib.h diff --git a/ndk/build/tools/build-ndk-sysroot.sh b/ndk/build/tools/build-ndk-sysroot.sh index 54ce1135e..7a79e9202 100755 --- a/ndk/build/tools/build-ndk-sysroot.sh +++ b/ndk/build/tools/build-ndk-sysroot.sh @@ -246,18 +246,28 @@ arch_headers () done } +# ZLib headers +common_header $TOP/external/zlib zlib.h +common_header $TOP/external/zlib zconf.h + +# Jni header common_header $TOP/dalvik/libnativehelper/include/nativehelper jni.h + +# libthread_db headers, not sure if this is needed for the NDK common_headers $BIONIC_ROOT/libthread_db/include # for libm, just copy math.h and fenv.h common_header $BIONIC_ROOT/libm/include math.h arch_header $BIONIC_ROOT/libm/include $ARCH/fenv.h +# our tiny C++ standard library common_headers $BIONIC_ROOT/libstdc++/include +# C library kernel headers common_headers $LIBC_ROOT/kernel/common arch_headers $LIBC_ROOT/kernel/arch-arm +# C library headers common_headers $LIBC_ROOT/include arch_headers $LIBC_ROOT/arch-$ARCH/include diff --git a/ndk/sources/external/Android.mk b/ndk/sources/external/Android.mk deleted file mode 100644 index 5053e7d64..000000000 --- a/ndk/sources/external/Android.mk +++ /dev/null @@ -1 +0,0 @@ -include $(call all-subdir-makefiles) diff --git a/ndk/sources/external/zlib/Android.mk b/ndk/sources/external/zlib/Android.mk deleted file mode 100644 index 88446a735..000000000 --- a/ndk/sources/external/zlib/Android.mk +++ /dev/null @@ -1,45 +0,0 @@ -# Copyright (C) 2009 The Android Open Source Project -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# - -# this is a very simple example that shows how to build a static library -# and an executable that links to it. -# - -LOCAL_PATH:= $(call my-dir) -include $(CLEAR_VARS) - -# measurements show that the ARM version of ZLib is about x1.17 faster -# than the thumb one... -LOCAL_ARM_MODE := arm - -LOCAL_SRC_FILES:= \ - adler32.c \ - compress.c \ - crc32.c \ - gzio.c \ - uncompr.c \ - deflate.c \ - trees.c \ - zutil.c \ - inflate.c \ - infback.c \ - inftrees.c \ - inffast.c - -LOCAL_MODULE:= libz - -LOCAL_CFLAGS+= -O3 -DUSE_MMAP - -include $(BUILD_STATIC_LIBRARY) diff --git a/ndk/sources/external/zlib/adler32.c b/ndk/sources/external/zlib/adler32.c deleted file mode 100644 index 007ba2627..000000000 --- a/ndk/sources/external/zlib/adler32.c +++ /dev/null @@ -1,149 +0,0 @@ -/* adler32.c -- compute the Adler-32 checksum of a data stream - * Copyright (C) 1995-2004 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* @(#) $Id$ */ - -#define ZLIB_INTERNAL -#include "zlib.h" - -#define BASE 65521UL /* largest prime smaller than 65536 */ -#define NMAX 5552 -/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ - -#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} -#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); -#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); -#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); -#define DO16(buf) DO8(buf,0); DO8(buf,8); - -/* use NO_DIVIDE if your processor does not do division in hardware */ -#ifdef NO_DIVIDE -# define MOD(a) \ - do { \ - if (a >= (BASE << 16)) a -= (BASE << 16); \ - if (a >= (BASE << 15)) a -= (BASE << 15); \ - if (a >= (BASE << 14)) a -= (BASE << 14); \ - if (a >= (BASE << 13)) a -= (BASE << 13); \ - if (a >= (BASE << 12)) a -= (BASE << 12); \ - if (a >= (BASE << 11)) a -= (BASE << 11); \ - if (a >= (BASE << 10)) a -= (BASE << 10); \ - if (a >= (BASE << 9)) a -= (BASE << 9); \ - if (a >= (BASE << 8)) a -= (BASE << 8); \ - if (a >= (BASE << 7)) a -= (BASE << 7); \ - if (a >= (BASE << 6)) a -= (BASE << 6); \ - if (a >= (BASE << 5)) a -= (BASE << 5); \ - if (a >= (BASE << 4)) a -= (BASE << 4); \ - if (a >= (BASE << 3)) a -= (BASE << 3); \ - if (a >= (BASE << 2)) a -= (BASE << 2); \ - if (a >= (BASE << 1)) a -= (BASE << 1); \ - if (a >= BASE) a -= BASE; \ - } while (0) -# define MOD4(a) \ - do { \ - if (a >= (BASE << 4)) a -= (BASE << 4); \ - if (a >= (BASE << 3)) a -= (BASE << 3); \ - if (a >= (BASE << 2)) a -= (BASE << 2); \ - if (a >= (BASE << 1)) a -= (BASE << 1); \ - if (a >= BASE) a -= BASE; \ - } while (0) -#else -# define MOD(a) a %= BASE -# define MOD4(a) a %= BASE -#endif - -/* ========================================================================= */ -uLong ZEXPORT adler32(adler, buf, len) - uLong adler; - const Bytef *buf; - uInt len; -{ - unsigned long sum2; - unsigned n; - - /* split Adler-32 into component sums */ - sum2 = (adler >> 16) & 0xffff; - adler &= 0xffff; - - /* in case user likes doing a byte at a time, keep it fast */ - if (len == 1) { - adler += buf[0]; - if (adler >= BASE) - adler -= BASE; - sum2 += adler; - if (sum2 >= BASE) - sum2 -= BASE; - return adler | (sum2 << 16); - } - - /* initial Adler-32 value (deferred check for len == 1 speed) */ - if (buf == Z_NULL) - return 1L; - - /* in case short lengths are provided, keep it somewhat fast */ - if (len < 16) { - while (len--) { - adler += *buf++; - sum2 += adler; - } - if (adler >= BASE) - adler -= BASE; - MOD4(sum2); /* only added so many BASE's */ - return adler | (sum2 << 16); - } - - /* do length NMAX blocks -- requires just one modulo operation */ - while (len >= NMAX) { - len -= NMAX; - n = NMAX / 16; /* NMAX is divisible by 16 */ - do { - DO16(buf); /* 16 sums unrolled */ - buf += 16; - } while (--n); - MOD(adler); - MOD(sum2); - } - - /* do remaining bytes (less than NMAX, still just one modulo) */ - if (len) { /* avoid modulos if none remaining */ - while (len >= 16) { - len -= 16; - DO16(buf); - buf += 16; - } - while (len--) { - adler += *buf++; - sum2 += adler; - } - MOD(adler); - MOD(sum2); - } - - /* return recombined sums */ - return adler | (sum2 << 16); -} - -/* ========================================================================= */ -uLong ZEXPORT adler32_combine(adler1, adler2, len2) - uLong adler1; - uLong adler2; - z_off_t len2; -{ - unsigned long sum1; - unsigned long sum2; - unsigned rem; - - /* the derivation of this formula is left as an exercise for the reader */ - rem = (unsigned)(len2 % BASE); - sum1 = adler1 & 0xffff; - sum2 = rem * sum1; - MOD(sum2); - sum1 += (adler2 & 0xffff) + BASE - 1; - sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem; - if (sum1 > BASE) sum1 -= BASE; - if (sum1 > BASE) sum1 -= BASE; - if (sum2 > (BASE << 1)) sum2 -= (BASE << 1); - if (sum2 > BASE) sum2 -= BASE; - return sum1 | (sum2 << 16); -} diff --git a/ndk/sources/external/zlib/compress.c b/ndk/sources/external/zlib/compress.c deleted file mode 100644 index df04f0148..000000000 --- a/ndk/sources/external/zlib/compress.c +++ /dev/null @@ -1,79 +0,0 @@ -/* compress.c -- compress a memory buffer - * Copyright (C) 1995-2003 Jean-loup Gailly. - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* @(#) $Id$ */ - -#define ZLIB_INTERNAL -#include "zlib.h" - -/* =========================================================================== - Compresses the source buffer into the destination buffer. The level - parameter has the same meaning as in deflateInit. sourceLen is the byte - length of the source buffer. Upon entry, destLen is the total size of the - destination buffer, which must be at least 0.1% larger than sourceLen plus - 12 bytes. Upon exit, destLen is the actual size of the compressed buffer. - - compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough - memory, Z_BUF_ERROR if there was not enough room in the output buffer, - Z_STREAM_ERROR if the level parameter is invalid. -*/ -int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) - Bytef *dest; - uLongf *destLen; - const Bytef *source; - uLong sourceLen; - int level; -{ - z_stream stream; - int err; - - stream.next_in = (Bytef*)source; - stream.avail_in = (uInt)sourceLen; -#ifdef MAXSEG_64K - /* Check for source > 64K on 16-bit machine: */ - if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; -#endif - stream.next_out = dest; - stream.avail_out = (uInt)*destLen; - if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; - - stream.zalloc = (alloc_func)0; - stream.zfree = (free_func)0; - stream.opaque = (voidpf)0; - - err = deflateInit(&stream, level); - if (err != Z_OK) return err; - - err = deflate(&stream, Z_FINISH); - if (err != Z_STREAM_END) { - deflateEnd(&stream); - return err == Z_OK ? Z_BUF_ERROR : err; - } - *destLen = stream.total_out; - - err = deflateEnd(&stream); - return err; -} - -/* =========================================================================== - */ -int ZEXPORT compress (dest, destLen, source, sourceLen) - Bytef *dest; - uLongf *destLen; - const Bytef *source; - uLong sourceLen; -{ - return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION); -} - -/* =========================================================================== - If the default memLevel or windowBits for deflateInit() is changed, then - this function needs to be updated. - */ -uLong ZEXPORT compressBound (sourceLen) - uLong sourceLen; -{ - return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + 11; -} diff --git a/ndk/sources/external/zlib/crc32.c b/ndk/sources/external/zlib/crc32.c deleted file mode 100644 index f658a9ef5..000000000 --- a/ndk/sources/external/zlib/crc32.c +++ /dev/null @@ -1,423 +0,0 @@ -/* crc32.c -- compute the CRC-32 of a data stream - * Copyright (C) 1995-2005 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - * - * Thanks to Rodney Brown for his contribution of faster - * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing - * tables for updating the shift register in one step with three exclusive-ors - * instead of four steps with four exclusive-ors. This results in about a - * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3. - */ - -/* @(#) $Id$ */ - -/* - Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore - protection on the static variables used to control the first-use generation - of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should - first call get_crc_table() to initialize the tables before allowing more than - one thread to use crc32(). - */ - -#ifdef MAKECRCH -# include -# ifndef DYNAMIC_CRC_TABLE -# define DYNAMIC_CRC_TABLE -# endif /* !DYNAMIC_CRC_TABLE */ -#endif /* MAKECRCH */ - -#include "zutil.h" /* for STDC and FAR definitions */ - -#define local static - -/* Find a four-byte integer type for crc32_little() and crc32_big(). */ -#ifndef NOBYFOUR -# ifdef STDC /* need ANSI C limits.h to determine sizes */ -# include -# define BYFOUR -# if (UINT_MAX == 0xffffffffUL) - typedef unsigned int u4; -# else -# if (ULONG_MAX == 0xffffffffUL) - typedef unsigned long u4; -# else -# if (USHRT_MAX == 0xffffffffUL) - typedef unsigned short u4; -# else -# undef BYFOUR /* can't find a four-byte integer type! */ -# endif -# endif -# endif -# endif /* STDC */ -#endif /* !NOBYFOUR */ - -/* Definitions for doing the crc four data bytes at a time. */ -#ifdef BYFOUR -# define REV(w) (((w)>>24)+(((w)>>8)&0xff00)+ \ - (((w)&0xff00)<<8)+(((w)&0xff)<<24)) - local unsigned long crc32_little OF((unsigned long, - const unsigned char FAR *, unsigned)); - local unsigned long crc32_big OF((unsigned long, - const unsigned char FAR *, unsigned)); -# define TBLS 8 -#else -# define TBLS 1 -#endif /* BYFOUR */ - -/* Local functions for crc concatenation */ -local unsigned long gf2_matrix_times OF((unsigned long *mat, - unsigned long vec)); -local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat)); - -#ifdef DYNAMIC_CRC_TABLE - -local volatile int crc_table_empty = 1; -local unsigned long FAR crc_table[TBLS][256]; -local void make_crc_table OF((void)); -#ifdef MAKECRCH - local void write_table OF((FILE *, const unsigned long FAR *)); -#endif /* MAKECRCH */ -/* - Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: - x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1. - - Polynomials over GF(2) are represented in binary, one bit per coefficient, - with the lowest powers in the most significant bit. Then adding polynomials - is just exclusive-or, and multiplying a polynomial by x is a right shift by - one. If we call the above polynomial p, and represent a byte as the - polynomial q, also with the lowest power in the most significant bit (so the - byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, - where a mod b means the remainder after dividing a by b. - - This calculation is done using the shift-register method of multiplying and - taking the remainder. The register is initialized to zero, and for each - incoming bit, x^32 is added mod p to the register if the bit is a one (where - x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by - x (which is shifting right by one and adding x^32 mod p if the bit shifted - out is a one). We start with the highest power (least significant bit) of - q and repeat for all eight bits of q. - - The first table is simply the CRC of all possible eight bit values. This is - all the information needed to generate CRCs on data a byte at a time for all - combinations of CRC register values and incoming bytes. The remaining tables - allow for word-at-a-time CRC calculation for both big-endian and little- - endian machines, where a word is four bytes. -*/ -local void make_crc_table() -{ - unsigned long c; - int n, k; - unsigned long poly; /* polynomial exclusive-or pattern */ - /* terms of polynomial defining this crc (except x^32): */ - static volatile int first = 1; /* flag to limit concurrent making */ - static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; - - /* See if another task is already doing this (not thread-safe, but better - than nothing -- significantly reduces duration of vulnerability in - case the advice about DYNAMIC_CRC_TABLE is ignored) */ - if (first) { - first = 0; - - /* make exclusive-or pattern from polynomial (0xedb88320UL) */ - poly = 0UL; - for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++) - poly |= 1UL << (31 - p[n]); - - /* generate a crc for every 8-bit value */ - for (n = 0; n < 256; n++) { - c = (unsigned long)n; - for (k = 0; k < 8; k++) - c = c & 1 ? poly ^ (c >> 1) : c >> 1; - crc_table[0][n] = c; - } - -#ifdef BYFOUR - /* generate crc for each value followed by one, two, and three zeros, - and then the byte reversal of those as well as the first table */ - for (n = 0; n < 256; n++) { - c = crc_table[0][n]; - crc_table[4][n] = REV(c); - for (k = 1; k < 4; k++) { - c = crc_table[0][c & 0xff] ^ (c >> 8); - crc_table[k][n] = c; - crc_table[k + 4][n] = REV(c); - } - } -#endif /* BYFOUR */ - - crc_table_empty = 0; - } - else { /* not first */ - /* wait for the other guy to finish (not efficient, but rare) */ - while (crc_table_empty) - ; - } - -#ifdef MAKECRCH - /* write out CRC tables to crc32.h */ - { - FILE *out; - - out = fopen("crc32.h", "w"); - if (out == NULL) return; - fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n"); - fprintf(out, " * Generated automatically by crc32.c\n */\n\n"); - fprintf(out, "local const unsigned long FAR "); - fprintf(out, "crc_table[TBLS][256] =\n{\n {\n"); - write_table(out, crc_table[0]); -# ifdef BYFOUR - fprintf(out, "#ifdef BYFOUR\n"); - for (k = 1; k < 8; k++) { - fprintf(out, " },\n {\n"); - write_table(out, crc_table[k]); - } - fprintf(out, "#endif\n"); -# endif /* BYFOUR */ - fprintf(out, " }\n};\n"); - fclose(out); - } -#endif /* MAKECRCH */ -} - -#ifdef MAKECRCH -local void write_table(out, table) - FILE *out; - const unsigned long FAR *table; -{ - int n; - - for (n = 0; n < 256; n++) - fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", table[n], - n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); -} -#endif /* MAKECRCH */ - -#else /* !DYNAMIC_CRC_TABLE */ -/* ======================================================================== - * Tables of CRC-32s of all single-byte values, made by make_crc_table(). - */ -#include "crc32.h" -#endif /* DYNAMIC_CRC_TABLE */ - -/* ========================================================================= - * This function can be used by asm versions of crc32() - */ -const unsigned long FAR * ZEXPORT get_crc_table() -{ -#ifdef DYNAMIC_CRC_TABLE - if (crc_table_empty) - make_crc_table(); -#endif /* DYNAMIC_CRC_TABLE */ - return (const unsigned long FAR *)crc_table; -} - -/* ========================================================================= */ -#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8) -#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 - -/* ========================================================================= */ -unsigned long ZEXPORT crc32(crc, buf, len) - unsigned long crc; - const unsigned char FAR *buf; - unsigned len; -{ - if (buf == Z_NULL) return 0UL; - -#ifdef DYNAMIC_CRC_TABLE - if (crc_table_empty) - make_crc_table(); -#endif /* DYNAMIC_CRC_TABLE */ - -#ifdef BYFOUR - if (sizeof(void *) == sizeof(ptrdiff_t)) { - u4 endian; - - endian = 1; - if (*((unsigned char *)(&endian))) - return crc32_little(crc, buf, len); - else - return crc32_big(crc, buf, len); - } -#endif /* BYFOUR */ - crc = crc ^ 0xffffffffUL; - while (len >= 8) { - DO8; - len -= 8; - } - if (len) do { - DO1; - } while (--len); - return crc ^ 0xffffffffUL; -} - -#ifdef BYFOUR - -/* ========================================================================= */ -#define DOLIT4 c ^= *buf4++; \ - c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \ - crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24] -#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4 - -/* ========================================================================= */ -local unsigned long crc32_little(crc, buf, len) - unsigned long crc; - const unsigned char FAR *buf; - unsigned len; -{ - register u4 c; - register const u4 FAR *buf4; - - c = (u4)crc; - c = ~c; - while (len && ((ptrdiff_t)buf & 3)) { - c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); - len--; - } - - buf4 = (const u4 FAR *)(const void FAR *)buf; - while (len >= 32) { - DOLIT32; - len -= 32; - } - while (len >= 4) { - DOLIT4; - len -= 4; - } - buf = (const unsigned char FAR *)buf4; - - if (len) do { - c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); - } while (--len); - c = ~c; - return (unsigned long)c; -} - -/* ========================================================================= */ -#define DOBIG4 c ^= *++buf4; \ - c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \ - crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24] -#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4 - -/* ========================================================================= */ -local unsigned long crc32_big(crc, buf, len) - unsigned long crc; - const unsigned char FAR *buf; - unsigned len; -{ - register u4 c; - register const u4 FAR *buf4; - - c = REV((u4)crc); - c = ~c; - while (len && ((ptrdiff_t)buf & 3)) { - c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); - len--; - } - - buf4 = (const u4 FAR *)(const void FAR *)buf; - buf4--; - while (len >= 32) { - DOBIG32; - len -= 32; - } - while (len >= 4) { - DOBIG4; - len -= 4; - } - buf4++; - buf = (const unsigned char FAR *)buf4; - - if (len) do { - c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); - } while (--len); - c = ~c; - return (unsigned long)(REV(c)); -} - -#endif /* BYFOUR */ - -#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */ - -/* ========================================================================= */ -local unsigned long gf2_matrix_times(mat, vec) - unsigned long *mat; - unsigned long vec; -{ - unsigned long sum; - - sum = 0; - while (vec) { - if (vec & 1) - sum ^= *mat; - vec >>= 1; - mat++; - } - return sum; -} - -/* ========================================================================= */ -local void gf2_matrix_square(square, mat) - unsigned long *square; - unsigned long *mat; -{ - int n; - - for (n = 0; n < GF2_DIM; n++) - square[n] = gf2_matrix_times(mat, mat[n]); -} - -/* ========================================================================= */ -uLong ZEXPORT crc32_combine(crc1, crc2, len2) - uLong crc1; - uLong crc2; - z_off_t len2; -{ - int n; - unsigned long row; - unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */ - unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */ - - /* degenerate case */ - if (len2 == 0) - return crc1; - - /* put operator for one zero bit in odd */ - odd[0] = 0xedb88320L; /* CRC-32 polynomial */ - row = 1; - for (n = 1; n < GF2_DIM; n++) { - odd[n] = row; - row <<= 1; - } - - /* put operator for two zero bits in even */ - gf2_matrix_square(even, odd); - - /* put operator for four zero bits in odd */ - gf2_matrix_square(odd, even); - - /* apply len2 zeros to crc1 (first square will put the operator for one - zero byte, eight zero bits, in even) */ - do { - /* apply zeros operator for this bit of len2 */ - gf2_matrix_square(even, odd); - if (len2 & 1) - crc1 = gf2_matrix_times(even, crc1); - len2 >>= 1; - - /* if no more bits set, then done */ - if (len2 == 0) - break; - - /* another iteration of the loop with odd and even swapped */ - gf2_matrix_square(odd, even); - if (len2 & 1) - crc1 = gf2_matrix_times(odd, crc1); - len2 >>= 1; - - /* if no more bits set, then done */ - } while (len2 != 0); - - /* return combined crc */ - crc1 ^= crc2; - return crc1; -} diff --git a/ndk/sources/external/zlib/crc32.h b/ndk/sources/external/zlib/crc32.h deleted file mode 100644 index 8053b6117..000000000 --- a/ndk/sources/external/zlib/crc32.h +++ /dev/null @@ -1,441 +0,0 @@ -/* crc32.h -- tables for rapid CRC calculation - * Generated automatically by crc32.c - */ - -local const unsigned long FAR crc_table[TBLS][256] = -{ - { - 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL, - 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL, - 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL, - 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL, - 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL, - 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL, - 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL, - 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL, - 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL, - 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL, - 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL, - 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL, - 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL, - 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL, - 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL, - 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL, - 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL, - 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL, - 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL, - 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL, - 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL, - 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL, - 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL, - 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL, - 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL, - 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL, - 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL, - 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL, - 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL, - 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL, - 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL, - 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL, - 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL, - 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL, - 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL, - 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL, - 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL, - 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL, - 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL, - 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL, - 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL, - 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL, - 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL, - 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL, - 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL, - 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL, - 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL, - 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL, - 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL, - 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL, - 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL, - 0x2d02ef8dUL -#ifdef BYFOUR - }, - { - 0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL, - 0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL, - 0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL, - 0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL, - 0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL, - 0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL, - 0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL, - 0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL, - 0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL, - 0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL, - 0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL, - 0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL, - 0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL, - 0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL, - 0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL, - 0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL, - 0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL, - 0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL, - 0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL, - 0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL, - 0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL, - 0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL, - 0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL, - 0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL, - 0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL, - 0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL, - 0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL, - 0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL, - 0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL, - 0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL, - 0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL, - 0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL, - 0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL, - 0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL, - 0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL, - 0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL, - 0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL, - 0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL, - 0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL, - 0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL, - 0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL, - 0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL, - 0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL, - 0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL, - 0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL, - 0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL, - 0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL, - 0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL, - 0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL, - 0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL, - 0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL, - 0x9324fd72UL - }, - { - 0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL, - 0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL, - 0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL, - 0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL, - 0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL, - 0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL, - 0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL, - 0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL, - 0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL, - 0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL, - 0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL, - 0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL, - 0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL, - 0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL, - 0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL, - 0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL, - 0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL, - 0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL, - 0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL, - 0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL, - 0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL, - 0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL, - 0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL, - 0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL, - 0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL, - 0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL, - 0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL, - 0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL, - 0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL, - 0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL, - 0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL, - 0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL, - 0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL, - 0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL, - 0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL, - 0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL, - 0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL, - 0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL, - 0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL, - 0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL, - 0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL, - 0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL, - 0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL, - 0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL, - 0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL, - 0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL, - 0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL, - 0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL, - 0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL, - 0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL, - 0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL, - 0xbe9834edUL - }, - { - 0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL, - 0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL, - 0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL, - 0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL, - 0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL, - 0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL, - 0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL, - 0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL, - 0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL, - 0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL, - 0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL, - 0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL, - 0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL, - 0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL, - 0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL, - 0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL, - 0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL, - 0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL, - 0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL, - 0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL, - 0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL, - 0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL, - 0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL, - 0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL, - 0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL, - 0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL, - 0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL, - 0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL, - 0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL, - 0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL, - 0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL, - 0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL, - 0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL, - 0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL, - 0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL, - 0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL, - 0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL, - 0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL, - 0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL, - 0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL, - 0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL, - 0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL, - 0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL, - 0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL, - 0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL, - 0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL, - 0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL, - 0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL, - 0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL, - 0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL, - 0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL, - 0xde0506f1UL - }, - { - 0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL, - 0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL, - 0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL, - 0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL, - 0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL, - 0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL, - 0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL, - 0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL, - 0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL, - 0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL, - 0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL, - 0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL, - 0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL, - 0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL, - 0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL, - 0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL, - 0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL, - 0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL, - 0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL, - 0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL, - 0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL, - 0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL, - 0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL, - 0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL, - 0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL, - 0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL, - 0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL, - 0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL, - 0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL, - 0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL, - 0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL, - 0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL, - 0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL, - 0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL, - 0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL, - 0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL, - 0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL, - 0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL, - 0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL, - 0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL, - 0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL, - 0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL, - 0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL, - 0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL, - 0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL, - 0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL, - 0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL, - 0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL, - 0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL, - 0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL, - 0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL, - 0x8def022dUL - }, - { - 0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL, - 0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL, - 0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL, - 0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL, - 0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL, - 0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL, - 0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL, - 0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL, - 0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL, - 0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL, - 0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL, - 0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL, - 0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL, - 0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL, - 0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL, - 0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL, - 0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL, - 0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL, - 0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL, - 0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL, - 0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL, - 0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL, - 0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL, - 0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL, - 0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL, - 0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL, - 0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL, - 0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL, - 0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL, - 0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL, - 0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL, - 0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL, - 0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL, - 0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL, - 0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL, - 0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL, - 0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL, - 0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL, - 0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL, - 0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL, - 0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL, - 0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL, - 0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL, - 0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL, - 0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL, - 0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL, - 0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL, - 0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL, - 0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL, - 0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL, - 0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL, - 0x72fd2493UL - }, - { - 0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL, - 0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL, - 0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL, - 0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL, - 0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL, - 0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL, - 0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL, - 0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL, - 0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL, - 0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL, - 0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL, - 0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL, - 0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL, - 0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL, - 0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL, - 0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL, - 0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL, - 0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL, - 0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL, - 0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL, - 0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL, - 0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL, - 0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL, - 0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL, - 0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL, - 0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL, - 0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL, - 0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL, - 0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL, - 0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL, - 0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL, - 0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL, - 0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL, - 0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL, - 0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL, - 0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL, - 0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL, - 0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL, - 0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL, - 0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL, - 0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL, - 0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL, - 0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL, - 0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL, - 0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL, - 0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL, - 0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL, - 0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL, - 0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL, - 0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL, - 0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL, - 0xed3498beUL - }, - { - 0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL, - 0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL, - 0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL, - 0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL, - 0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL, - 0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL, - 0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL, - 0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL, - 0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL, - 0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL, - 0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL, - 0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL, - 0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL, - 0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL, - 0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL, - 0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL, - 0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL, - 0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL, - 0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL, - 0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL, - 0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL, - 0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL, - 0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL, - 0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL, - 0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL, - 0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL, - 0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL, - 0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL, - 0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL, - 0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL, - 0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL, - 0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL, - 0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL, - 0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL, - 0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL, - 0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL, - 0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL, - 0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL, - 0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL, - 0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL, - 0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL, - 0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL, - 0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL, - 0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL, - 0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL, - 0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL, - 0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL, - 0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL, - 0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL, - 0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL, - 0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL, - 0xf10605deUL -#endif - } -}; diff --git a/ndk/sources/external/zlib/deflate.c b/ndk/sources/external/zlib/deflate.c deleted file mode 100644 index 29ce1f64a..000000000 --- a/ndk/sources/external/zlib/deflate.c +++ /dev/null @@ -1,1736 +0,0 @@ -/* deflate.c -- compress data using the deflation algorithm - * Copyright (C) 1995-2005 Jean-loup Gailly. - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* - * ALGORITHM - * - * The "deflation" process depends on being able to identify portions - * of the input text which are identical to earlier input (within a - * sliding window trailing behind the input currently being processed). - * - * The most straightforward technique turns out to be the fastest for - * most input files: try all possible matches and select the longest. - * The key feature of this algorithm is that insertions into the string - * dictionary are very simple and thus fast, and deletions are avoided - * completely. Insertions are performed at each input character, whereas - * string matches are performed only when the previous match ends. So it - * is preferable to spend more time in matches to allow very fast string - * insertions and avoid deletions. The matching algorithm for small - * strings is inspired from that of Rabin & Karp. A brute force approach - * is used to find longer strings when a small match has been found. - * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze - * (by Leonid Broukhis). - * A previous version of this file used a more sophisticated algorithm - * (by Fiala and Greene) which is guaranteed to run in linear amortized - * time, but has a larger average cost, uses more memory and is patented. - * However the F&G algorithm may be faster for some highly redundant - * files if the parameter max_chain_length (described below) is too large. - * - * ACKNOWLEDGEMENTS - * - * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and - * I found it in 'freeze' written by Leonid Broukhis. - * Thanks to many people for bug reports and testing. - * - * REFERENCES - * - * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification". - * Available in http://www.ietf.org/rfc/rfc1951.txt - * - * A description of the Rabin and Karp algorithm is given in the book - * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. - * - * Fiala,E.R., and Greene,D.H. - * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 - * - */ - -/* @(#) $Id$ */ - -#include "deflate.h" - -const char deflate_copyright[] = - " deflate 1.2.3 Copyright 1995-2005 Jean-loup Gailly "; -/* - If you use the zlib library in a product, an acknowledgment is welcome - in the documentation of your product. If for some reason you cannot - include such an acknowledgment, I would appreciate that you keep this - copyright string in the executable of your product. - */ - -/* =========================================================================== - * Function prototypes. - */ -typedef enum { - need_more, /* block not completed, need more input or more output */ - block_done, /* block flush performed */ - finish_started, /* finish started, need only more output at next deflate */ - finish_done /* finish done, accept no more input or output */ -} block_state; - -typedef block_state (*compress_func) OF((deflate_state *s, int flush)); -/* Compression function. Returns the block state after the call. */ - -local void fill_window OF((deflate_state *s)); -local block_state deflate_stored OF((deflate_state *s, int flush)); -local block_state deflate_fast OF((deflate_state *s, int flush)); -#ifndef FASTEST -local block_state deflate_slow OF((deflate_state *s, int flush)); -#endif -local void lm_init OF((deflate_state *s)); -local void putShortMSB OF((deflate_state *s, uInt b)); -local void flush_pending OF((z_streamp strm)); -local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); -#ifndef FASTEST -#ifdef ASMV - void match_init OF((void)); /* asm code initialization */ - uInt longest_match OF((deflate_state *s, IPos cur_match)); -#else -local uInt longest_match OF((deflate_state *s, IPos cur_match)); -#endif -#endif -local uInt longest_match_fast OF((deflate_state *s, IPos cur_match)); - -#ifdef DEBUG -local void check_match OF((deflate_state *s, IPos start, IPos match, - int length)); -#endif - -/* =========================================================================== - * Local data - */ - -#define NIL 0 -/* Tail of hash chains */ - -#ifndef TOO_FAR -# define TOO_FAR 4096 -#endif -/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ - -#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) -/* Minimum amount of lookahead, except at the end of the input file. - * See deflate.c for comments about the MIN_MATCH+1. - */ - -/* Values for max_lazy_match, good_match and max_chain_length, depending on - * the desired pack level (0..9). The values given below have been tuned to - * exclude worst case performance for pathological files. Better values may be - * found for specific files. - */ -typedef struct config_s { - ush good_length; /* reduce lazy search above this match length */ - ush max_lazy; /* do not perform lazy search above this match length */ - ush nice_length; /* quit search above this match length */ - ush max_chain; - compress_func func; -} config; - -#ifdef FASTEST -local const config configuration_table[2] = { -/* good lazy nice chain */ -/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ -/* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */ -#else -local const config configuration_table[10] = { -/* good lazy nice chain */ -/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ -/* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */ -/* 2 */ {4, 5, 16, 8, deflate_fast}, -/* 3 */ {4, 6, 32, 32, deflate_fast}, - -/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */ -/* 5 */ {8, 16, 32, 32, deflate_slow}, -/* 6 */ {8, 16, 128, 128, deflate_slow}, -/* 7 */ {8, 32, 128, 256, deflate_slow}, -/* 8 */ {32, 128, 258, 1024, deflate_slow}, -/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */ -#endif - -/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 - * For deflate_fast() (levels <= 3) good is ignored and lazy has a different - * meaning. - */ - -#define EQUAL 0 -/* result of memcmp for equal strings */ - -#ifndef NO_DUMMY_DECL -struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ -#endif - -/* =========================================================================== - * Update a hash value with the given input byte - * IN assertion: all calls to to UPDATE_HASH are made with consecutive - * input characters, so that a running hash key can be computed from the - * previous key instead of complete recalculation each time. - */ -#define UPDATE_HASH(s,h,c) (h = (((h)<hash_shift) ^ (c)) & s->hash_mask) - - -/* =========================================================================== - * Insert string str in the dictionary and set match_head to the previous head - * of the hash chain (the most recent string with same hash key). Return - * the previous length of the hash chain. - * If this file is compiled with -DFASTEST, the compression level is forced - * to 1, and no hash chains are maintained. - * IN assertion: all calls to to INSERT_STRING are made with consecutive - * input characters and the first MIN_MATCH bytes of str are valid - * (except for the last MIN_MATCH-1 bytes of the input file). - */ -#ifdef FASTEST -#define INSERT_STRING(s, str, match_head) \ - (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ - match_head = s->head[s->ins_h], \ - s->head[s->ins_h] = (Pos)(str)) -#else -#define INSERT_STRING(s, str, match_head) \ - (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ - match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \ - s->head[s->ins_h] = (Pos)(str)) -#endif - -/* =========================================================================== - * Initialize the hash table (avoiding 64K overflow for 16 bit systems). - * prev[] will be initialized on the fly. - */ -#define CLEAR_HASH(s) \ - s->head[s->hash_size-1] = NIL; \ - zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); - -/* ========================================================================= */ -int ZEXPORT deflateInit_(strm, level, version, stream_size) - z_streamp strm; - int level; - const char *version; - int stream_size; -{ - return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, - Z_DEFAULT_STRATEGY, version, stream_size); - /* To do: ignore strm->next_in if we use it as window */ -} - -/* ========================================================================= */ -int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, - version, stream_size) - z_streamp strm; - int level; - int method; - int windowBits; - int memLevel; - int strategy; - const char *version; - int stream_size; -{ - deflate_state *s; - int wrap = 1; - static const char my_version[] = ZLIB_VERSION; - - ushf *overlay; - /* We overlay pending_buf and d_buf+l_buf. This works since the average - * output size for (length,distance) codes is <= 24 bits. - */ - - if (version == Z_NULL || version[0] != my_version[0] || - stream_size != sizeof(z_stream)) { - return Z_VERSION_ERROR; - } - if (strm == Z_NULL) return Z_STREAM_ERROR; - - strm->msg = Z_NULL; - if (strm->zalloc == (alloc_func)0) { - strm->zalloc = zcalloc; - strm->opaque = (voidpf)0; - } - if (strm->zfree == (free_func)0) strm->zfree = zcfree; - -#ifdef FASTEST - if (level != 0) level = 1; -#else - if (level == Z_DEFAULT_COMPRESSION) level = 6; -#endif - - if (windowBits < 0) { /* suppress zlib wrapper */ - wrap = 0; - windowBits = -windowBits; - } -#ifdef GZIP - else if (windowBits > 15) { - wrap = 2; /* write gzip wrapper instead */ - windowBits -= 16; - } -#endif - if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || - windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || - strategy < 0 || strategy > Z_FIXED) { - return Z_STREAM_ERROR; - } - if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */ - s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state)); - if (s == Z_NULL) return Z_MEM_ERROR; - strm->state = (struct internal_state FAR *)s; - s->strm = strm; - - s->wrap = wrap; - s->gzhead = Z_NULL; - s->w_bits = windowBits; - s->w_size = 1 << s->w_bits; - s->w_mask = s->w_size - 1; - - s->hash_bits = memLevel + 7; - s->hash_size = 1 << s->hash_bits; - s->hash_mask = s->hash_size - 1; - s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); - - s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); - s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); - s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); - - s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ - - overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); - s->pending_buf = (uchf *) overlay; - s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L); - - if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || - s->pending_buf == Z_NULL) { - s->status = FINISH_STATE; - strm->msg = (char*)ERR_MSG(Z_MEM_ERROR); - deflateEnd (strm); - return Z_MEM_ERROR; - } - s->d_buf = overlay + s->lit_bufsize/sizeof(ush); - s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; - - s->level = level; - s->strategy = strategy; - s->method = (Byte)method; - - return deflateReset(strm); -} - -/* ========================================================================= */ -int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) - z_streamp strm; - const Bytef *dictionary; - uInt dictLength; -{ - deflate_state *s; - uInt length = dictLength; - uInt n; - IPos hash_head = 0; - - if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL || - strm->state->wrap == 2 || - (strm->state->wrap == 1 && strm->state->status != INIT_STATE)) - return Z_STREAM_ERROR; - - s = strm->state; - if (s->wrap) - strm->adler = adler32(strm->adler, dictionary, dictLength); - - if (length < MIN_MATCH) return Z_OK; - if (length > MAX_DIST(s)) { - length = MAX_DIST(s); - dictionary += dictLength - length; /* use the tail of the dictionary */ - } - zmemcpy(s->window, dictionary, length); - s->strstart = length; - s->block_start = (long)length; - - /* Insert all strings in the hash table (except for the last two bytes). - * s->lookahead stays null, so s->ins_h will be recomputed at the next - * call of fill_window. - */ - s->ins_h = s->window[0]; - UPDATE_HASH(s, s->ins_h, s->window[1]); - for (n = 0; n <= length - MIN_MATCH; n++) { - INSERT_STRING(s, n, hash_head); - } - if (hash_head) hash_head = 0; /* to make compiler happy */ - return Z_OK; -} - -/* ========================================================================= */ -int ZEXPORT deflateReset (strm) - z_streamp strm; -{ - deflate_state *s; - - if (strm == Z_NULL || strm->state == Z_NULL || - strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) { - return Z_STREAM_ERROR; - } - - strm->total_in = strm->total_out = 0; - strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */ - strm->data_type = Z_UNKNOWN; - - s = (deflate_state *)strm->state; - s->pending = 0; - s->pending_out = s->pending_buf; - - if (s->wrap < 0) { - s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */ - } - s->status = s->wrap ? INIT_STATE : BUSY_STATE; - strm->adler = -#ifdef GZIP - s->wrap == 2 ? crc32(0L, Z_NULL, 0) : -#endif - adler32(0L, Z_NULL, 0); - s->last_flush = Z_NO_FLUSH; - - _tr_init(s); - lm_init(s); - - return Z_OK; -} - -/* ========================================================================= */ -int ZEXPORT deflateSetHeader (strm, head) - z_streamp strm; - gz_headerp head; -{ - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - if (strm->state->wrap != 2) return Z_STREAM_ERROR; - strm->state->gzhead = head; - return Z_OK; -} - -/* ========================================================================= */ -int ZEXPORT deflatePrime (strm, bits, value) - z_streamp strm; - int bits; - int value; -{ - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - strm->state->bi_valid = bits; - strm->state->bi_buf = (ush)(value & ((1 << bits) - 1)); - return Z_OK; -} - -/* ========================================================================= */ -int ZEXPORT deflateParams(strm, level, strategy) - z_streamp strm; - int level; - int strategy; -{ - deflate_state *s; - compress_func func; - int err = Z_OK; - - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - s = strm->state; - -#ifdef FASTEST - if (level != 0) level = 1; -#else - if (level == Z_DEFAULT_COMPRESSION) level = 6; -#endif - if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { - return Z_STREAM_ERROR; - } - func = configuration_table[s->level].func; - - if (func != configuration_table[level].func && strm->total_in != 0) { - /* Flush the last buffer: */ - err = deflate(strm, Z_PARTIAL_FLUSH); - } - if (s->level != level) { - s->level = level; - s->max_lazy_match = configuration_table[level].max_lazy; - s->good_match = configuration_table[level].good_length; - s->nice_match = configuration_table[level].nice_length; - s->max_chain_length = configuration_table[level].max_chain; - } - s->strategy = strategy; - return err; -} - -/* ========================================================================= */ -int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain) - z_streamp strm; - int good_length; - int max_lazy; - int nice_length; - int max_chain; -{ - deflate_state *s; - - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - s = strm->state; - s->good_match = good_length; - s->max_lazy_match = max_lazy; - s->nice_match = nice_length; - s->max_chain_length = max_chain; - return Z_OK; -} - -/* ========================================================================= - * For the default windowBits of 15 and memLevel of 8, this function returns - * a close to exact, as well as small, upper bound on the compressed size. - * They are coded as constants here for a reason--if the #define's are - * changed, then this function needs to be changed as well. The return - * value for 15 and 8 only works for those exact settings. - * - * For any setting other than those defaults for windowBits and memLevel, - * the value returned is a conservative worst case for the maximum expansion - * resulting from using fixed blocks instead of stored blocks, which deflate - * can emit on compressed data for some combinations of the parameters. - * - * This function could be more sophisticated to provide closer upper bounds - * for every combination of windowBits and memLevel, as well as wrap. - * But even the conservative upper bound of about 14% expansion does not - * seem onerous for output buffer allocation. - */ -uLong ZEXPORT deflateBound(strm, sourceLen) - z_streamp strm; - uLong sourceLen; -{ - deflate_state *s; - uLong destLen; - - /* conservative upper bound */ - destLen = sourceLen + - ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 11; - - /* if can't get parameters, return conservative bound */ - if (strm == Z_NULL || strm->state == Z_NULL) - return destLen; - - /* if not default parameters, return conservative bound */ - s = strm->state; - if (s->w_bits != 15 || s->hash_bits != 8 + 7) - return destLen; - - /* default settings: return tight bound for that case */ - return compressBound(sourceLen); -} - -/* ========================================================================= - * Put a short in the pending buffer. The 16-bit value is put in MSB order. - * IN assertion: the stream state is correct and there is enough room in - * pending_buf. - */ -local void putShortMSB (s, b) - deflate_state *s; - uInt b; -{ - put_byte(s, (Byte)(b >> 8)); - put_byte(s, (Byte)(b & 0xff)); -} - -/* ========================================================================= - * Flush as much pending output as possible. All deflate() output goes - * through this function so some applications may wish to modify it - * to avoid allocating a large strm->next_out buffer and copying into it. - * (See also read_buf()). - */ -local void flush_pending(strm) - z_streamp strm; -{ - unsigned len = strm->state->pending; - - if (len > strm->avail_out) len = strm->avail_out; - if (len == 0) return; - - zmemcpy(strm->next_out, strm->state->pending_out, len); - strm->next_out += len; - strm->state->pending_out += len; - strm->total_out += len; - strm->avail_out -= len; - strm->state->pending -= len; - if (strm->state->pending == 0) { - strm->state->pending_out = strm->state->pending_buf; - } -} - -/* ========================================================================= */ -int ZEXPORT deflate (strm, flush) - z_streamp strm; - int flush; -{ - int old_flush; /* value of flush param for previous deflate call */ - deflate_state *s; - - if (strm == Z_NULL || strm->state == Z_NULL || - flush > Z_FINISH || flush < 0) { - return Z_STREAM_ERROR; - } - s = strm->state; - - if (strm->next_out == Z_NULL || - (strm->next_in == Z_NULL && strm->avail_in != 0) || - (s->status == FINISH_STATE && flush != Z_FINISH)) { - ERR_RETURN(strm, Z_STREAM_ERROR); - } - if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); - - s->strm = strm; /* just in case */ - old_flush = s->last_flush; - s->last_flush = flush; - - /* Write the header */ - if (s->status == INIT_STATE) { -#ifdef GZIP - if (s->wrap == 2) { - strm->adler = crc32(0L, Z_NULL, 0); - put_byte(s, 31); - put_byte(s, 139); - put_byte(s, 8); - if (s->gzhead == NULL) { - put_byte(s, 0); - put_byte(s, 0); - put_byte(s, 0); - put_byte(s, 0); - put_byte(s, 0); - put_byte(s, s->level == 9 ? 2 : - (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? - 4 : 0)); - put_byte(s, OS_CODE); - s->status = BUSY_STATE; - } - else { - put_byte(s, (s->gzhead->text ? 1 : 0) + - (s->gzhead->hcrc ? 2 : 0) + - (s->gzhead->extra == Z_NULL ? 0 : 4) + - (s->gzhead->name == Z_NULL ? 0 : 8) + - (s->gzhead->comment == Z_NULL ? 0 : 16) - ); - put_byte(s, (Byte)(s->gzhead->time & 0xff)); - put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff)); - put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff)); - put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff)); - put_byte(s, s->level == 9 ? 2 : - (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? - 4 : 0)); - put_byte(s, s->gzhead->os & 0xff); - if (s->gzhead->extra != NULL) { - put_byte(s, s->gzhead->extra_len & 0xff); - put_byte(s, (s->gzhead->extra_len >> 8) & 0xff); - } - if (s->gzhead->hcrc) - strm->adler = crc32(strm->adler, s->pending_buf, - s->pending); - s->gzindex = 0; - s->status = EXTRA_STATE; - } - } - else -#endif - { - uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; - uInt level_flags; - - if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) - level_flags = 0; - else if (s->level < 6) - level_flags = 1; - else if (s->level == 6) - level_flags = 2; - else - level_flags = 3; - header |= (level_flags << 6); - if (s->strstart != 0) header |= PRESET_DICT; - header += 31 - (header % 31); - - s->status = BUSY_STATE; - putShortMSB(s, header); - - /* Save the adler32 of the preset dictionary: */ - if (s->strstart != 0) { - putShortMSB(s, (uInt)(strm->adler >> 16)); - putShortMSB(s, (uInt)(strm->adler & 0xffff)); - } - strm->adler = adler32(0L, Z_NULL, 0); - } - } -#ifdef GZIP - if (s->status == EXTRA_STATE) { - if (s->gzhead->extra != NULL) { - uInt beg = s->pending; /* start of bytes to update crc */ - - while (s->gzindex < (s->gzhead->extra_len & 0xffff)) { - if (s->pending == s->pending_buf_size) { - if (s->gzhead->hcrc && s->pending > beg) - strm->adler = crc32(strm->adler, s->pending_buf + beg, - s->pending - beg); - flush_pending(strm); - beg = s->pending; - if (s->pending == s->pending_buf_size) - break; - } - put_byte(s, s->gzhead->extra[s->gzindex]); - s->gzindex++; - } - if (s->gzhead->hcrc && s->pending > beg) - strm->adler = crc32(strm->adler, s->pending_buf + beg, - s->pending - beg); - if (s->gzindex == s->gzhead->extra_len) { - s->gzindex = 0; - s->status = NAME_STATE; - } - } - else - s->status = NAME_STATE; - } - if (s->status == NAME_STATE) { - if (s->gzhead->name != NULL) { - uInt beg = s->pending; /* start of bytes to update crc */ - int val; - - do { - if (s->pending == s->pending_buf_size) { - if (s->gzhead->hcrc && s->pending > beg) - strm->adler = crc32(strm->adler, s->pending_buf + beg, - s->pending - beg); - flush_pending(strm); - beg = s->pending; - if (s->pending == s->pending_buf_size) { - val = 1; - break; - } - } - val = s->gzhead->name[s->gzindex++]; - put_byte(s, val); - } while (val != 0); - if (s->gzhead->hcrc && s->pending > beg) - strm->adler = crc32(strm->adler, s->pending_buf + beg, - s->pending - beg); - if (val == 0) { - s->gzindex = 0; - s->status = COMMENT_STATE; - } - } - else - s->status = COMMENT_STATE; - } - if (s->status == COMMENT_STATE) { - if (s->gzhead->comment != NULL) { - uInt beg = s->pending; /* start of bytes to update crc */ - int val; - - do { - if (s->pending == s->pending_buf_size) { - if (s->gzhead->hcrc && s->pending > beg) - strm->adler = crc32(strm->adler, s->pending_buf + beg, - s->pending - beg); - flush_pending(strm); - beg = s->pending; - if (s->pending == s->pending_buf_size) { - val = 1; - break; - } - } - val = s->gzhead->comment[s->gzindex++]; - put_byte(s, val); - } while (val != 0); - if (s->gzhead->hcrc && s->pending > beg) - strm->adler = crc32(strm->adler, s->pending_buf + beg, - s->pending - beg); - if (val == 0) - s->status = HCRC_STATE; - } - else - s->status = HCRC_STATE; - } - if (s->status == HCRC_STATE) { - if (s->gzhead->hcrc) { - if (s->pending + 2 > s->pending_buf_size) - flush_pending(strm); - if (s->pending + 2 <= s->pending_buf_size) { - put_byte(s, (Byte)(strm->adler & 0xff)); - put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); - strm->adler = crc32(0L, Z_NULL, 0); - s->status = BUSY_STATE; - } - } - else - s->status = BUSY_STATE; - } -#endif - - /* Flush as much pending output as possible */ - if (s->pending != 0) { - flush_pending(strm); - if (strm->avail_out == 0) { - /* Since avail_out is 0, deflate will be called again with - * more output space, but possibly with both pending and - * avail_in equal to zero. There won't be anything to do, - * but this is not an error situation so make sure we - * return OK instead of BUF_ERROR at next call of deflate: - */ - s->last_flush = -1; - return Z_OK; - } - - /* Make sure there is something to do and avoid duplicate consecutive - * flushes. For repeated and useless calls with Z_FINISH, we keep - * returning Z_STREAM_END instead of Z_BUF_ERROR. - */ - } else if (strm->avail_in == 0 && flush <= old_flush && - flush != Z_FINISH) { - ERR_RETURN(strm, Z_BUF_ERROR); - } - - /* User must not provide more input after the first FINISH: */ - if (s->status == FINISH_STATE && strm->avail_in != 0) { - ERR_RETURN(strm, Z_BUF_ERROR); - } - - /* Start a new block or continue the current one. - */ - if (strm->avail_in != 0 || s->lookahead != 0 || - (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { - block_state bstate; - - bstate = (*(configuration_table[s->level].func))(s, flush); - - if (bstate == finish_started || bstate == finish_done) { - s->status = FINISH_STATE; - } - if (bstate == need_more || bstate == finish_started) { - if (strm->avail_out == 0) { - s->last_flush = -1; /* avoid BUF_ERROR next call, see above */ - } - return Z_OK; - /* If flush != Z_NO_FLUSH && avail_out == 0, the next call - * of deflate should use the same flush parameter to make sure - * that the flush is complete. So we don't have to output an - * empty block here, this will be done at next call. This also - * ensures that for a very small output buffer, we emit at most - * one empty block. - */ - } - if (bstate == block_done) { - if (flush == Z_PARTIAL_FLUSH) { - _tr_align(s); - } else { /* FULL_FLUSH or SYNC_FLUSH */ - _tr_stored_block(s, (char*)0, 0L, 0); - /* For a full flush, this empty block will be recognized - * as a special marker by inflate_sync(). - */ - if (flush == Z_FULL_FLUSH) { - CLEAR_HASH(s); /* forget history */ - } - } - flush_pending(strm); - if (strm->avail_out == 0) { - s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ - return Z_OK; - } - } - } - Assert(strm->avail_out > 0, "bug2"); - - if (flush != Z_FINISH) return Z_OK; - if (s->wrap <= 0) return Z_STREAM_END; - - /* Write the trailer */ -#ifdef GZIP - if (s->wrap == 2) { - put_byte(s, (Byte)(strm->adler & 0xff)); - put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); - put_byte(s, (Byte)((strm->adler >> 16) & 0xff)); - put_byte(s, (Byte)((strm->adler >> 24) & 0xff)); - put_byte(s, (Byte)(strm->total_in & 0xff)); - put_byte(s, (Byte)((strm->total_in >> 8) & 0xff)); - put_byte(s, (Byte)((strm->total_in >> 16) & 0xff)); - put_byte(s, (Byte)((strm->total_in >> 24) & 0xff)); - } - else -#endif - { - putShortMSB(s, (uInt)(strm->adler >> 16)); - putShortMSB(s, (uInt)(strm->adler & 0xffff)); - } - flush_pending(strm); - /* If avail_out is zero, the application will call deflate again - * to flush the rest. - */ - if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */ - return s->pending != 0 ? Z_OK : Z_STREAM_END; -} - -/* ========================================================================= */ -int ZEXPORT deflateEnd (strm) - z_streamp strm; -{ - int status; - - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - - status = strm->state->status; - if (status != INIT_STATE && - status != EXTRA_STATE && - status != NAME_STATE && - status != COMMENT_STATE && - status != HCRC_STATE && - status != BUSY_STATE && - status != FINISH_STATE) { - return Z_STREAM_ERROR; - } - - /* Deallocate in reverse order of allocations: */ - TRY_FREE(strm, strm->state->pending_buf); - TRY_FREE(strm, strm->state->head); - TRY_FREE(strm, strm->state->prev); - TRY_FREE(strm, strm->state->window); - - ZFREE(strm, strm->state); - strm->state = Z_NULL; - - return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; -} - -/* ========================================================================= - * Copy the source state to the destination state. - * To simplify the source, this is not supported for 16-bit MSDOS (which - * doesn't have enough memory anyway to duplicate compression states). - */ -int ZEXPORT deflateCopy (dest, source) - z_streamp dest; - z_streamp source; -{ -#ifdef MAXSEG_64K - return Z_STREAM_ERROR; -#else - deflate_state *ds; - deflate_state *ss; - ushf *overlay; - - - if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { - return Z_STREAM_ERROR; - } - - ss = source->state; - - zmemcpy(dest, source, sizeof(z_stream)); - - ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state)); - if (ds == Z_NULL) return Z_MEM_ERROR; - dest->state = (struct internal_state FAR *) ds; - zmemcpy(ds, ss, sizeof(deflate_state)); - ds->strm = dest; - - ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); - ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); - ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); - overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2); - ds->pending_buf = (uchf *) overlay; - - if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || - ds->pending_buf == Z_NULL) { - deflateEnd (dest); - return Z_MEM_ERROR; - } - /* following zmemcpy do not work for 16-bit MSDOS */ - zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); - zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos)); - zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos)); - zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); - - ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); - ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush); - ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize; - - ds->l_desc.dyn_tree = ds->dyn_ltree; - ds->d_desc.dyn_tree = ds->dyn_dtree; - ds->bl_desc.dyn_tree = ds->bl_tree; - - return Z_OK; -#endif /* MAXSEG_64K */ -} - -/* =========================================================================== - * Read a new buffer from the current input stream, update the adler32 - * and total number of bytes read. All deflate() input goes through - * this function so some applications may wish to modify it to avoid - * allocating a large strm->next_in buffer and copying from it. - * (See also flush_pending()). - */ -local int read_buf(strm, buf, size) - z_streamp strm; - Bytef *buf; - unsigned size; -{ - unsigned len = strm->avail_in; - - if (len > size) len = size; - if (len == 0) return 0; - - strm->avail_in -= len; - - if (strm->state->wrap == 1) { - strm->adler = adler32(strm->adler, strm->next_in, len); - } -#ifdef GZIP - else if (strm->state->wrap == 2) { - strm->adler = crc32(strm->adler, strm->next_in, len); - } -#endif - zmemcpy(buf, strm->next_in, len); - strm->next_in += len; - strm->total_in += len; - - return (int)len; -} - -/* =========================================================================== - * Initialize the "longest match" routines for a new zlib stream - */ -local void lm_init (s) - deflate_state *s; -{ - s->window_size = (ulg)2L*s->w_size; - - CLEAR_HASH(s); - - /* Set the default configuration parameters: - */ - s->max_lazy_match = configuration_table[s->level].max_lazy; - s->good_match = configuration_table[s->level].good_length; - s->nice_match = configuration_table[s->level].nice_length; - s->max_chain_length = configuration_table[s->level].max_chain; - - s->strstart = 0; - s->block_start = 0L; - s->lookahead = 0; - s->match_length = s->prev_length = MIN_MATCH-1; - s->match_available = 0; - s->ins_h = 0; -#ifndef FASTEST -#ifdef ASMV - match_init(); /* initialize the asm code */ -#endif -#endif -} - -#ifndef FASTEST -/* =========================================================================== - * Set match_start to the longest match starting at the given string and - * return its length. Matches shorter or equal to prev_length are discarded, - * in which case the result is equal to prev_length and match_start is - * garbage. - * IN assertions: cur_match is the head of the hash chain for the current - * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 - * OUT assertion: the match length is not greater than s->lookahead. - */ -#ifndef ASMV -/* For 80x86 and 680x0, an optimized version will be provided in match.asm or - * match.S. The code will be functionally equivalent. - */ -local uInt longest_match(s, cur_match) - deflate_state *s; - IPos cur_match; /* current match */ -{ - unsigned chain_length = s->max_chain_length;/* max hash chain length */ - register Bytef *scan = s->window + s->strstart; /* current string */ - register Bytef *match; /* matched string */ - register int len; /* length of current match */ - int best_len = s->prev_length; /* best match length so far */ - int nice_match = s->nice_match; /* stop if match long enough */ - IPos limit = s->strstart > (IPos)MAX_DIST(s) ? - s->strstart - (IPos)MAX_DIST(s) : NIL; - /* Stop when cur_match becomes <= limit. To simplify the code, - * we prevent matches with the string of window index 0. - */ - Posf *prev = s->prev; - uInt wmask = s->w_mask; - -#ifdef UNALIGNED_OK - /* Compare two bytes at a time. Note: this is not always beneficial. - * Try with and without -DUNALIGNED_OK to check. - */ - register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; - register ush scan_start = *(ushf*)scan; - register ush scan_end = *(ushf*)(scan+best_len-1); -#else - register Bytef *strend = s->window + s->strstart + MAX_MATCH; - register Byte scan_end1 = scan[best_len-1]; - register Byte scan_end = scan[best_len]; -#endif - - /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. - * It is easy to get rid of this optimization if necessary. - */ - Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); - - /* Do not waste too much time if we already have a good match: */ - if (s->prev_length >= s->good_match) { - chain_length >>= 2; - } - /* Do not look for matches beyond the end of the input. This is necessary - * to make deflate deterministic. - */ - if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; - - Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); - - do { - Assert(cur_match < s->strstart, "no future"); - match = s->window + cur_match; - - /* Skip to next match if the match length cannot increase - * or if the match length is less than 2. Note that the checks below - * for insufficient lookahead only occur occasionally for performance - * reasons. Therefore uninitialized memory will be accessed, and - * conditional jumps will be made that depend on those values. - * However the length of the match is limited to the lookahead, so - * the output of deflate is not affected by the uninitialized values. - */ -#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) - /* This code assumes sizeof(unsigned short) == 2. Do not use - * UNALIGNED_OK if your compiler uses a different size. - */ - if (*(ushf*)(match+best_len-1) != scan_end || - *(ushf*)match != scan_start) continue; - - /* It is not necessary to compare scan[2] and match[2] since they are - * always equal when the other bytes match, given that the hash keys - * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at - * strstart+3, +5, ... up to strstart+257. We check for insufficient - * lookahead only every 4th comparison; the 128th check will be made - * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is - * necessary to put more guard bytes at the end of the window, or - * to check more often for insufficient lookahead. - */ - Assert(scan[2] == match[2], "scan[2]?"); - scan++, match++; - do { - } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && - *(ushf*)(scan+=2) == *(ushf*)(match+=2) && - *(ushf*)(scan+=2) == *(ushf*)(match+=2) && - *(ushf*)(scan+=2) == *(ushf*)(match+=2) && - scan < strend); - /* The funny "do {}" generates better code on most compilers */ - - /* Here, scan <= window+strstart+257 */ - Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); - if (*scan == *match) scan++; - - len = (MAX_MATCH - 1) - (int)(strend-scan); - scan = strend - (MAX_MATCH-1); - -#else /* UNALIGNED_OK */ - - if (match[best_len] != scan_end || - match[best_len-1] != scan_end1 || - *match != *scan || - *++match != scan[1]) continue; - - /* The check at best_len-1 can be removed because it will be made - * again later. (This heuristic is not always a win.) - * It is not necessary to compare scan[2] and match[2] since they - * are always equal when the other bytes match, given that - * the hash keys are equal and that HASH_BITS >= 8. - */ - scan += 2, match++; - Assert(*scan == *match, "match[2]?"); - - /* We check for insufficient lookahead only every 8th comparison; - * the 256th check will be made at strstart+258. - */ - do { - } while (*++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - scan < strend); - - Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); - - len = MAX_MATCH - (int)(strend - scan); - scan = strend - MAX_MATCH; - -#endif /* UNALIGNED_OK */ - - if (len > best_len) { - s->match_start = cur_match; - best_len = len; - if (len >= nice_match) break; -#ifdef UNALIGNED_OK - scan_end = *(ushf*)(scan+best_len-1); -#else - scan_end1 = scan[best_len-1]; - scan_end = scan[best_len]; -#endif - } - } while ((cur_match = prev[cur_match & wmask]) > limit - && --chain_length != 0); - - if ((uInt)best_len <= s->lookahead) return (uInt)best_len; - return s->lookahead; -} -#endif /* ASMV */ -#endif /* FASTEST */ - -/* --------------------------------------------------------------------------- - * Optimized version for level == 1 or strategy == Z_RLE only - */ -local uInt longest_match_fast(s, cur_match) - deflate_state *s; - IPos cur_match; /* current match */ -{ - register Bytef *scan = s->window + s->strstart; /* current string */ - register Bytef *match; /* matched string */ - register int len; /* length of current match */ - register Bytef *strend = s->window + s->strstart + MAX_MATCH; - - /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. - * It is easy to get rid of this optimization if necessary. - */ - Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); - - Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); - - Assert(cur_match < s->strstart, "no future"); - - match = s->window + cur_match; - - /* Return failure if the match length is less than 2: - */ - if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; - - /* The check at best_len-1 can be removed because it will be made - * again later. (This heuristic is not always a win.) - * It is not necessary to compare scan[2] and match[2] since they - * are always equal when the other bytes match, given that - * the hash keys are equal and that HASH_BITS >= 8. - */ - scan += 2, match += 2; - Assert(*scan == *match, "match[2]?"); - - /* We check for insufficient lookahead only every 8th comparison; - * the 256th check will be made at strstart+258. - */ - do { - } while (*++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - scan < strend); - - Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); - - len = MAX_MATCH - (int)(strend - scan); - - if (len < MIN_MATCH) return MIN_MATCH - 1; - - s->match_start = cur_match; - return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead; -} - -#ifdef DEBUG -/* =========================================================================== - * Check that the match at match_start is indeed a match. - */ -local void check_match(s, start, match, length) - deflate_state *s; - IPos start, match; - int length; -{ - /* check that the match is indeed a match */ - if (zmemcmp(s->window + match, - s->window + start, length) != EQUAL) { - fprintf(stderr, " start %u, match %u, length %d\n", - start, match, length); - do { - fprintf(stderr, "%c%c", s->window[match++], s->window[start++]); - } while (--length != 0); - z_error("invalid match"); - } - if (z_verbose > 1) { - fprintf(stderr,"\\[%d,%d]", start-match, length); - do { putc(s->window[start++], stderr); } while (--length != 0); - } -} -#else -# define check_match(s, start, match, length) -#endif /* DEBUG */ - -/* =========================================================================== - * Fill the window when the lookahead becomes insufficient. - * Updates strstart and lookahead. - * - * IN assertion: lookahead < MIN_LOOKAHEAD - * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD - * At least one byte has been read, or avail_in == 0; reads are - * performed for at least two bytes (required for the zip translate_eol - * option -- not supported here). - */ -local void fill_window(s) - deflate_state *s; -{ - register unsigned n, m; - register Posf *p; - unsigned more; /* Amount of free space at the end of the window. */ - uInt wsize = s->w_size; - - do { - more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); - - /* Deal with !@#$% 64K limit: */ - if (sizeof(int) <= 2) { - if (more == 0 && s->strstart == 0 && s->lookahead == 0) { - more = wsize; - - } else if (more == (unsigned)(-1)) { - /* Very unlikely, but possible on 16 bit machine if - * strstart == 0 && lookahead == 1 (input done a byte at time) - */ - more--; - } - } - - /* If the window is almost full and there is insufficient lookahead, - * move the upper half to the lower one to make room in the upper half. - */ - if (s->strstart >= wsize+MAX_DIST(s)) { - - zmemcpy(s->window, s->window+wsize, (unsigned)wsize); - s->match_start -= wsize; - s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ - s->block_start -= (long) wsize; - - /* Slide the hash table (could be avoided with 32 bit values - at the expense of memory usage). We slide even when level == 0 - to keep the hash table consistent if we switch back to level > 0 - later. (Using level 0 permanently is not an optimal usage of - zlib, so we don't care about this pathological case.) - */ - /* %%% avoid this when Z_RLE */ - n = s->hash_size; - p = &s->head[n]; - do { - m = *--p; - *p = (Pos)(m >= wsize ? m-wsize : NIL); - } while (--n); - - n = wsize; -#ifndef FASTEST - p = &s->prev[n]; - do { - m = *--p; - *p = (Pos)(m >= wsize ? m-wsize : NIL); - /* If n is not on any hash chain, prev[n] is garbage but - * its value will never be used. - */ - } while (--n); -#endif - more += wsize; - } - if (s->strm->avail_in == 0) return; - - /* If there was no sliding: - * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && - * more == window_size - lookahead - strstart - * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) - * => more >= window_size - 2*WSIZE + 2 - * In the BIG_MEM or MMAP case (not yet supported), - * window_size == input_size + MIN_LOOKAHEAD && - * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. - * Otherwise, window_size == 2*WSIZE so more >= 2. - * If there was sliding, more >= WSIZE. So in all cases, more >= 2. - */ - Assert(more >= 2, "more < 2"); - - n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); - s->lookahead += n; - - /* Initialize the hash value now that we have some input: */ - if (s->lookahead >= MIN_MATCH) { - s->ins_h = s->window[s->strstart]; - UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); -#if MIN_MATCH != 3 - Call UPDATE_HASH() MIN_MATCH-3 more times -#endif - } - /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, - * but this is not important since only literal bytes will be emitted. - */ - - } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); -} - -/* =========================================================================== - * Flush the current block, with given end-of-file flag. - * IN assertion: strstart is set to the end of the current match. - */ -#define FLUSH_BLOCK_ONLY(s, eof) { \ - _tr_flush_block(s, (s->block_start >= 0L ? \ - (charf *)&s->window[(unsigned)s->block_start] : \ - (charf *)Z_NULL), \ - (ulg)((long)s->strstart - s->block_start), \ - (eof)); \ - s->block_start = s->strstart; \ - flush_pending(s->strm); \ - Tracev((stderr,"[FLUSH]")); \ -} - -/* Same but force premature exit if necessary. */ -#define FLUSH_BLOCK(s, eof) { \ - FLUSH_BLOCK_ONLY(s, eof); \ - if (s->strm->avail_out == 0) return (eof) ? finish_started : need_more; \ -} - -/* =========================================================================== - * Copy without compression as much as possible from the input stream, return - * the current block state. - * This function does not insert new strings in the dictionary since - * uncompressible data is probably not useful. This function is used - * only for the level=0 compression option. - * NOTE: this function should be optimized to avoid extra copying from - * window to pending_buf. - */ -local block_state deflate_stored(s, flush) - deflate_state *s; - int flush; -{ - /* Stored blocks are limited to 0xffff bytes, pending_buf is limited - * to pending_buf_size, and each stored block has a 5 byte header: - */ - ulg max_block_size = 0xffff; - ulg max_start; - - if (max_block_size > s->pending_buf_size - 5) { - max_block_size = s->pending_buf_size - 5; - } - - /* Copy as much as possible from input to output: */ - for (;;) { - /* Fill the window as much as possible: */ - if (s->lookahead <= 1) { - - Assert(s->strstart < s->w_size+MAX_DIST(s) || - s->block_start >= (long)s->w_size, "slide too late"); - - fill_window(s); - if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more; - - if (s->lookahead == 0) break; /* flush the current block */ - } - Assert(s->block_start >= 0L, "block gone"); - - s->strstart += s->lookahead; - s->lookahead = 0; - - /* Emit a stored block if pending_buf will be full: */ - max_start = s->block_start + max_block_size; - if (s->strstart == 0 || (ulg)s->strstart >= max_start) { - /* strstart == 0 is possible when wraparound on 16-bit machine */ - s->lookahead = (uInt)(s->strstart - max_start); - s->strstart = (uInt)max_start; - FLUSH_BLOCK(s, 0); - } - /* Flush if we may have to slide, otherwise block_start may become - * negative and the data will be gone: - */ - if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) { - FLUSH_BLOCK(s, 0); - } - } - FLUSH_BLOCK(s, flush == Z_FINISH); - return flush == Z_FINISH ? finish_done : block_done; -} - -/* =========================================================================== - * Compress as much as possible from the input stream, return the current - * block state. - * This function does not perform lazy evaluation of matches and inserts - * new strings in the dictionary only for unmatched strings or for short - * matches. It is used only for the fast compression options. - */ -local block_state deflate_fast(s, flush) - deflate_state *s; - int flush; -{ - IPos hash_head = NIL; /* head of the hash chain */ - int bflush; /* set if current block must be flushed */ - - for (;;) { - /* Make sure that we always have enough lookahead, except - * at the end of the input file. We need MAX_MATCH bytes - * for the next match, plus MIN_MATCH bytes to insert the - * string following the next match. - */ - if (s->lookahead < MIN_LOOKAHEAD) { - fill_window(s); - if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { - return need_more; - } - if (s->lookahead == 0) break; /* flush the current block */ - } - - /* Insert the string window[strstart .. strstart+2] in the - * dictionary, and set hash_head to the head of the hash chain: - */ - if (s->lookahead >= MIN_MATCH) { - INSERT_STRING(s, s->strstart, hash_head); - } - - /* Find the longest match, discarding those <= prev_length. - * At this point we have always match_length < MIN_MATCH - */ - if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { - /* To simplify the code, we prevent matches with the string - * of window index 0 (in particular we have to avoid a match - * of the string with itself at the start of the input file). - */ -#ifdef FASTEST - if ((s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) || - (s->strategy == Z_RLE && s->strstart - hash_head == 1)) { - s->match_length = longest_match_fast (s, hash_head); - } -#else - if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) { - s->match_length = longest_match (s, hash_head); - } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) { - s->match_length = longest_match_fast (s, hash_head); - } -#endif - /* longest_match() or longest_match_fast() sets match_start */ - } - if (s->match_length >= MIN_MATCH) { - check_match(s, s->strstart, s->match_start, s->match_length); - - _tr_tally_dist(s, s->strstart - s->match_start, - s->match_length - MIN_MATCH, bflush); - - s->lookahead -= s->match_length; - - /* Insert new strings in the hash table only if the match length - * is not too large. This saves time but degrades compression. - */ -#ifndef FASTEST - if (s->match_length <= s->max_insert_length && - s->lookahead >= MIN_MATCH) { - s->match_length--; /* string at strstart already in table */ - do { - s->strstart++; - INSERT_STRING(s, s->strstart, hash_head); - /* strstart never exceeds WSIZE-MAX_MATCH, so there are - * always MIN_MATCH bytes ahead. - */ - } while (--s->match_length != 0); - s->strstart++; - } else -#endif - { - s->strstart += s->match_length; - s->match_length = 0; - s->ins_h = s->window[s->strstart]; - UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); -#if MIN_MATCH != 3 - Call UPDATE_HASH() MIN_MATCH-3 more times -#endif - /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not - * matter since it will be recomputed at next deflate call. - */ - } - } else { - /* No match, output a literal byte */ - Tracevv((stderr,"%c", s->window[s->strstart])); - _tr_tally_lit (s, s->window[s->strstart], bflush); - s->lookahead--; - s->strstart++; - } - if (bflush) FLUSH_BLOCK(s, 0); - } - FLUSH_BLOCK(s, flush == Z_FINISH); - return flush == Z_FINISH ? finish_done : block_done; -} - -#ifndef FASTEST -/* =========================================================================== - * Same as above, but achieves better compression. We use a lazy - * evaluation for matches: a match is finally adopted only if there is - * no better match at the next window position. - */ -local block_state deflate_slow(s, flush) - deflate_state *s; - int flush; -{ - IPos hash_head = NIL; /* head of hash chain */ - int bflush; /* set if current block must be flushed */ - - /* Process the input block. */ - for (;;) { - /* Make sure that we always have enough lookahead, except - * at the end of the input file. We need MAX_MATCH bytes - * for the next match, plus MIN_MATCH bytes to insert the - * string following the next match. - */ - if (s->lookahead < MIN_LOOKAHEAD) { - fill_window(s); - if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { - return need_more; - } - if (s->lookahead == 0) break; /* flush the current block */ - } - - /* Insert the string window[strstart .. strstart+2] in the - * dictionary, and set hash_head to the head of the hash chain: - */ - if (s->lookahead >= MIN_MATCH) { - INSERT_STRING(s, s->strstart, hash_head); - } - - /* Find the longest match, discarding those <= prev_length. - */ - s->prev_length = s->match_length, s->prev_match = s->match_start; - s->match_length = MIN_MATCH-1; - - if (hash_head != NIL && s->prev_length < s->max_lazy_match && - s->strstart - hash_head <= MAX_DIST(s)) { - /* To simplify the code, we prevent matches with the string - * of window index 0 (in particular we have to avoid a match - * of the string with itself at the start of the input file). - */ - if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) { - s->match_length = longest_match (s, hash_head); - } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) { - s->match_length = longest_match_fast (s, hash_head); - } - /* longest_match() or longest_match_fast() sets match_start */ - - if (s->match_length <= 5 && (s->strategy == Z_FILTERED -#if TOO_FAR <= 32767 - || (s->match_length == MIN_MATCH && - s->strstart - s->match_start > TOO_FAR) -#endif - )) { - - /* If prev_match is also MIN_MATCH, match_start is garbage - * but we will ignore the current match anyway. - */ - s->match_length = MIN_MATCH-1; - } - } - /* If there was a match at the previous step and the current - * match is not better, output the previous match: - */ - if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { - uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; - /* Do not insert strings in hash table beyond this. */ - - check_match(s, s->strstart-1, s->prev_match, s->prev_length); - - _tr_tally_dist(s, s->strstart -1 - s->prev_match, - s->prev_length - MIN_MATCH, bflush); - - /* Insert in hash table all strings up to the end of the match. - * strstart-1 and strstart are already inserted. If there is not - * enough lookahead, the last two strings are not inserted in - * the hash table. - */ - s->lookahead -= s->prev_length-1; - s->prev_length -= 2; - do { - if (++s->strstart <= max_insert) { - INSERT_STRING(s, s->strstart, hash_head); - } - } while (--s->prev_length != 0); - s->match_available = 0; - s->match_length = MIN_MATCH-1; - s->strstart++; - - if (bflush) FLUSH_BLOCK(s, 0); - - } else if (s->match_available) { - /* If there was no match at the previous position, output a - * single literal. If there was a match but the current match - * is longer, truncate the previous match to a single literal. - */ - Tracevv((stderr,"%c", s->window[s->strstart-1])); - _tr_tally_lit(s, s->window[s->strstart-1], bflush); - if (bflush) { - FLUSH_BLOCK_ONLY(s, 0); - } - s->strstart++; - s->lookahead--; - if (s->strm->avail_out == 0) return need_more; - } else { - /* There is no previous match to compare with, wait for - * the next step to decide. - */ - s->match_available = 1; - s->strstart++; - s->lookahead--; - } - } - Assert (flush != Z_NO_FLUSH, "no flush?"); - if (s->match_available) { - Tracevv((stderr,"%c", s->window[s->strstart-1])); - _tr_tally_lit(s, s->window[s->strstart-1], bflush); - s->match_available = 0; - } - FLUSH_BLOCK(s, flush == Z_FINISH); - return flush == Z_FINISH ? finish_done : block_done; -} -#endif /* FASTEST */ - -#if 0 -/* =========================================================================== - * For Z_RLE, simply look for runs of bytes, generate matches only of distance - * one. Do not maintain a hash table. (It will be regenerated if this run of - * deflate switches away from Z_RLE.) - */ -local block_state deflate_rle(s, flush) - deflate_state *s; - int flush; -{ - int bflush; /* set if current block must be flushed */ - uInt run; /* length of run */ - uInt max; /* maximum length of run */ - uInt prev; /* byte at distance one to match */ - Bytef *scan; /* scan for end of run */ - - for (;;) { - /* Make sure that we always have enough lookahead, except - * at the end of the input file. We need MAX_MATCH bytes - * for the longest encodable run. - */ - if (s->lookahead < MAX_MATCH) { - fill_window(s); - if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) { - return need_more; - } - if (s->lookahead == 0) break; /* flush the current block */ - } - - /* See how many times the previous byte repeats */ - run = 0; - if (s->strstart > 0) { /* if there is a previous byte, that is */ - max = s->lookahead < MAX_MATCH ? s->lookahead : MAX_MATCH; - scan = s->window + s->strstart - 1; - prev = *scan++; - do { - if (*scan++ != prev) - break; - } while (++run < max); - } - - /* Emit match if have run of MIN_MATCH or longer, else emit literal */ - if (run >= MIN_MATCH) { - check_match(s, s->strstart, s->strstart - 1, run); - _tr_tally_dist(s, 1, run - MIN_MATCH, bflush); - s->lookahead -= run; - s->strstart += run; - } else { - /* No match, output a literal byte */ - Tracevv((stderr,"%c", s->window[s->strstart])); - _tr_tally_lit (s, s->window[s->strstart], bflush); - s->lookahead--; - s->strstart++; - } - if (bflush) FLUSH_BLOCK(s, 0); - } - FLUSH_BLOCK(s, flush == Z_FINISH); - return flush == Z_FINISH ? finish_done : block_done; -} -#endif diff --git a/ndk/sources/external/zlib/deflate.h b/ndk/sources/external/zlib/deflate.h deleted file mode 100644 index 05a5ab3a2..000000000 --- a/ndk/sources/external/zlib/deflate.h +++ /dev/null @@ -1,331 +0,0 @@ -/* deflate.h -- internal compression state - * Copyright (C) 1995-2004 Jean-loup Gailly - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* WARNING: this file should *not* be used by applications. It is - part of the implementation of the compression library and is - subject to change. Applications should only use zlib.h. - */ - -/* @(#) $Id$ */ - -#ifndef DEFLATE_H -#define DEFLATE_H - -#include "zutil.h" - -/* define NO_GZIP when compiling if you want to disable gzip header and - trailer creation by deflate(). NO_GZIP would be used to avoid linking in - the crc code when it is not needed. For shared libraries, gzip encoding - should be left enabled. */ -#ifndef NO_GZIP -# define GZIP -#endif - -/* =========================================================================== - * Internal compression state. - */ - -#define LENGTH_CODES 29 -/* number of length codes, not counting the special END_BLOCK code */ - -#define LITERALS 256 -/* number of literal bytes 0..255 */ - -#define L_CODES (LITERALS+1+LENGTH_CODES) -/* number of Literal or Length codes, including the END_BLOCK code */ - -#define D_CODES 30 -/* number of distance codes */ - -#define BL_CODES 19 -/* number of codes used to transfer the bit lengths */ - -#define HEAP_SIZE (2*L_CODES+1) -/* maximum heap size */ - -#define MAX_BITS 15 -/* All codes must not exceed MAX_BITS bits */ - -#define INIT_STATE 42 -#define EXTRA_STATE 69 -#define NAME_STATE 73 -#define COMMENT_STATE 91 -#define HCRC_STATE 103 -#define BUSY_STATE 113 -#define FINISH_STATE 666 -/* Stream status */ - - -/* Data structure describing a single value and its code string. */ -typedef struct ct_data_s { - union { - ush freq; /* frequency count */ - ush code; /* bit string */ - } fc; - union { - ush dad; /* father node in Huffman tree */ - ush len; /* length of bit string */ - } dl; -} FAR ct_data; - -#define Freq fc.freq -#define Code fc.code -#define Dad dl.dad -#define Len dl.len - -typedef struct static_tree_desc_s static_tree_desc; - -typedef struct tree_desc_s { - ct_data *dyn_tree; /* the dynamic tree */ - int max_code; /* largest code with non zero frequency */ - static_tree_desc *stat_desc; /* the corresponding static tree */ -} FAR tree_desc; - -typedef ush Pos; -typedef Pos FAR Posf; -typedef unsigned IPos; - -/* A Pos is an index in the character window. We use short instead of int to - * save space in the various tables. IPos is used only for parameter passing. - */ - -typedef struct internal_state { - z_streamp strm; /* pointer back to this zlib stream */ - int status; /* as the name implies */ - Bytef *pending_buf; /* output still pending */ - ulg pending_buf_size; /* size of pending_buf */ - Bytef *pending_out; /* next pending byte to output to the stream */ - uInt pending; /* nb of bytes in the pending buffer */ - int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ - gz_headerp gzhead; /* gzip header information to write */ - uInt gzindex; /* where in extra, name, or comment */ - Byte method; /* STORED (for zip only) or DEFLATED */ - int last_flush; /* value of flush param for previous deflate call */ - - /* used by deflate.c: */ - - uInt w_size; /* LZ77 window size (32K by default) */ - uInt w_bits; /* log2(w_size) (8..16) */ - uInt w_mask; /* w_size - 1 */ - - Bytef *window; - /* Sliding window. Input bytes are read into the second half of the window, - * and move to the first half later to keep a dictionary of at least wSize - * bytes. With this organization, matches are limited to a distance of - * wSize-MAX_MATCH bytes, but this ensures that IO is always - * performed with a length multiple of the block size. Also, it limits - * the window size to 64K, which is quite useful on MSDOS. - * To do: use the user input buffer as sliding window. - */ - - ulg window_size; - /* Actual size of window: 2*wSize, except when the user input buffer - * is directly used as sliding window. - */ - - Posf *prev; - /* Link to older string with same hash index. To limit the size of this - * array to 64K, this link is maintained only for the last 32K strings. - * An index in this array is thus a window index modulo 32K. - */ - - Posf *head; /* Heads of the hash chains or NIL. */ - - uInt ins_h; /* hash index of string to be inserted */ - uInt hash_size; /* number of elements in hash table */ - uInt hash_bits; /* log2(hash_size) */ - uInt hash_mask; /* hash_size-1 */ - - uInt hash_shift; - /* Number of bits by which ins_h must be shifted at each input - * step. It must be such that after MIN_MATCH steps, the oldest - * byte no longer takes part in the hash key, that is: - * hash_shift * MIN_MATCH >= hash_bits - */ - - long block_start; - /* Window position at the beginning of the current output block. Gets - * negative when the window is moved backwards. - */ - - uInt match_length; /* length of best match */ - IPos prev_match; /* previous match */ - int match_available; /* set if previous match exists */ - uInt strstart; /* start of string to insert */ - uInt match_start; /* start of matching string */ - uInt lookahead; /* number of valid bytes ahead in window */ - - uInt prev_length; - /* Length of the best match at previous step. Matches not greater than this - * are discarded. This is used in the lazy match evaluation. - */ - - uInt max_chain_length; - /* To speed up deflation, hash chains are never searched beyond this - * length. A higher limit improves compression ratio but degrades the - * speed. - */ - - uInt max_lazy_match; - /* Attempt to find a better match only when the current match is strictly - * smaller than this value. This mechanism is used only for compression - * levels >= 4. - */ -# define max_insert_length max_lazy_match - /* Insert new strings in the hash table only if the match length is not - * greater than this length. This saves time but degrades compression. - * max_insert_length is used only for compression levels <= 3. - */ - - int level; /* compression level (1..9) */ - int strategy; /* favor or force Huffman coding*/ - - uInt good_match; - /* Use a faster search when the previous match is longer than this */ - - int nice_match; /* Stop searching when current match exceeds this */ - - /* used by trees.c: */ - /* Didn't use ct_data typedef below to supress compiler warning */ - struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ - struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ - struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ - - struct tree_desc_s l_desc; /* desc. for literal tree */ - struct tree_desc_s d_desc; /* desc. for distance tree */ - struct tree_desc_s bl_desc; /* desc. for bit length tree */ - - ush bl_count[MAX_BITS+1]; - /* number of codes at each bit length for an optimal tree */ - - int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ - int heap_len; /* number of elements in the heap */ - int heap_max; /* element of largest frequency */ - /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. - * The same heap array is used to build all trees. - */ - - uch depth[2*L_CODES+1]; - /* Depth of each subtree used as tie breaker for trees of equal frequency - */ - - uchf *l_buf; /* buffer for literals or lengths */ - - uInt lit_bufsize; - /* Size of match buffer for literals/lengths. There are 4 reasons for - * limiting lit_bufsize to 64K: - * - frequencies can be kept in 16 bit counters - * - if compression is not successful for the first block, all input - * data is still in the window so we can still emit a stored block even - * when input comes from standard input. (This can also be done for - * all blocks if lit_bufsize is not greater than 32K.) - * - if compression is not successful for a file smaller than 64K, we can - * even emit a stored file instead of a stored block (saving 5 bytes). - * This is applicable only for zip (not gzip or zlib). - * - creating new Huffman trees less frequently may not provide fast - * adaptation to changes in the input data statistics. (Take for - * example a binary file with poorly compressible code followed by - * a highly compressible string table.) Smaller buffer sizes give - * fast adaptation but have of course the overhead of transmitting - * trees more frequently. - * - I can't count above 4 - */ - - uInt last_lit; /* running index in l_buf */ - - ushf *d_buf; - /* Buffer for distances. To simplify the code, d_buf and l_buf have - * the same number of elements. To use different lengths, an extra flag - * array would be necessary. - */ - - ulg opt_len; /* bit length of current block with optimal trees */ - ulg static_len; /* bit length of current block with static trees */ - uInt matches; /* number of string matches in current block */ - int last_eob_len; /* bit length of EOB code for last block */ - -#ifdef DEBUG - ulg compressed_len; /* total bit length of compressed file mod 2^32 */ - ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ -#endif - - ush bi_buf; - /* Output buffer. bits are inserted starting at the bottom (least - * significant bits). - */ - int bi_valid; - /* Number of valid bits in bi_buf. All bits above the last valid bit - * are always zero. - */ - -} FAR deflate_state; - -/* Output a byte on the stream. - * IN assertion: there is enough room in pending_buf. - */ -#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} - - -#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) -/* Minimum amount of lookahead, except at the end of the input file. - * See deflate.c for comments about the MIN_MATCH+1. - */ - -#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) -/* In order to simplify the code, particularly on 16 bit machines, match - * distances are limited to MAX_DIST instead of WSIZE. - */ - - /* in trees.c */ -void _tr_init OF((deflate_state *s)); -int _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); -void _tr_flush_block OF((deflate_state *s, charf *buf, ulg stored_len, - int eof)); -void _tr_align OF((deflate_state *s)); -void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len, - int eof)); - -#define d_code(dist) \ - ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) -/* Mapping from a distance to a distance code. dist is the distance - 1 and - * must not have side effects. _dist_code[256] and _dist_code[257] are never - * used. - */ - -#ifndef DEBUG -/* Inline versions of _tr_tally for speed: */ - -#if defined(GEN_TREES_H) || !defined(STDC) - extern uch _length_code[]; - extern uch _dist_code[]; -#else - extern const uch _length_code[]; - extern const uch _dist_code[]; -#endif - -# define _tr_tally_lit(s, c, flush) \ - { uch cc = (c); \ - s->d_buf[s->last_lit] = 0; \ - s->l_buf[s->last_lit++] = cc; \ - s->dyn_ltree[cc].Freq++; \ - flush = (s->last_lit == s->lit_bufsize-1); \ - } -# define _tr_tally_dist(s, distance, length, flush) \ - { uch len = (length); \ - ush dist = (distance); \ - s->d_buf[s->last_lit] = dist; \ - s->l_buf[s->last_lit++] = len; \ - dist--; \ - s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ - s->dyn_dtree[d_code(dist)].Freq++; \ - flush = (s->last_lit == s->lit_bufsize-1); \ - } -#else -# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) -# define _tr_tally_dist(s, distance, length, flush) \ - flush = _tr_tally(s, distance, length) -#endif - -#endif /* DEFLATE_H */ diff --git a/ndk/sources/external/zlib/gzio.c b/ndk/sources/external/zlib/gzio.c deleted file mode 100644 index 7e90f4928..000000000 --- a/ndk/sources/external/zlib/gzio.c +++ /dev/null @@ -1,1026 +0,0 @@ -/* gzio.c -- IO on .gz files - * Copyright (C) 1995-2005 Jean-loup Gailly. - * For conditions of distribution and use, see copyright notice in zlib.h - * - * Compile this file with -DNO_GZCOMPRESS to avoid the compression code. - */ - -/* @(#) $Id$ */ - -#include - -#include "zutil.h" - -#ifdef NO_DEFLATE /* for compatibility with old definition */ -# define NO_GZCOMPRESS -#endif - -#ifndef NO_DUMMY_DECL -struct internal_state {int dummy;}; /* for buggy compilers */ -#endif - -#ifndef Z_BUFSIZE -# ifdef MAXSEG_64K -# define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */ -# else -# define Z_BUFSIZE 16384 -# endif -#endif -#ifndef Z_PRINTF_BUFSIZE -# define Z_PRINTF_BUFSIZE 4096 -#endif - -#ifdef __MVS__ -# pragma map (fdopen , "\174\174FDOPEN") - FILE *fdopen(int, const char *); -#endif - -#ifndef STDC -extern voidp malloc OF((uInt size)); -extern void free OF((voidpf ptr)); -#endif - -#define ALLOC(size) malloc(size) -#define TRYFREE(p) {if (p) free(p);} - -static int const gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */ - -/* gzip flag byte */ -#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ -#define HEAD_CRC 0x02 /* bit 1 set: header CRC present */ -#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ -#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ -#define COMMENT 0x10 /* bit 4 set: file comment present */ -#define RESERVED 0xE0 /* bits 5..7: reserved */ - -typedef struct gz_stream { - z_stream stream; - int z_err; /* error code for last stream operation */ - int z_eof; /* set if end of input file */ - FILE *file; /* .gz file */ - Byte *inbuf; /* input buffer */ - Byte *outbuf; /* output buffer */ - uLong crc; /* crc32 of uncompressed data */ - char *msg; /* error message */ - char *path; /* path name for debugging only */ - int transparent; /* 1 if input file is not a .gz file */ - char mode; /* 'w' or 'r' */ - z_off_t start; /* start of compressed data in file (header skipped) */ - z_off_t in; /* bytes into deflate or inflate */ - z_off_t out; /* bytes out of deflate or inflate */ - int back; /* one character push-back */ - int last; /* true if push-back is last character */ -} gz_stream; - - -local gzFile gz_open OF((const char *path, const char *mode, int fd)); -local int do_flush OF((gzFile file, int flush)); -local int get_byte OF((gz_stream *s)); -local void check_header OF((gz_stream *s)); -local int destroy OF((gz_stream *s)); -local void putLong OF((FILE *file, uLong x)); -local uLong getLong OF((gz_stream *s)); - -/* =========================================================================== - Opens a gzip (.gz) file for reading or writing. The mode parameter - is as in fopen ("rb" or "wb"). The file is given either by file descriptor - or path name (if fd == -1). - gz_open returns NULL if the file could not be opened or if there was - insufficient memory to allocate the (de)compression state; errno - can be checked to distinguish the two cases (if errno is zero, the - zlib error is Z_MEM_ERROR). -*/ -local gzFile gz_open (path, mode, fd) - const char *path; - const char *mode; - int fd; -{ - int err; - int level = Z_DEFAULT_COMPRESSION; /* compression level */ - int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */ - char *p = (char*)mode; - gz_stream *s; - char fmode[80]; /* copy of mode, without the compression level */ - char *m = fmode; - - if (!path || !mode) return Z_NULL; - - s = (gz_stream *)ALLOC(sizeof(gz_stream)); - if (!s) return Z_NULL; - - s->stream.zalloc = (alloc_func)0; - s->stream.zfree = (free_func)0; - s->stream.opaque = (voidpf)0; - s->stream.next_in = s->inbuf = Z_NULL; - s->stream.next_out = s->outbuf = Z_NULL; - s->stream.avail_in = s->stream.avail_out = 0; - s->file = NULL; - s->z_err = Z_OK; - s->z_eof = 0; - s->in = 0; - s->out = 0; - s->back = EOF; - s->crc = crc32(0L, Z_NULL, 0); - s->msg = NULL; - s->transparent = 0; - - s->path = (char*)ALLOC(strlen(path)+1); - if (s->path == NULL) { - return destroy(s), (gzFile)Z_NULL; - } - strcpy(s->path, path); /* do this early for debugging */ - - s->mode = '\0'; - do { - if (*p == 'r') s->mode = 'r'; - if (*p == 'w' || *p == 'a') s->mode = 'w'; - if (*p >= '0' && *p <= '9') { - level = *p - '0'; - } else if (*p == 'f') { - strategy = Z_FILTERED; - } else if (*p == 'h') { - strategy = Z_HUFFMAN_ONLY; - } else if (*p == 'R') { - strategy = Z_RLE; - } else { - *m++ = *p; /* copy the mode */ - } - } while (*p++ && m != fmode + sizeof(fmode)); - if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL; - - if (s->mode == 'w') { -#ifdef NO_GZCOMPRESS - err = Z_STREAM_ERROR; -#else - err = deflateInit2(&(s->stream), level, - Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy); - /* windowBits is passed < 0 to suppress zlib header */ - - s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE); -#endif - if (err != Z_OK || s->outbuf == Z_NULL) { - return destroy(s), (gzFile)Z_NULL; - } - } else { - s->stream.next_in = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); - - err = inflateInit2(&(s->stream), -MAX_WBITS); - /* windowBits is passed < 0 to tell that there is no zlib header. - * Note that in this case inflate *requires* an extra "dummy" byte - * after the compressed stream in order to complete decompression and - * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are - * present after the compressed stream. - */ - if (err != Z_OK || s->inbuf == Z_NULL) { - return destroy(s), (gzFile)Z_NULL; - } - } - s->stream.avail_out = Z_BUFSIZE; - - errno = 0; - s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode); - - if (s->file == NULL) { - return destroy(s), (gzFile)Z_NULL; - } - if (s->mode == 'w') { - /* Write a very simple .gz header: - */ - fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1], - Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE); - s->start = 10L; - /* We use 10L instead of ftell(s->file) to because ftell causes an - * fflush on some systems. This version of the library doesn't use - * start anyway in write mode, so this initialization is not - * necessary. - */ - } else { - check_header(s); /* skip the .gz header */ - s->start = ftell(s->file) - s->stream.avail_in; - } - - return (gzFile)s; -} - -/* =========================================================================== - Opens a gzip (.gz) file for reading or writing. -*/ -gzFile ZEXPORT gzopen (path, mode) - const char *path; - const char *mode; -{ - return gz_open (path, mode, -1); -} - -/* =========================================================================== - Associate a gzFile with the file descriptor fd. fd is not dup'ed here - to mimic the behavio(u)r of fdopen. -*/ -gzFile ZEXPORT gzdopen (fd, mode) - int fd; - const char *mode; -{ - char name[46]; /* allow for up to 128-bit integers */ - - if (fd < 0) return (gzFile)Z_NULL; - sprintf(name, "", fd); /* for debugging */ - - return gz_open (name, mode, fd); -} - -/* =========================================================================== - * Update the compression level and strategy - */ -int ZEXPORT gzsetparams (file, level, strategy) - gzFile file; - int level; - int strategy; -{ - gz_stream *s = (gz_stream*)file; - - if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR; - - /* Make room to allow flushing */ - if (s->stream.avail_out == 0) { - - s->stream.next_out = s->outbuf; - if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) { - s->z_err = Z_ERRNO; - } - s->stream.avail_out = Z_BUFSIZE; - } - - return deflateParams (&(s->stream), level, strategy); -} - -/* =========================================================================== - Read a byte from a gz_stream; update next_in and avail_in. Return EOF - for end of file. - IN assertion: the stream s has been sucessfully opened for reading. -*/ -local int get_byte(s) - gz_stream *s; -{ - if (s->z_eof) return EOF; - if (s->stream.avail_in == 0) { - errno = 0; - s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file); - if (s->stream.avail_in == 0) { - s->z_eof = 1; - if (ferror(s->file)) s->z_err = Z_ERRNO; - return EOF; - } - s->stream.next_in = s->inbuf; - } - s->stream.avail_in--; - return *(s->stream.next_in)++; -} - -/* =========================================================================== - Check the gzip header of a gz_stream opened for reading. Set the stream - mode to transparent if the gzip magic header is not present; set s->err - to Z_DATA_ERROR if the magic header is present but the rest of the header - is incorrect. - IN assertion: the stream s has already been created sucessfully; - s->stream.avail_in is zero for the first time, but may be non-zero - for concatenated .gz files. -*/ -local void check_header(s) - gz_stream *s; -{ - int method; /* method byte */ - int flags; /* flags byte */ - uInt len; - int c; - - /* Assure two bytes in the buffer so we can peek ahead -- handle case - where first byte of header is at the end of the buffer after the last - gzip segment */ - len = s->stream.avail_in; - if (len < 2) { - if (len) s->inbuf[0] = s->stream.next_in[0]; - errno = 0; - len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file); - if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO; - s->stream.avail_in += len; - s->stream.next_in = s->inbuf; - if (s->stream.avail_in < 2) { - s->transparent = s->stream.avail_in; - return; - } - } - - /* Peek ahead to check the gzip magic header */ - if (s->stream.next_in[0] != gz_magic[0] || - s->stream.next_in[1] != gz_magic[1]) { - s->transparent = 1; - return; - } - s->stream.avail_in -= 2; - s->stream.next_in += 2; - - /* Check the rest of the gzip header */ - method = get_byte(s); - flags = get_byte(s); - if (method != Z_DEFLATED || (flags & RESERVED) != 0) { - s->z_err = Z_DATA_ERROR; - return; - } - - /* Discard time, xflags and OS code: */ - for (len = 0; len < 6; len++) (void)get_byte(s); - - if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */ - len = (uInt)get_byte(s); - len += ((uInt)get_byte(s))<<8; - /* len is garbage if EOF but the loop below will quit anyway */ - while (len-- != 0 && get_byte(s) != EOF) ; - } - if ((flags & ORIG_NAME) != 0) { /* skip the original file name */ - while ((c = get_byte(s)) != 0 && c != EOF) ; - } - if ((flags & COMMENT) != 0) { /* skip the .gz file comment */ - while ((c = get_byte(s)) != 0 && c != EOF) ; - } - if ((flags & HEAD_CRC) != 0) { /* skip the header crc */ - for (len = 0; len < 2; len++) (void)get_byte(s); - } - s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK; -} - - /* =========================================================================== - * Cleanup then free the given gz_stream. Return a zlib error code. - Try freeing in the reverse order of allocations. - */ -local int destroy (s) - gz_stream *s; -{ - int err = Z_OK; - - if (!s) return Z_STREAM_ERROR; - - TRYFREE(s->msg); - - if (s->stream.state != NULL) { - if (s->mode == 'w') { -#ifdef NO_GZCOMPRESS - err = Z_STREAM_ERROR; -#else - err = deflateEnd(&(s->stream)); -#endif - } else if (s->mode == 'r') { - err = inflateEnd(&(s->stream)); - } - } - if (s->file != NULL && fclose(s->file)) { -#ifdef ESPIPE - if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */ -#endif - err = Z_ERRNO; - } - if (s->z_err < 0) err = s->z_err; - - TRYFREE(s->inbuf); - TRYFREE(s->outbuf); - TRYFREE(s->path); - TRYFREE(s); - return err; -} - -/* =========================================================================== - Reads the given number of uncompressed bytes from the compressed file. - gzread returns the number of bytes actually read (0 for end of file). -*/ -int ZEXPORT gzread (file, buf, len) - gzFile file; - voidp buf; - unsigned len; -{ - gz_stream *s = (gz_stream*)file; - Bytef *start = (Bytef*)buf; /* starting point for crc computation */ - Byte *next_out; /* == stream.next_out but not forced far (for MSDOS) */ - - if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR; - - if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1; - if (s->z_err == Z_STREAM_END) return 0; /* EOF */ - - next_out = (Byte*)buf; - s->stream.next_out = (Bytef*)buf; - s->stream.avail_out = len; - - if (s->stream.avail_out && s->back != EOF) { - *next_out++ = s->back; - s->stream.next_out++; - s->stream.avail_out--; - s->back = EOF; - s->out++; - start++; - if (s->last) { - s->z_err = Z_STREAM_END; - return 1; - } - } - - while (s->stream.avail_out != 0) { - - if (s->transparent) { - /* Copy first the lookahead bytes: */ - uInt n = s->stream.avail_in; - if (n > s->stream.avail_out) n = s->stream.avail_out; - if (n > 0) { - zmemcpy(s->stream.next_out, s->stream.next_in, n); - next_out += n; - s->stream.next_out = next_out; - s->stream.next_in += n; - s->stream.avail_out -= n; - s->stream.avail_in -= n; - } - if (s->stream.avail_out > 0) { - s->stream.avail_out -= - (uInt)fread(next_out, 1, s->stream.avail_out, s->file); - } - len -= s->stream.avail_out; - s->in += len; - s->out += len; - if (len == 0) s->z_eof = 1; - return (int)len; - } - if (s->stream.avail_in == 0 && !s->z_eof) { - - errno = 0; - s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file); - if (s->stream.avail_in == 0) { - s->z_eof = 1; - if (ferror(s->file)) { - s->z_err = Z_ERRNO; - break; - } - } - s->stream.next_in = s->inbuf; - } - s->in += s->stream.avail_in; - s->out += s->stream.avail_out; - s->z_err = inflate(&(s->stream), Z_NO_FLUSH); - s->in -= s->stream.avail_in; - s->out -= s->stream.avail_out; - - if (s->z_err == Z_STREAM_END) { - /* Check CRC and original size */ - s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start)); - start = s->stream.next_out; - - if (getLong(s) != s->crc) { - s->z_err = Z_DATA_ERROR; - } else { - (void)getLong(s); - /* The uncompressed length returned by above getlong() may be - * different from s->out in case of concatenated .gz files. - * Check for such files: - */ - check_header(s); - if (s->z_err == Z_OK) { - inflateReset(&(s->stream)); - s->crc = crc32(0L, Z_NULL, 0); - } - } - } - if (s->z_err != Z_OK || s->z_eof) break; - } - s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start)); - - if (len == s->stream.avail_out && - (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO)) - return -1; - return (int)(len - s->stream.avail_out); -} - - -/* =========================================================================== - Reads one byte from the compressed file. gzgetc returns this byte - or -1 in case of end of file or error. -*/ -int ZEXPORT gzgetc(file) - gzFile file; -{ - unsigned char c; - - return gzread(file, &c, 1) == 1 ? c : -1; -} - - -/* =========================================================================== - Push one byte back onto the stream. -*/ -int ZEXPORT gzungetc(c, file) - int c; - gzFile file; -{ - gz_stream *s = (gz_stream*)file; - - if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF; - s->back = c; - s->out--; - s->last = (s->z_err == Z_STREAM_END); - if (s->last) s->z_err = Z_OK; - s->z_eof = 0; - return c; -} - - -/* =========================================================================== - Reads bytes from the compressed file until len-1 characters are - read, or a newline character is read and transferred to buf, or an - end-of-file condition is encountered. The string is then terminated - with a null character. - gzgets returns buf, or Z_NULL in case of error. - - The current implementation is not optimized at all. -*/ -char * ZEXPORT gzgets(file, buf, len) - gzFile file; - char *buf; - int len; -{ - char *b = buf; - if (buf == Z_NULL || len <= 0) return Z_NULL; - - while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ; - *buf = '\0'; - return b == buf && len > 0 ? Z_NULL : b; -} - - -#ifndef NO_GZCOMPRESS -/* =========================================================================== - Writes the given number of uncompressed bytes into the compressed file. - gzwrite returns the number of bytes actually written (0 in case of error). -*/ -int ZEXPORT gzwrite (file, buf, len) - gzFile file; - voidpc buf; - unsigned len; -{ - gz_stream *s = (gz_stream*)file; - - if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR; - - s->stream.next_in = (Bytef*)buf; - s->stream.avail_in = len; - - while (s->stream.avail_in != 0) { - - if (s->stream.avail_out == 0) { - - s->stream.next_out = s->outbuf; - if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) { - s->z_err = Z_ERRNO; - break; - } - s->stream.avail_out = Z_BUFSIZE; - } - s->in += s->stream.avail_in; - s->out += s->stream.avail_out; - s->z_err = deflate(&(s->stream), Z_NO_FLUSH); - s->in -= s->stream.avail_in; - s->out -= s->stream.avail_out; - if (s->z_err != Z_OK) break; - } - s->crc = crc32(s->crc, (const Bytef *)buf, len); - - return (int)(len - s->stream.avail_in); -} - - -/* =========================================================================== - Converts, formats, and writes the args to the compressed file under - control of the format string, as in fprintf. gzprintf returns the number of - uncompressed bytes actually written (0 in case of error). -*/ -#ifdef STDC -#include - -int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...) -{ - char buf[Z_PRINTF_BUFSIZE]; - va_list va; - int len; - - buf[sizeof(buf) - 1] = 0; - va_start(va, format); -#ifdef NO_vsnprintf -# ifdef HAS_vsprintf_void - (void)vsprintf(buf, format, va); - va_end(va); - for (len = 0; len < sizeof(buf); len++) - if (buf[len] == 0) break; -# else - len = vsprintf(buf, format, va); - va_end(va); -# endif -#else -# ifdef HAS_vsnprintf_void - (void)vsnprintf(buf, sizeof(buf), format, va); - va_end(va); - len = strlen(buf); -# else - len = vsnprintf(buf, sizeof(buf), format, va); - va_end(va); -# endif -#endif - if (len <= 0 || len >= (int)sizeof(buf) || buf[sizeof(buf) - 1] != 0) - return 0; - return gzwrite(file, buf, (unsigned)len); -} -#else /* not ANSI C */ - -int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, - a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) - gzFile file; - const char *format; - int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, - a11, a12, a13, a14, a15, a16, a17, a18, a19, a20; -{ - char buf[Z_PRINTF_BUFSIZE]; - int len; - - buf[sizeof(buf) - 1] = 0; -#ifdef NO_snprintf -# ifdef HAS_sprintf_void - sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8, - a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); - for (len = 0; len < sizeof(buf); len++) - if (buf[len] == 0) break; -# else - len = sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8, - a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); -# endif -#else -# ifdef HAS_snprintf_void - snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8, - a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); - len = strlen(buf); -# else - len = snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8, - a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); -# endif -#endif - if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0) - return 0; - return gzwrite(file, buf, len); -} -#endif - -/* =========================================================================== - Writes c, converted to an unsigned char, into the compressed file. - gzputc returns the value that was written, or -1 in case of error. -*/ -int ZEXPORT gzputc(file, c) - gzFile file; - int c; -{ - unsigned char cc = (unsigned char) c; /* required for big endian systems */ - - return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1; -} - - -/* =========================================================================== - Writes the given null-terminated string to the compressed file, excluding - the terminating null character. - gzputs returns the number of characters written, or -1 in case of error. -*/ -int ZEXPORT gzputs(file, s) - gzFile file; - const char *s; -{ - return gzwrite(file, (char*)s, (unsigned)strlen(s)); -} - - -/* =========================================================================== - Flushes all pending output into the compressed file. The parameter - flush is as in the deflate() function. -*/ -local int do_flush (file, flush) - gzFile file; - int flush; -{ - uInt len; - int done = 0; - gz_stream *s = (gz_stream*)file; - - if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR; - - s->stream.avail_in = 0; /* should be zero already anyway */ - - for (;;) { - len = Z_BUFSIZE - s->stream.avail_out; - - if (len != 0) { - if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) { - s->z_err = Z_ERRNO; - return Z_ERRNO; - } - s->stream.next_out = s->outbuf; - s->stream.avail_out = Z_BUFSIZE; - } - if (done) break; - s->out += s->stream.avail_out; - s->z_err = deflate(&(s->stream), flush); - s->out -= s->stream.avail_out; - - /* Ignore the second of two consecutive flushes: */ - if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK; - - /* deflate has finished flushing only when it hasn't used up - * all the available space in the output buffer: - */ - done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END); - - if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break; - } - return s->z_err == Z_STREAM_END ? Z_OK : s->z_err; -} - -int ZEXPORT gzflush (file, flush) - gzFile file; - int flush; -{ - gz_stream *s = (gz_stream*)file; - int err = do_flush (file, flush); - - if (err) return err; - fflush(s->file); - return s->z_err == Z_STREAM_END ? Z_OK : s->z_err; -} -#endif /* NO_GZCOMPRESS */ - -/* =========================================================================== - Sets the starting position for the next gzread or gzwrite on the given - compressed file. The offset represents a number of bytes in the - gzseek returns the resulting offset location as measured in bytes from - the beginning of the uncompressed stream, or -1 in case of error. - SEEK_END is not implemented, returns error. - In this version of the library, gzseek can be extremely slow. -*/ -z_off_t ZEXPORT gzseek (file, offset, whence) - gzFile file; - z_off_t offset; - int whence; -{ - gz_stream *s = (gz_stream*)file; - - if (s == NULL || whence == SEEK_END || - s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) { - return -1L; - } - - if (s->mode == 'w') { -#ifdef NO_GZCOMPRESS - return -1L; -#else - if (whence == SEEK_SET) { - offset -= s->in; - } - if (offset < 0) return -1L; - - /* At this point, offset is the number of zero bytes to write. */ - if (s->inbuf == Z_NULL) { - s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */ - if (s->inbuf == Z_NULL) return -1L; - zmemzero(s->inbuf, Z_BUFSIZE); - } - while (offset > 0) { - uInt size = Z_BUFSIZE; - if (offset < Z_BUFSIZE) size = (uInt)offset; - - size = gzwrite(file, s->inbuf, size); - if (size == 0) return -1L; - - offset -= size; - } - return s->in; -#endif - } - /* Rest of function is for reading only */ - - /* compute absolute position */ - if (whence == SEEK_CUR) { - offset += s->out; - } - if (offset < 0) return -1L; - - if (s->transparent) { - /* map to fseek */ - s->back = EOF; - s->stream.avail_in = 0; - s->stream.next_in = s->inbuf; - if (fseek(s->file, offset, SEEK_SET) < 0) return -1L; - - s->in = s->out = offset; - return offset; - } - - /* For a negative seek, rewind and use positive seek */ - if (offset >= s->out) { - offset -= s->out; - } else if (gzrewind(file) < 0) { - return -1L; - } - /* offset is now the number of bytes to skip. */ - - if (offset != 0 && s->outbuf == Z_NULL) { - s->outbuf = (Byte*)ALLOC(Z_BUFSIZE); - if (s->outbuf == Z_NULL) return -1L; - } - if (offset && s->back != EOF) { - s->back = EOF; - s->out++; - offset--; - if (s->last) s->z_err = Z_STREAM_END; - } - while (offset > 0) { - int size = Z_BUFSIZE; - if (offset < Z_BUFSIZE) size = (int)offset; - - size = gzread(file, s->outbuf, (uInt)size); - if (size <= 0) return -1L; - offset -= size; - } - return s->out; -} - -/* =========================================================================== - Rewinds input file. -*/ -int ZEXPORT gzrewind (file) - gzFile file; -{ - gz_stream *s = (gz_stream*)file; - - if (s == NULL || s->mode != 'r') return -1; - - s->z_err = Z_OK; - s->z_eof = 0; - s->back = EOF; - s->stream.avail_in = 0; - s->stream.next_in = s->inbuf; - s->crc = crc32(0L, Z_NULL, 0); - if (!s->transparent) (void)inflateReset(&s->stream); - s->in = 0; - s->out = 0; - return fseek(s->file, s->start, SEEK_SET); -} - -/* =========================================================================== - Returns the starting position for the next gzread or gzwrite on the - given compressed file. This position represents a number of bytes in the - uncompressed data stream. -*/ -z_off_t ZEXPORT gztell (file) - gzFile file; -{ - return gzseek(file, 0L, SEEK_CUR); -} - -/* =========================================================================== - Returns 1 when EOF has previously been detected reading the given - input stream, otherwise zero. -*/ -int ZEXPORT gzeof (file) - gzFile file; -{ - gz_stream *s = (gz_stream*)file; - - /* With concatenated compressed files that can have embedded - * crc trailers, z_eof is no longer the only/best indicator of EOF - * on a gz_stream. Handle end-of-stream error explicitly here. - */ - if (s == NULL || s->mode != 'r') return 0; - if (s->z_eof) return 1; - return s->z_err == Z_STREAM_END; -} - -/* =========================================================================== - Returns 1 if reading and doing so transparently, otherwise zero. -*/ -int ZEXPORT gzdirect (file) - gzFile file; -{ - gz_stream *s = (gz_stream*)file; - - if (s == NULL || s->mode != 'r') return 0; - return s->transparent; -} - -/* =========================================================================== - Outputs a long in LSB order to the given file -*/ -local void putLong (file, x) - FILE *file; - uLong x; -{ - int n; - for (n = 0; n < 4; n++) { - fputc((int)(x & 0xff), file); - x >>= 8; - } -} - -/* =========================================================================== - Reads a long in LSB order from the given gz_stream. Sets z_err in case - of error. -*/ -local uLong getLong (s) - gz_stream *s; -{ - uLong x = (uLong)get_byte(s); - int c; - - x += ((uLong)get_byte(s))<<8; - x += ((uLong)get_byte(s))<<16; - c = get_byte(s); - if (c == EOF) s->z_err = Z_DATA_ERROR; - x += ((uLong)c)<<24; - return x; -} - -/* =========================================================================== - Flushes all pending output if necessary, closes the compressed file - and deallocates all the (de)compression state. -*/ -int ZEXPORT gzclose (file) - gzFile file; -{ - gz_stream *s = (gz_stream*)file; - - if (s == NULL) return Z_STREAM_ERROR; - - if (s->mode == 'w') { -#ifdef NO_GZCOMPRESS - return Z_STREAM_ERROR; -#else - if (do_flush (file, Z_FINISH) != Z_OK) - return destroy((gz_stream*)file); - - putLong (s->file, s->crc); - putLong (s->file, (uLong)(s->in & 0xffffffff)); -#endif - } - return destroy((gz_stream*)file); -} - -#ifdef STDC -# define zstrerror(errnum) strerror(errnum) -#else -# define zstrerror(errnum) "" -#endif - -/* =========================================================================== - Returns the error message for the last error which occurred on the - given compressed file. errnum is set to zlib error number. If an - error occurred in the file system and not in the compression library, - errnum is set to Z_ERRNO and the application may consult errno - to get the exact error code. -*/ -const char * ZEXPORT gzerror (file, errnum) - gzFile file; - int *errnum; -{ - char *m; - gz_stream *s = (gz_stream*)file; - - if (s == NULL) { - *errnum = Z_STREAM_ERROR; - return (const char*)ERR_MSG(Z_STREAM_ERROR); - } - *errnum = s->z_err; - if (*errnum == Z_OK) return (const char*)""; - - m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg); - - if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err); - - TRYFREE(s->msg); - s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3); - if (s->msg == Z_NULL) return (const char*)ERR_MSG(Z_MEM_ERROR); - strcpy(s->msg, s->path); - strcat(s->msg, ": "); - strcat(s->msg, m); - return (const char*)s->msg; -} - -/* =========================================================================== - Clear the error and end-of-file flags, and do the same for the real file. -*/ -void ZEXPORT gzclearerr (file) - gzFile file; -{ - gz_stream *s = (gz_stream*)file; - - if (s == NULL) return; - if (s->z_err != Z_STREAM_END) s->z_err = Z_OK; - s->z_eof = 0; - clearerr(s->file); -} diff --git a/ndk/sources/external/zlib/infback.c b/ndk/sources/external/zlib/infback.c deleted file mode 100644 index 455dbc9ee..000000000 --- a/ndk/sources/external/zlib/infback.c +++ /dev/null @@ -1,623 +0,0 @@ -/* infback.c -- inflate using a call-back interface - * Copyright (C) 1995-2005 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* - This code is largely copied from inflate.c. Normally either infback.o or - inflate.o would be linked into an application--not both. The interface - with inffast.c is retained so that optimized assembler-coded versions of - inflate_fast() can be used with either inflate.c or infback.c. - */ - -#include "zutil.h" -#include "inftrees.h" -#include "inflate.h" -#include "inffast.h" - -/* function prototypes */ -local void fixedtables OF((struct inflate_state FAR *state)); - -/* - strm provides memory allocation functions in zalloc and zfree, or - Z_NULL to use the library memory allocation functions. - - windowBits is in the range 8..15, and window is a user-supplied - window and output buffer that is 2**windowBits bytes. - */ -int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size) -z_streamp strm; -int windowBits; -unsigned char FAR *window; -const char *version; -int stream_size; -{ - struct inflate_state FAR *state; - - if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || - stream_size != (int)(sizeof(z_stream))) - return Z_VERSION_ERROR; - if (strm == Z_NULL || window == Z_NULL || - windowBits < 8 || windowBits > 15) - return Z_STREAM_ERROR; - strm->msg = Z_NULL; /* in case we return an error */ - if (strm->zalloc == (alloc_func)0) { - strm->zalloc = zcalloc; - strm->opaque = (voidpf)0; - } - if (strm->zfree == (free_func)0) strm->zfree = zcfree; - state = (struct inflate_state FAR *)ZALLOC(strm, 1, - sizeof(struct inflate_state)); - if (state == Z_NULL) return Z_MEM_ERROR; - Tracev((stderr, "inflate: allocated\n")); - strm->state = (struct internal_state FAR *)state; - state->dmax = 32768U; - state->wbits = windowBits; - state->wsize = 1U << windowBits; - state->window = window; - state->write = 0; - state->whave = 0; - return Z_OK; -} - -/* - Return state with length and distance decoding tables and index sizes set to - fixed code decoding. Normally this returns fixed tables from inffixed.h. - If BUILDFIXED is defined, then instead this routine builds the tables the - first time it's called, and returns those tables the first time and - thereafter. This reduces the size of the code by about 2K bytes, in - exchange for a little execution time. However, BUILDFIXED should not be - used for threaded applications, since the rewriting of the tables and virgin - may not be thread-safe. - */ -local void fixedtables(state) -struct inflate_state FAR *state; -{ -#ifdef BUILDFIXED - static int virgin = 1; - static code *lenfix, *distfix; - static code fixed[544]; - - /* build fixed huffman tables if first call (may not be thread safe) */ - if (virgin) { - unsigned sym, bits; - static code *next; - - /* literal/length table */ - sym = 0; - while (sym < 144) state->lens[sym++] = 8; - while (sym < 256) state->lens[sym++] = 9; - while (sym < 280) state->lens[sym++] = 7; - while (sym < 288) state->lens[sym++] = 8; - next = fixed; - lenfix = next; - bits = 9; - inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); - - /* distance table */ - sym = 0; - while (sym < 32) state->lens[sym++] = 5; - distfix = next; - bits = 5; - inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); - - /* do this just once */ - virgin = 0; - } -#else /* !BUILDFIXED */ -# include "inffixed.h" -#endif /* BUILDFIXED */ - state->lencode = lenfix; - state->lenbits = 9; - state->distcode = distfix; - state->distbits = 5; -} - -/* Macros for inflateBack(): */ - -/* Load returned state from inflate_fast() */ -#define LOAD() \ - do { \ - put = strm->next_out; \ - left = strm->avail_out; \ - next = strm->next_in; \ - have = strm->avail_in; \ - hold = state->hold; \ - bits = state->bits; \ - } while (0) - -/* Set state from registers for inflate_fast() */ -#define RESTORE() \ - do { \ - strm->next_out = put; \ - strm->avail_out = left; \ - strm->next_in = next; \ - strm->avail_in = have; \ - state->hold = hold; \ - state->bits = bits; \ - } while (0) - -/* Clear the input bit accumulator */ -#define INITBITS() \ - do { \ - hold = 0; \ - bits = 0; \ - } while (0) - -/* Assure that some input is available. If input is requested, but denied, - then return a Z_BUF_ERROR from inflateBack(). */ -#define PULL() \ - do { \ - if (have == 0) { \ - have = in(in_desc, &next); \ - if (have == 0) { \ - next = Z_NULL; \ - ret = Z_BUF_ERROR; \ - goto inf_leave; \ - } \ - } \ - } while (0) - -/* Get a byte of input into the bit accumulator, or return from inflateBack() - with an error if there is no input available. */ -#define PULLBYTE() \ - do { \ - PULL(); \ - have--; \ - hold += (unsigned long)(*next++) << bits; \ - bits += 8; \ - } while (0) - -/* Assure that there are at least n bits in the bit accumulator. If there is - not enough available input to do that, then return from inflateBack() with - an error. */ -#define NEEDBITS(n) \ - do { \ - while (bits < (unsigned)(n)) \ - PULLBYTE(); \ - } while (0) - -/* Return the low n bits of the bit accumulator (n < 16) */ -#define BITS(n) \ - ((unsigned)hold & ((1U << (n)) - 1)) - -/* Remove n bits from the bit accumulator */ -#define DROPBITS(n) \ - do { \ - hold >>= (n); \ - bits -= (unsigned)(n); \ - } while (0) - -/* Remove zero to seven bits as needed to go to a byte boundary */ -#define BYTEBITS() \ - do { \ - hold >>= bits & 7; \ - bits -= bits & 7; \ - } while (0) - -/* Assure that some output space is available, by writing out the window - if it's full. If the write fails, return from inflateBack() with a - Z_BUF_ERROR. */ -#define ROOM() \ - do { \ - if (left == 0) { \ - put = state->window; \ - left = state->wsize; \ - state->whave = left; \ - if (out(out_desc, put, left)) { \ - ret = Z_BUF_ERROR; \ - goto inf_leave; \ - } \ - } \ - } while (0) - -/* - strm provides the memory allocation functions and window buffer on input, - and provides information on the unused input on return. For Z_DATA_ERROR - returns, strm will also provide an error message. - - in() and out() are the call-back input and output functions. When - inflateBack() needs more input, it calls in(). When inflateBack() has - filled the window with output, or when it completes with data in the - window, it calls out() to write out the data. The application must not - change the provided input until in() is called again or inflateBack() - returns. The application must not change the window/output buffer until - inflateBack() returns. - - in() and out() are called with a descriptor parameter provided in the - inflateBack() call. This parameter can be a structure that provides the - information required to do the read or write, as well as accumulated - information on the input and output such as totals and check values. - - in() should return zero on failure. out() should return non-zero on - failure. If either in() or out() fails, than inflateBack() returns a - Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it - was in() or out() that caused in the error. Otherwise, inflateBack() - returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format - error, or Z_MEM_ERROR if it could not allocate memory for the state. - inflateBack() can also return Z_STREAM_ERROR if the input parameters - are not correct, i.e. strm is Z_NULL or the state was not initialized. - */ -int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc) -z_streamp strm; -in_func in; -void FAR *in_desc; -out_func out; -void FAR *out_desc; -{ - struct inflate_state FAR *state; - unsigned char FAR *next; /* next input */ - unsigned char FAR *put; /* next output */ - unsigned have, left; /* available input and output */ - unsigned long hold; /* bit buffer */ - unsigned bits; /* bits in bit buffer */ - unsigned copy; /* number of stored or match bytes to copy */ - unsigned char FAR *from; /* where to copy match bytes from */ - code this; /* current decoding table entry */ - code last; /* parent table entry */ - unsigned len; /* length to copy for repeats, bits to drop */ - int ret; /* return code */ - static const unsigned short order[19] = /* permutation of code lengths */ - {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; - - /* Check that the strm exists and that the state was initialized */ - if (strm == Z_NULL || strm->state == Z_NULL) - return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - - /* Reset the state */ - strm->msg = Z_NULL; - state->mode = TYPE; - state->last = 0; - state->whave = 0; - next = strm->next_in; - have = next != Z_NULL ? strm->avail_in : 0; - hold = 0; - bits = 0; - put = state->window; - left = state->wsize; - - /* Inflate until end of block marked as last */ - for (;;) - switch (state->mode) { - case TYPE: - /* determine and dispatch block type */ - if (state->last) { - BYTEBITS(); - state->mode = DONE; - break; - } - NEEDBITS(3); - state->last = BITS(1); - DROPBITS(1); - switch (BITS(2)) { - case 0: /* stored block */ - Tracev((stderr, "inflate: stored block%s\n", - state->last ? " (last)" : "")); - state->mode = STORED; - break; - case 1: /* fixed block */ - fixedtables(state); - Tracev((stderr, "inflate: fixed codes block%s\n", - state->last ? " (last)" : "")); - state->mode = LEN; /* decode codes */ - break; - case 2: /* dynamic block */ - Tracev((stderr, "inflate: dynamic codes block%s\n", - state->last ? " (last)" : "")); - state->mode = TABLE; - break; - case 3: - strm->msg = (char *)"invalid block type"; - state->mode = BAD; - } - DROPBITS(2); - break; - - case STORED: - /* get and verify stored block length */ - BYTEBITS(); /* go to byte boundary */ - NEEDBITS(32); - if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { - strm->msg = (char *)"invalid stored block lengths"; - state->mode = BAD; - break; - } - state->length = (unsigned)hold & 0xffff; - Tracev((stderr, "inflate: stored length %u\n", - state->length)); - INITBITS(); - - /* copy stored block from input to output */ - while (state->length != 0) { - copy = state->length; - PULL(); - ROOM(); - if (copy > have) copy = have; - if (copy > left) copy = left; - zmemcpy(put, next, copy); - have -= copy; - next += copy; - left -= copy; - put += copy; - state->length -= copy; - } - Tracev((stderr, "inflate: stored end\n")); - state->mode = TYPE; - break; - - case TABLE: - /* get dynamic table entries descriptor */ - NEEDBITS(14); - state->nlen = BITS(5) + 257; - DROPBITS(5); - state->ndist = BITS(5) + 1; - DROPBITS(5); - state->ncode = BITS(4) + 4; - DROPBITS(4); -#ifndef PKZIP_BUG_WORKAROUND - if (state->nlen > 286 || state->ndist > 30) { - strm->msg = (char *)"too many length or distance symbols"; - state->mode = BAD; - break; - } -#endif - Tracev((stderr, "inflate: table sizes ok\n")); - - /* get code length code lengths (not a typo) */ - state->have = 0; - while (state->have < state->ncode) { - NEEDBITS(3); - state->lens[order[state->have++]] = (unsigned short)BITS(3); - DROPBITS(3); - } - while (state->have < 19) - state->lens[order[state->have++]] = 0; - state->next = state->codes; - state->lencode = (code const FAR *)(state->next); - state->lenbits = 7; - ret = inflate_table(CODES, state->lens, 19, &(state->next), - &(state->lenbits), state->work); - if (ret) { - strm->msg = (char *)"invalid code lengths set"; - state->mode = BAD; - break; - } - Tracev((stderr, "inflate: code lengths ok\n")); - - /* get length and distance code code lengths */ - state->have = 0; - while (state->have < state->nlen + state->ndist) { - for (;;) { - this = state->lencode[BITS(state->lenbits)]; - if ((unsigned)(this.bits) <= bits) break; - PULLBYTE(); - } - if (this.val < 16) { - NEEDBITS(this.bits); - DROPBITS(this.bits); - state->lens[state->have++] = this.val; - } - else { - if (this.val == 16) { - NEEDBITS(this.bits + 2); - DROPBITS(this.bits); - if (state->have == 0) { - strm->msg = (char *)"invalid bit length repeat"; - state->mode = BAD; - break; - } - len = (unsigned)(state->lens[state->have - 1]); - copy = 3 + BITS(2); - DROPBITS(2); - } - else if (this.val == 17) { - NEEDBITS(this.bits + 3); - DROPBITS(this.bits); - len = 0; - copy = 3 + BITS(3); - DROPBITS(3); - } - else { - NEEDBITS(this.bits + 7); - DROPBITS(this.bits); - len = 0; - copy = 11 + BITS(7); - DROPBITS(7); - } - if (state->have + copy > state->nlen + state->ndist) { - strm->msg = (char *)"invalid bit length repeat"; - state->mode = BAD; - break; - } - while (copy--) - state->lens[state->have++] = (unsigned short)len; - } - } - - /* handle error breaks in while */ - if (state->mode == BAD) break; - - /* build code tables */ - state->next = state->codes; - state->lencode = (code const FAR *)(state->next); - state->lenbits = 9; - ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), - &(state->lenbits), state->work); - if (ret) { - strm->msg = (char *)"invalid literal/lengths set"; - state->mode = BAD; - break; - } - state->distcode = (code const FAR *)(state->next); - state->distbits = 6; - ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, - &(state->next), &(state->distbits), state->work); - if (ret) { - strm->msg = (char *)"invalid distances set"; - state->mode = BAD; - break; - } - Tracev((stderr, "inflate: codes ok\n")); - state->mode = LEN; - - case LEN: - /* use inflate_fast() if we have enough input and output */ - if (have >= 6 && left >= 258) { - RESTORE(); - if (state->whave < state->wsize) - state->whave = state->wsize - left; - inflate_fast(strm, state->wsize); - LOAD(); - break; - } - - /* get a literal, length, or end-of-block code */ - for (;;) { - this = state->lencode[BITS(state->lenbits)]; - if ((unsigned)(this.bits) <= bits) break; - PULLBYTE(); - } - if (this.op && (this.op & 0xf0) == 0) { - last = this; - for (;;) { - this = state->lencode[last.val + - (BITS(last.bits + last.op) >> last.bits)]; - if ((unsigned)(last.bits + this.bits) <= bits) break; - PULLBYTE(); - } - DROPBITS(last.bits); - } - DROPBITS(this.bits); - state->length = (unsigned)this.val; - - /* process literal */ - if (this.op == 0) { - Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ? - "inflate: literal '%c'\n" : - "inflate: literal 0x%02x\n", this.val)); - ROOM(); - *put++ = (unsigned char)(state->length); - left--; - state->mode = LEN; - break; - } - - /* process end of block */ - if (this.op & 32) { - Tracevv((stderr, "inflate: end of block\n")); - state->mode = TYPE; - break; - } - - /* invalid code */ - if (this.op & 64) { - strm->msg = (char *)"invalid literal/length code"; - state->mode = BAD; - break; - } - - /* length code -- get extra bits, if any */ - state->extra = (unsigned)(this.op) & 15; - if (state->extra != 0) { - NEEDBITS(state->extra); - state->length += BITS(state->extra); - DROPBITS(state->extra); - } - Tracevv((stderr, "inflate: length %u\n", state->length)); - - /* get distance code */ - for (;;) { - this = state->distcode[BITS(state->distbits)]; - if ((unsigned)(this.bits) <= bits) break; - PULLBYTE(); - } - if ((this.op & 0xf0) == 0) { - last = this; - for (;;) { - this = state->distcode[last.val + - (BITS(last.bits + last.op) >> last.bits)]; - if ((unsigned)(last.bits + this.bits) <= bits) break; - PULLBYTE(); - } - DROPBITS(last.bits); - } - DROPBITS(this.bits); - if (this.op & 64) { - strm->msg = (char *)"invalid distance code"; - state->mode = BAD; - break; - } - state->offset = (unsigned)this.val; - - /* get distance extra bits, if any */ - state->extra = (unsigned)(this.op) & 15; - if (state->extra != 0) { - NEEDBITS(state->extra); - state->offset += BITS(state->extra); - DROPBITS(state->extra); - } - if (state->offset > state->wsize - (state->whave < state->wsize ? - left : 0)) { - strm->msg = (char *)"invalid distance too far back"; - state->mode = BAD; - break; - } - Tracevv((stderr, "inflate: distance %u\n", state->offset)); - - /* copy match from window to output */ - do { - ROOM(); - copy = state->wsize - state->offset; - if (copy < left) { - from = put + copy; - copy = left - copy; - } - else { - from = put - state->offset; - copy = left; - } - if (copy > state->length) copy = state->length; - state->length -= copy; - left -= copy; - do { - *put++ = *from++; - } while (--copy); - } while (state->length != 0); - break; - - case DONE: - /* inflate stream terminated properly -- write leftover output */ - ret = Z_STREAM_END; - if (left < state->wsize) { - if (out(out_desc, state->window, state->wsize - left)) - ret = Z_BUF_ERROR; - } - goto inf_leave; - - case BAD: - ret = Z_DATA_ERROR; - goto inf_leave; - - default: /* can't happen, but makes compilers happy */ - ret = Z_STREAM_ERROR; - goto inf_leave; - } - - /* Return unused input */ - inf_leave: - strm->next_in = next; - strm->avail_in = have; - return ret; -} - -int ZEXPORT inflateBackEnd(strm) -z_streamp strm; -{ - if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) - return Z_STREAM_ERROR; - ZFREE(strm, strm->state); - strm->state = Z_NULL; - Tracev((stderr, "inflate: end\n")); - return Z_OK; -} diff --git a/ndk/sources/external/zlib/inffast.c b/ndk/sources/external/zlib/inffast.c deleted file mode 100644 index bbee92ed1..000000000 --- a/ndk/sources/external/zlib/inffast.c +++ /dev/null @@ -1,318 +0,0 @@ -/* inffast.c -- fast decoding - * Copyright (C) 1995-2004 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -#include "zutil.h" -#include "inftrees.h" -#include "inflate.h" -#include "inffast.h" - -#ifndef ASMINF - -/* Allow machine dependent optimization for post-increment or pre-increment. - Based on testing to date, - Pre-increment preferred for: - - PowerPC G3 (Adler) - - MIPS R5000 (Randers-Pehrson) - Post-increment preferred for: - - none - No measurable difference: - - Pentium III (Anderson) - - M68060 (Nikl) - */ -#ifdef POSTINC -# define OFF 0 -# define PUP(a) *(a)++ -#else -# define OFF 1 -# define PUP(a) *++(a) -#endif - -/* - Decode literal, length, and distance codes and write out the resulting - literal and match bytes until either not enough input or output is - available, an end-of-block is encountered, or a data error is encountered. - When large enough input and output buffers are supplied to inflate(), for - example, a 16K input buffer and a 64K output buffer, more than 95% of the - inflate execution time is spent in this routine. - - Entry assumptions: - - state->mode == LEN - strm->avail_in >= 6 - strm->avail_out >= 258 - start >= strm->avail_out - state->bits < 8 - - On return, state->mode is one of: - - LEN -- ran out of enough output space or enough available input - TYPE -- reached end of block code, inflate() to interpret next block - BAD -- error in block data - - Notes: - - - The maximum input bits used by a length/distance pair is 15 bits for the - length code, 5 bits for the length extra, 15 bits for the distance code, - and 13 bits for the distance extra. This totals 48 bits, or six bytes. - Therefore if strm->avail_in >= 6, then there is enough input to avoid - checking for available input while decoding. - - - The maximum bytes that a single length/distance pair can output is 258 - bytes, which is the maximum length that can be coded. inflate_fast() - requires strm->avail_out >= 258 for each loop to avoid checking for - output space. - */ -void inflate_fast(strm, start) -z_streamp strm; -unsigned start; /* inflate()'s starting value for strm->avail_out */ -{ - struct inflate_state FAR *state; - unsigned char FAR *in; /* local strm->next_in */ - unsigned char FAR *last; /* while in < last, enough input available */ - unsigned char FAR *out; /* local strm->next_out */ - unsigned char FAR *beg; /* inflate()'s initial strm->next_out */ - unsigned char FAR *end; /* while out < end, enough space available */ -#ifdef INFLATE_STRICT - unsigned dmax; /* maximum distance from zlib header */ -#endif - unsigned wsize; /* window size or zero if not using window */ - unsigned whave; /* valid bytes in the window */ - unsigned write; /* window write index */ - unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */ - unsigned long hold; /* local strm->hold */ - unsigned bits; /* local strm->bits */ - code const FAR *lcode; /* local strm->lencode */ - code const FAR *dcode; /* local strm->distcode */ - unsigned lmask; /* mask for first level of length codes */ - unsigned dmask; /* mask for first level of distance codes */ - code this; /* retrieved table entry */ - unsigned op; /* code bits, operation, extra bits, or */ - /* window position, window bytes to copy */ - unsigned len; /* match length, unused bytes */ - unsigned dist; /* match distance */ - unsigned char FAR *from; /* where to copy match from */ - - /* copy state to local variables */ - state = (struct inflate_state FAR *)strm->state; - in = strm->next_in - OFF; - last = in + (strm->avail_in - 5); - out = strm->next_out - OFF; - beg = out - (start - strm->avail_out); - end = out + (strm->avail_out - 257); -#ifdef INFLATE_STRICT - dmax = state->dmax; -#endif - wsize = state->wsize; - whave = state->whave; - write = state->write; - window = state->window; - hold = state->hold; - bits = state->bits; - lcode = state->lencode; - dcode = state->distcode; - lmask = (1U << state->lenbits) - 1; - dmask = (1U << state->distbits) - 1; - - /* decode literals and length/distances until end-of-block or not enough - input data or output space */ - do { - if (bits < 15) { - hold += (unsigned long)(PUP(in)) << bits; - bits += 8; - hold += (unsigned long)(PUP(in)) << bits; - bits += 8; - } - this = lcode[hold & lmask]; - dolen: - op = (unsigned)(this.bits); - hold >>= op; - bits -= op; - op = (unsigned)(this.op); - if (op == 0) { /* literal */ - Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ? - "inflate: literal '%c'\n" : - "inflate: literal 0x%02x\n", this.val)); - PUP(out) = (unsigned char)(this.val); - } - else if (op & 16) { /* length base */ - len = (unsigned)(this.val); - op &= 15; /* number of extra bits */ - if (op) { - if (bits < op) { - hold += (unsigned long)(PUP(in)) << bits; - bits += 8; - } - len += (unsigned)hold & ((1U << op) - 1); - hold >>= op; - bits -= op; - } - Tracevv((stderr, "inflate: length %u\n", len)); - if (bits < 15) { - hold += (unsigned long)(PUP(in)) << bits; - bits += 8; - hold += (unsigned long)(PUP(in)) << bits; - bits += 8; - } - this = dcode[hold & dmask]; - dodist: - op = (unsigned)(this.bits); - hold >>= op; - bits -= op; - op = (unsigned)(this.op); - if (op & 16) { /* distance base */ - dist = (unsigned)(this.val); - op &= 15; /* number of extra bits */ - if (bits < op) { - hold += (unsigned long)(PUP(in)) << bits; - bits += 8; - if (bits < op) { - hold += (unsigned long)(PUP(in)) << bits; - bits += 8; - } - } - dist += (unsigned)hold & ((1U << op) - 1); -#ifdef INFLATE_STRICT - if (dist > dmax) { - strm->msg = (char *)"invalid distance too far back"; - state->mode = BAD; - break; - } -#endif - hold >>= op; - bits -= op; - Tracevv((stderr, "inflate: distance %u\n", dist)); - op = (unsigned)(out - beg); /* max distance in output */ - if (dist > op) { /* see if copy from window */ - op = dist - op; /* distance back in window */ - if (op > whave) { - strm->msg = (char *)"invalid distance too far back"; - state->mode = BAD; - break; - } - from = window - OFF; - if (write == 0) { /* very common case */ - from += wsize - op; - if (op < len) { /* some from window */ - len -= op; - do { - PUP(out) = PUP(from); - } while (--op); - from = out - dist; /* rest from output */ - } - } - else if (write < op) { /* wrap around window */ - from += wsize + write - op; - op -= write; - if (op < len) { /* some from end of window */ - len -= op; - do { - PUP(out) = PUP(from); - } while (--op); - from = window - OFF; - if (write < len) { /* some from start of window */ - op = write; - len -= op; - do { - PUP(out) = PUP(from); - } while (--op); - from = out - dist; /* rest from output */ - } - } - } - else { /* contiguous in window */ - from += write - op; - if (op < len) { /* some from window */ - len -= op; - do { - PUP(out) = PUP(from); - } while (--op); - from = out - dist; /* rest from output */ - } - } - while (len > 2) { - PUP(out) = PUP(from); - PUP(out) = PUP(from); - PUP(out) = PUP(from); - len -= 3; - } - if (len) { - PUP(out) = PUP(from); - if (len > 1) - PUP(out) = PUP(from); - } - } - else { - from = out - dist; /* copy direct from output */ - do { /* minimum length is three */ - PUP(out) = PUP(from); - PUP(out) = PUP(from); - PUP(out) = PUP(from); - len -= 3; - } while (len > 2); - if (len) { - PUP(out) = PUP(from); - if (len > 1) - PUP(out) = PUP(from); - } - } - } - else if ((op & 64) == 0) { /* 2nd level distance code */ - this = dcode[this.val + (hold & ((1U << op) - 1))]; - goto dodist; - } - else { - strm->msg = (char *)"invalid distance code"; - state->mode = BAD; - break; - } - } - else if ((op & 64) == 0) { /* 2nd level length code */ - this = lcode[this.val + (hold & ((1U << op) - 1))]; - goto dolen; - } - else if (op & 32) { /* end-of-block */ - Tracevv((stderr, "inflate: end of block\n")); - state->mode = TYPE; - break; - } - else { - strm->msg = (char *)"invalid literal/length code"; - state->mode = BAD; - break; - } - } while (in < last && out < end); - - /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ - len = bits >> 3; - in -= len; - bits -= len << 3; - hold &= (1U << bits) - 1; - - /* update state and return */ - strm->next_in = in + OFF; - strm->next_out = out + OFF; - strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last)); - strm->avail_out = (unsigned)(out < end ? - 257 + (end - out) : 257 - (out - end)); - state->hold = hold; - state->bits = bits; - return; -} - -/* - inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe): - - Using bit fields for code structure - - Different op definition to avoid & for extra bits (do & for table bits) - - Three separate decoding do-loops for direct, window, and write == 0 - - Special case for distance > 1 copies to do overlapped load and store copy - - Explicit branch predictions (based on measured branch probabilities) - - Deferring match copy and interspersed it with decoding subsequent codes - - Swapping literal/length else - - Swapping window/direct else - - Larger unrolled copy loops (three is about right) - - Moving len -= 3 statement into middle of loop - */ - -#endif /* !ASMINF */ diff --git a/ndk/sources/external/zlib/inffast.h b/ndk/sources/external/zlib/inffast.h deleted file mode 100644 index 1e88d2d97..000000000 --- a/ndk/sources/external/zlib/inffast.h +++ /dev/null @@ -1,11 +0,0 @@ -/* inffast.h -- header to use inffast.c - * Copyright (C) 1995-2003 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* WARNING: this file should *not* be used by applications. It is - part of the implementation of the compression library and is - subject to change. Applications should only use zlib.h. - */ - -void inflate_fast OF((z_streamp strm, unsigned start)); diff --git a/ndk/sources/external/zlib/inffixed.h b/ndk/sources/external/zlib/inffixed.h deleted file mode 100644 index 75ed4b597..000000000 --- a/ndk/sources/external/zlib/inffixed.h +++ /dev/null @@ -1,94 +0,0 @@ - /* inffixed.h -- table for decoding fixed codes - * Generated automatically by makefixed(). - */ - - /* WARNING: this file should *not* be used by applications. It - is part of the implementation of the compression library and - is subject to change. Applications should only use zlib.h. - */ - - static const code lenfix[512] = { - {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, - {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, - {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, - {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, - {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, - {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, - {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, - {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, - {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, - {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, - {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, - {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, - {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, - {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, - {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, - {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, - {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, - {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142}, - {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, - {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, - {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, - {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, - {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, - {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, - {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, - {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, - {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, - {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, - {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, - {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, - {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, - {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, - {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55}, - {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, - {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, - {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190}, - {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16}, - {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, - {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, - {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, - {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, - {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, - {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, - {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, - {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, - {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, - {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, - {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, - {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, - {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, - {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51}, - {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, - {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, - {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110}, - {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0}, - {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, - {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, - {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, - {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, - {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258}, - {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, - {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, - {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, - {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, - {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, - {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, - {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, - {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, - {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, - {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, - {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, - {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, - {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, - {0,9,255} - }; - - static const code distfix[32] = { - {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, - {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, - {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385}, - {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, - {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, - {22,5,193},{64,5,0} - }; diff --git a/ndk/sources/external/zlib/inflate.c b/ndk/sources/external/zlib/inflate.c deleted file mode 100644 index 792fdee8e..000000000 --- a/ndk/sources/external/zlib/inflate.c +++ /dev/null @@ -1,1368 +0,0 @@ -/* inflate.c -- zlib decompression - * Copyright (C) 1995-2005 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* - * Change history: - * - * 1.2.beta0 24 Nov 2002 - * - First version -- complete rewrite of inflate to simplify code, avoid - * creation of window when not needed, minimize use of window when it is - * needed, make inffast.c even faster, implement gzip decoding, and to - * improve code readability and style over the previous zlib inflate code - * - * 1.2.beta1 25 Nov 2002 - * - Use pointers for available input and output checking in inffast.c - * - Remove input and output counters in inffast.c - * - Change inffast.c entry and loop from avail_in >= 7 to >= 6 - * - Remove unnecessary second byte pull from length extra in inffast.c - * - Unroll direct copy to three copies per loop in inffast.c - * - * 1.2.beta2 4 Dec 2002 - * - Change external routine names to reduce potential conflicts - * - Correct filename to inffixed.h for fixed tables in inflate.c - * - Make hbuf[] unsigned char to match parameter type in inflate.c - * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset) - * to avoid negation problem on Alphas (64 bit) in inflate.c - * - * 1.2.beta3 22 Dec 2002 - * - Add comments on state->bits assertion in inffast.c - * - Add comments on op field in inftrees.h - * - Fix bug in reuse of allocated window after inflateReset() - * - Remove bit fields--back to byte structure for speed - * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths - * - Change post-increments to pre-increments in inflate_fast(), PPC biased? - * - Add compile time option, POSTINC, to use post-increments instead (Intel?) - * - Make MATCH copy in inflate() much faster for when inflate_fast() not used - * - Use local copies of stream next and avail values, as well as local bit - * buffer and bit count in inflate()--for speed when inflate_fast() not used - * - * 1.2.beta4 1 Jan 2003 - * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings - * - Move a comment on output buffer sizes from inffast.c to inflate.c - * - Add comments in inffast.c to introduce the inflate_fast() routine - * - Rearrange window copies in inflate_fast() for speed and simplification - * - Unroll last copy for window match in inflate_fast() - * - Use local copies of window variables in inflate_fast() for speed - * - Pull out common write == 0 case for speed in inflate_fast() - * - Make op and len in inflate_fast() unsigned for consistency - * - Add FAR to lcode and dcode declarations in inflate_fast() - * - Simplified bad distance check in inflate_fast() - * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new - * source file infback.c to provide a call-back interface to inflate for - * programs like gzip and unzip -- uses window as output buffer to avoid - * window copying - * - * 1.2.beta5 1 Jan 2003 - * - Improved inflateBack() interface to allow the caller to provide initial - * input in strm. - * - Fixed stored blocks bug in inflateBack() - * - * 1.2.beta6 4 Jan 2003 - * - Added comments in inffast.c on effectiveness of POSTINC - * - Typecasting all around to reduce compiler warnings - * - Changed loops from while (1) or do {} while (1) to for (;;), again to - * make compilers happy - * - Changed type of window in inflateBackInit() to unsigned char * - * - * 1.2.beta7 27 Jan 2003 - * - Changed many types to unsigned or unsigned short to avoid warnings - * - Added inflateCopy() function - * - * 1.2.0 9 Mar 2003 - * - Changed inflateBack() interface to provide separate opaque descriptors - * for the in() and out() functions - * - Changed inflateBack() argument and in_func typedef to swap the length - * and buffer address return values for the input function - * - Check next_in and next_out for Z_NULL on entry to inflate() - * - * The history for versions after 1.2.0 are in ChangeLog in zlib distribution. - */ - -#include "zutil.h" -#include "inftrees.h" -#include "inflate.h" -#include "inffast.h" - -#ifdef MAKEFIXED -# ifndef BUILDFIXED -# define BUILDFIXED -# endif -#endif - -/* function prototypes */ -local void fixedtables OF((struct inflate_state FAR *state)); -local int updatewindow OF((z_streamp strm, unsigned out)); -#ifdef BUILDFIXED - void makefixed OF((void)); -#endif -local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf, - unsigned len)); - -int ZEXPORT inflateReset(strm) -z_streamp strm; -{ - struct inflate_state FAR *state; - - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - strm->total_in = strm->total_out = state->total = 0; - strm->msg = Z_NULL; - strm->adler = 1; /* to support ill-conceived Java test suite */ - state->mode = HEAD; - state->last = 0; - state->havedict = 0; - state->dmax = 32768U; - state->head = Z_NULL; - state->wsize = 0; - state->whave = 0; - state->write = 0; - state->hold = 0; - state->bits = 0; - state->lencode = state->distcode = state->next = state->codes; - Tracev((stderr, "inflate: reset\n")); - return Z_OK; -} - -int ZEXPORT inflatePrime(strm, bits, value) -z_streamp strm; -int bits; -int value; -{ - struct inflate_state FAR *state; - - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR; - value &= (1L << bits) - 1; - state->hold += value << state->bits; - state->bits += bits; - return Z_OK; -} - -int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size) -z_streamp strm; -int windowBits; -const char *version; -int stream_size; -{ - struct inflate_state FAR *state; - - if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || - stream_size != (int)(sizeof(z_stream))) - return Z_VERSION_ERROR; - if (strm == Z_NULL) return Z_STREAM_ERROR; - strm->msg = Z_NULL; /* in case we return an error */ - if (strm->zalloc == (alloc_func)0) { - strm->zalloc = zcalloc; - strm->opaque = (voidpf)0; - } - if (strm->zfree == (free_func)0) strm->zfree = zcfree; - state = (struct inflate_state FAR *) - ZALLOC(strm, 1, sizeof(struct inflate_state)); - if (state == Z_NULL) return Z_MEM_ERROR; - Tracev((stderr, "inflate: allocated\n")); - strm->state = (struct internal_state FAR *)state; - if (windowBits < 0) { - state->wrap = 0; - windowBits = -windowBits; - } - else { - state->wrap = (windowBits >> 4) + 1; -#ifdef GUNZIP - if (windowBits < 48) windowBits &= 15; -#endif - } - if (windowBits < 8 || windowBits > 15) { - ZFREE(strm, state); - strm->state = Z_NULL; - return Z_STREAM_ERROR; - } - state->wbits = (unsigned)windowBits; - state->window = Z_NULL; - return inflateReset(strm); -} - -int ZEXPORT inflateInit_(strm, version, stream_size) -z_streamp strm; -const char *version; -int stream_size; -{ - return inflateInit2_(strm, DEF_WBITS, version, stream_size); -} - -/* - Return state with length and distance decoding tables and index sizes set to - fixed code decoding. Normally this returns fixed tables from inffixed.h. - If BUILDFIXED is defined, then instead this routine builds the tables the - first time it's called, and returns those tables the first time and - thereafter. This reduces the size of the code by about 2K bytes, in - exchange for a little execution time. However, BUILDFIXED should not be - used for threaded applications, since the rewriting of the tables and virgin - may not be thread-safe. - */ -local void fixedtables(state) -struct inflate_state FAR *state; -{ -#ifdef BUILDFIXED - static int virgin = 1; - static code *lenfix, *distfix; - static code fixed[544]; - - /* build fixed huffman tables if first call (may not be thread safe) */ - if (virgin) { - unsigned sym, bits; - static code *next; - - /* literal/length table */ - sym = 0; - while (sym < 144) state->lens[sym++] = 8; - while (sym < 256) state->lens[sym++] = 9; - while (sym < 280) state->lens[sym++] = 7; - while (sym < 288) state->lens[sym++] = 8; - next = fixed; - lenfix = next; - bits = 9; - inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); - - /* distance table */ - sym = 0; - while (sym < 32) state->lens[sym++] = 5; - distfix = next; - bits = 5; - inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); - - /* do this just once */ - virgin = 0; - } -#else /* !BUILDFIXED */ -# include "inffixed.h" -#endif /* BUILDFIXED */ - state->lencode = lenfix; - state->lenbits = 9; - state->distcode = distfix; - state->distbits = 5; -} - -#ifdef MAKEFIXED -#include - -/* - Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also - defines BUILDFIXED, so the tables are built on the fly. makefixed() writes - those tables to stdout, which would be piped to inffixed.h. A small program - can simply call makefixed to do this: - - void makefixed(void); - - int main(void) - { - makefixed(); - return 0; - } - - Then that can be linked with zlib built with MAKEFIXED defined and run: - - a.out > inffixed.h - */ -void makefixed() -{ - unsigned low, size; - struct inflate_state state; - - fixedtables(&state); - puts(" /* inffixed.h -- table for decoding fixed codes"); - puts(" * Generated automatically by makefixed()."); - puts(" */"); - puts(""); - puts(" /* WARNING: this file should *not* be used by applications."); - puts(" It is part of the implementation of this library and is"); - puts(" subject to change. Applications should only use zlib.h."); - puts(" */"); - puts(""); - size = 1U << 9; - printf(" static const code lenfix[%u] = {", size); - low = 0; - for (;;) { - if ((low % 7) == 0) printf("\n "); - printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits, - state.lencode[low].val); - if (++low == size) break; - putchar(','); - } - puts("\n };"); - size = 1U << 5; - printf("\n static const code distfix[%u] = {", size); - low = 0; - for (;;) { - if ((low % 6) == 0) printf("\n "); - printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, - state.distcode[low].val); - if (++low == size) break; - putchar(','); - } - puts("\n };"); -} -#endif /* MAKEFIXED */ - -/* - Update the window with the last wsize (normally 32K) bytes written before - returning. If window does not exist yet, create it. This is only called - when a window is already in use, or when output has been written during this - inflate call, but the end of the deflate stream has not been reached yet. - It is also called to create a window for dictionary data when a dictionary - is loaded. - - Providing output buffers larger than 32K to inflate() should provide a speed - advantage, since only the last 32K of output is copied to the sliding window - upon return from inflate(), and since all distances after the first 32K of - output will fall in the output data, making match copies simpler and faster. - The advantage may be dependent on the size of the processor's data caches. - */ -local int updatewindow(strm, out) -z_streamp strm; -unsigned out; -{ - struct inflate_state FAR *state; - unsigned copy, dist; - - state = (struct inflate_state FAR *)strm->state; - - /* if it hasn't been done already, allocate space for the window */ - if (state->window == Z_NULL) { - state->window = (unsigned char FAR *) - ZALLOC(strm, 1U << state->wbits, - sizeof(unsigned char)); - if (state->window == Z_NULL) return 1; - } - - /* if window not in use yet, initialize */ - if (state->wsize == 0) { - state->wsize = 1U << state->wbits; - state->write = 0; - state->whave = 0; - } - - /* copy state->wsize or less output bytes into the circular window */ - copy = out - strm->avail_out; - if (copy >= state->wsize) { - zmemcpy(state->window, strm->next_out - state->wsize, state->wsize); - state->write = 0; - state->whave = state->wsize; - } - else { - dist = state->wsize - state->write; - if (dist > copy) dist = copy; - zmemcpy(state->window + state->write, strm->next_out - copy, dist); - copy -= dist; - if (copy) { - zmemcpy(state->window, strm->next_out - copy, copy); - state->write = copy; - state->whave = state->wsize; - } - else { - state->write += dist; - if (state->write == state->wsize) state->write = 0; - if (state->whave < state->wsize) state->whave += dist; - } - } - return 0; -} - -/* Macros for inflate(): */ - -/* check function to use adler32() for zlib or crc32() for gzip */ -#ifdef GUNZIP -# define UPDATE(check, buf, len) \ - (state->flags ? crc32(check, buf, len) : adler32(check, buf, len)) -#else -# define UPDATE(check, buf, len) adler32(check, buf, len) -#endif - -/* check macros for header crc */ -#ifdef GUNZIP -# define CRC2(check, word) \ - do { \ - hbuf[0] = (unsigned char)(word); \ - hbuf[1] = (unsigned char)((word) >> 8); \ - check = crc32(check, hbuf, 2); \ - } while (0) - -# define CRC4(check, word) \ - do { \ - hbuf[0] = (unsigned char)(word); \ - hbuf[1] = (unsigned char)((word) >> 8); \ - hbuf[2] = (unsigned char)((word) >> 16); \ - hbuf[3] = (unsigned char)((word) >> 24); \ - check = crc32(check, hbuf, 4); \ - } while (0) -#endif - -/* Load registers with state in inflate() for speed */ -#define LOAD() \ - do { \ - put = strm->next_out; \ - left = strm->avail_out; \ - next = strm->next_in; \ - have = strm->avail_in; \ - hold = state->hold; \ - bits = state->bits; \ - } while (0) - -/* Restore state from registers in inflate() */ -#define RESTORE() \ - do { \ - strm->next_out = put; \ - strm->avail_out = left; \ - strm->next_in = next; \ - strm->avail_in = have; \ - state->hold = hold; \ - state->bits = bits; \ - } while (0) - -/* Clear the input bit accumulator */ -#define INITBITS() \ - do { \ - hold = 0; \ - bits = 0; \ - } while (0) - -/* Get a byte of input into the bit accumulator, or return from inflate() - if there is no input available. */ -#define PULLBYTE() \ - do { \ - if (have == 0) goto inf_leave; \ - have--; \ - hold += (unsigned long)(*next++) << bits; \ - bits += 8; \ - } while (0) - -/* Assure that there are at least n bits in the bit accumulator. If there is - not enough available input to do that, then return from inflate(). */ -#define NEEDBITS(n) \ - do { \ - while (bits < (unsigned)(n)) \ - PULLBYTE(); \ - } while (0) - -/* Return the low n bits of the bit accumulator (n < 16) */ -#define BITS(n) \ - ((unsigned)hold & ((1U << (n)) - 1)) - -/* Remove n bits from the bit accumulator */ -#define DROPBITS(n) \ - do { \ - hold >>= (n); \ - bits -= (unsigned)(n); \ - } while (0) - -/* Remove zero to seven bits as needed to go to a byte boundary */ -#define BYTEBITS() \ - do { \ - hold >>= bits & 7; \ - bits -= bits & 7; \ - } while (0) - -/* Reverse the bytes in a 32-bit value */ -#define REVERSE(q) \ - ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ - (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) - -/* - inflate() uses a state machine to process as much input data and generate as - much output data as possible before returning. The state machine is - structured roughly as follows: - - for (;;) switch (state) { - ... - case STATEn: - if (not enough input data or output space to make progress) - return; - ... make progress ... - state = STATEm; - break; - ... - } - - so when inflate() is called again, the same case is attempted again, and - if the appropriate resources are provided, the machine proceeds to the - next state. The NEEDBITS() macro is usually the way the state evaluates - whether it can proceed or should return. NEEDBITS() does the return if - the requested bits are not available. The typical use of the BITS macros - is: - - NEEDBITS(n); - ... do something with BITS(n) ... - DROPBITS(n); - - where NEEDBITS(n) either returns from inflate() if there isn't enough - input left to load n bits into the accumulator, or it continues. BITS(n) - gives the low n bits in the accumulator. When done, DROPBITS(n) drops - the low n bits off the accumulator. INITBITS() clears the accumulator - and sets the number of available bits to zero. BYTEBITS() discards just - enough bits to put the accumulator on a byte boundary. After BYTEBITS() - and a NEEDBITS(8), then BITS(8) would return the next byte in the stream. - - NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return - if there is no input available. The decoding of variable length codes uses - PULLBYTE() directly in order to pull just enough bytes to decode the next - code, and no more. - - Some states loop until they get enough input, making sure that enough - state information is maintained to continue the loop where it left off - if NEEDBITS() returns in the loop. For example, want, need, and keep - would all have to actually be part of the saved state in case NEEDBITS() - returns: - - case STATEw: - while (want < need) { - NEEDBITS(n); - keep[want++] = BITS(n); - DROPBITS(n); - } - state = STATEx; - case STATEx: - - As shown above, if the next state is also the next case, then the break - is omitted. - - A state may also return if there is not enough output space available to - complete that state. Those states are copying stored data, writing a - literal byte, and copying a matching string. - - When returning, a "goto inf_leave" is used to update the total counters, - update the check value, and determine whether any progress has been made - during that inflate() call in order to return the proper return code. - Progress is defined as a change in either strm->avail_in or strm->avail_out. - When there is a window, goto inf_leave will update the window with the last - output written. If a goto inf_leave occurs in the middle of decompression - and there is no window currently, goto inf_leave will create one and copy - output to the window for the next call of inflate(). - - In this implementation, the flush parameter of inflate() only affects the - return code (per zlib.h). inflate() always writes as much as possible to - strm->next_out, given the space available and the provided input--the effect - documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers - the allocation of and copying into a sliding window until necessary, which - provides the effect documented in zlib.h for Z_FINISH when the entire input - stream available. So the only thing the flush parameter actually does is: - when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it - will return Z_BUF_ERROR if it has not reached the end of the stream. - */ - -int ZEXPORT inflate(strm, flush) -z_streamp strm; -int flush; -{ - struct inflate_state FAR *state; - unsigned char FAR *next; /* next input */ - unsigned char FAR *put; /* next output */ - unsigned have, left; /* available input and output */ - unsigned long hold; /* bit buffer */ - unsigned bits; /* bits in bit buffer */ - unsigned in, out; /* save starting available input and output */ - unsigned copy; /* number of stored or match bytes to copy */ - unsigned char FAR *from; /* where to copy match bytes from */ - code this; /* current decoding table entry */ - code last; /* parent table entry */ - unsigned len; /* length to copy for repeats, bits to drop */ - int ret; /* return code */ -#ifdef GUNZIP - unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ -#endif - static const unsigned short order[19] = /* permutation of code lengths */ - {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; - - if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL || - (strm->next_in == Z_NULL && strm->avail_in != 0)) - return Z_STREAM_ERROR; - - state = (struct inflate_state FAR *)strm->state; - if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */ - LOAD(); - in = have; - out = left; - ret = Z_OK; - for (;;) - switch (state->mode) { - case HEAD: - if (state->wrap == 0) { - state->mode = TYPEDO; - break; - } - NEEDBITS(16); -#ifdef GUNZIP - if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */ - state->check = crc32(0L, Z_NULL, 0); - CRC2(state->check, hold); - INITBITS(); - state->mode = FLAGS; - break; - } - state->flags = 0; /* expect zlib header */ - if (state->head != Z_NULL) - state->head->done = -1; - if (!(state->wrap & 1) || /* check if zlib header allowed */ -#else - if ( -#endif - ((BITS(8) << 8) + (hold >> 8)) % 31) { - strm->msg = (char *)"incorrect header check"; - state->mode = BAD; - break; - } - if (BITS(4) != Z_DEFLATED) { - strm->msg = (char *)"unknown compression method"; - state->mode = BAD; - break; - } - DROPBITS(4); - len = BITS(4) + 8; - if (len > state->wbits) { - strm->msg = (char *)"invalid window size"; - state->mode = BAD; - break; - } - state->dmax = 1U << len; - Tracev((stderr, "inflate: zlib header ok\n")); - strm->adler = state->check = adler32(0L, Z_NULL, 0); - state->mode = hold & 0x200 ? DICTID : TYPE; - INITBITS(); - break; -#ifdef GUNZIP - case FLAGS: - NEEDBITS(16); - state->flags = (int)(hold); - if ((state->flags & 0xff) != Z_DEFLATED) { - strm->msg = (char *)"unknown compression method"; - state->mode = BAD; - break; - } - if (state->flags & 0xe000) { - strm->msg = (char *)"unknown header flags set"; - state->mode = BAD; - break; - } - if (state->head != Z_NULL) - state->head->text = (int)((hold >> 8) & 1); - if (state->flags & 0x0200) CRC2(state->check, hold); - INITBITS(); - state->mode = TIME; - case TIME: - NEEDBITS(32); - if (state->head != Z_NULL) - state->head->time = hold; - if (state->flags & 0x0200) CRC4(state->check, hold); - INITBITS(); - state->mode = OS; - case OS: - NEEDBITS(16); - if (state->head != Z_NULL) { - state->head->xflags = (int)(hold & 0xff); - state->head->os = (int)(hold >> 8); - } - if (state->flags & 0x0200) CRC2(state->check, hold); - INITBITS(); - state->mode = EXLEN; - case EXLEN: - if (state->flags & 0x0400) { - NEEDBITS(16); - state->length = (unsigned)(hold); - if (state->head != Z_NULL) - state->head->extra_len = (unsigned)hold; - if (state->flags & 0x0200) CRC2(state->check, hold); - INITBITS(); - } - else if (state->head != Z_NULL) - state->head->extra = Z_NULL; - state->mode = EXTRA; - case EXTRA: - if (state->flags & 0x0400) { - copy = state->length; - if (copy > have) copy = have; - if (copy) { - if (state->head != Z_NULL && - state->head->extra != Z_NULL) { - len = state->head->extra_len - state->length; - zmemcpy(state->head->extra + len, next, - len + copy > state->head->extra_max ? - state->head->extra_max - len : copy); - } - if (state->flags & 0x0200) - state->check = crc32(state->check, next, copy); - have -= copy; - next += copy; - state->length -= copy; - } - if (state->length) goto inf_leave; - } - state->length = 0; - state->mode = NAME; - case NAME: - if (state->flags & 0x0800) { - if (have == 0) goto inf_leave; - copy = 0; - do { - len = (unsigned)(next[copy++]); - if (state->head != Z_NULL && - state->head->name != Z_NULL && - state->length < state->head->name_max) - state->head->name[state->length++] = len; - } while (len && copy < have); - if (state->flags & 0x0200) - state->check = crc32(state->check, next, copy); - have -= copy; - next += copy; - if (len) goto inf_leave; - } - else if (state->head != Z_NULL) - state->head->name = Z_NULL; - state->length = 0; - state->mode = COMMENT; - case COMMENT: - if (state->flags & 0x1000) { - if (have == 0) goto inf_leave; - copy = 0; - do { - len = (unsigned)(next[copy++]); - if (state->head != Z_NULL && - state->head->comment != Z_NULL && - state->length < state->head->comm_max) - state->head->comment[state->length++] = len; - } while (len && copy < have); - if (state->flags & 0x0200) - state->check = crc32(state->check, next, copy); - have -= copy; - next += copy; - if (len) goto inf_leave; - } - else if (state->head != Z_NULL) - state->head->comment = Z_NULL; - state->mode = HCRC; - case HCRC: - if (state->flags & 0x0200) { - NEEDBITS(16); - if (hold != (state->check & 0xffff)) { - strm->msg = (char *)"header crc mismatch"; - state->mode = BAD; - break; - } - INITBITS(); - } - if (state->head != Z_NULL) { - state->head->hcrc = (int)((state->flags >> 9) & 1); - state->head->done = 1; - } - strm->adler = state->check = crc32(0L, Z_NULL, 0); - state->mode = TYPE; - break; -#endif - case DICTID: - NEEDBITS(32); - strm->adler = state->check = REVERSE(hold); - INITBITS(); - state->mode = DICT; - case DICT: - if (state->havedict == 0) { - RESTORE(); - return Z_NEED_DICT; - } - strm->adler = state->check = adler32(0L, Z_NULL, 0); - state->mode = TYPE; - case TYPE: - if (flush == Z_BLOCK) goto inf_leave; - case TYPEDO: - if (state->last) { - BYTEBITS(); - state->mode = CHECK; - break; - } - NEEDBITS(3); - state->last = BITS(1); - DROPBITS(1); - switch (BITS(2)) { - case 0: /* stored block */ - Tracev((stderr, "inflate: stored block%s\n", - state->last ? " (last)" : "")); - state->mode = STORED; - break; - case 1: /* fixed block */ - fixedtables(state); - Tracev((stderr, "inflate: fixed codes block%s\n", - state->last ? " (last)" : "")); - state->mode = LEN; /* decode codes */ - break; - case 2: /* dynamic block */ - Tracev((stderr, "inflate: dynamic codes block%s\n", - state->last ? " (last)" : "")); - state->mode = TABLE; - break; - case 3: - strm->msg = (char *)"invalid block type"; - state->mode = BAD; - } - DROPBITS(2); - break; - case STORED: - BYTEBITS(); /* go to byte boundary */ - NEEDBITS(32); - if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { - strm->msg = (char *)"invalid stored block lengths"; - state->mode = BAD; - break; - } - state->length = (unsigned)hold & 0xffff; - Tracev((stderr, "inflate: stored length %u\n", - state->length)); - INITBITS(); - state->mode = COPY; - case COPY: - copy = state->length; - if (copy) { - if (copy > have) copy = have; - if (copy > left) copy = left; - if (copy == 0) goto inf_leave; - zmemcpy(put, next, copy); - have -= copy; - next += copy; - left -= copy; - put += copy; - state->length -= copy; - break; - } - Tracev((stderr, "inflate: stored end\n")); - state->mode = TYPE; - break; - case TABLE: - NEEDBITS(14); - state->nlen = BITS(5) + 257; - DROPBITS(5); - state->ndist = BITS(5) + 1; - DROPBITS(5); - state->ncode = BITS(4) + 4; - DROPBITS(4); -#ifndef PKZIP_BUG_WORKAROUND - if (state->nlen > 286 || state->ndist > 30) { - strm->msg = (char *)"too many length or distance symbols"; - state->mode = BAD; - break; - } -#endif - Tracev((stderr, "inflate: table sizes ok\n")); - state->have = 0; - state->mode = LENLENS; - case LENLENS: - while (state->have < state->ncode) { - NEEDBITS(3); - state->lens[order[state->have++]] = (unsigned short)BITS(3); - DROPBITS(3); - } - while (state->have < 19) - state->lens[order[state->have++]] = 0; - state->next = state->codes; - state->lencode = (code const FAR *)(state->next); - state->lenbits = 7; - ret = inflate_table(CODES, state->lens, 19, &(state->next), - &(state->lenbits), state->work); - if (ret) { - strm->msg = (char *)"invalid code lengths set"; - state->mode = BAD; - break; - } - Tracev((stderr, "inflate: code lengths ok\n")); - state->have = 0; - state->mode = CODELENS; - case CODELENS: - while (state->have < state->nlen + state->ndist) { - for (;;) { - this = state->lencode[BITS(state->lenbits)]; - if ((unsigned)(this.bits) <= bits) break; - PULLBYTE(); - } - if (this.val < 16) { - NEEDBITS(this.bits); - DROPBITS(this.bits); - state->lens[state->have++] = this.val; - } - else { - if (this.val == 16) { - NEEDBITS(this.bits + 2); - DROPBITS(this.bits); - if (state->have == 0) { - strm->msg = (char *)"invalid bit length repeat"; - state->mode = BAD; - break; - } - len = state->lens[state->have - 1]; - copy = 3 + BITS(2); - DROPBITS(2); - } - else if (this.val == 17) { - NEEDBITS(this.bits + 3); - DROPBITS(this.bits); - len = 0; - copy = 3 + BITS(3); - DROPBITS(3); - } - else { - NEEDBITS(this.bits + 7); - DROPBITS(this.bits); - len = 0; - copy = 11 + BITS(7); - DROPBITS(7); - } - if (state->have + copy > state->nlen + state->ndist) { - strm->msg = (char *)"invalid bit length repeat"; - state->mode = BAD; - break; - } - while (copy--) - state->lens[state->have++] = (unsigned short)len; - } - } - - /* handle error breaks in while */ - if (state->mode == BAD) break; - - /* build code tables */ - state->next = state->codes; - state->lencode = (code const FAR *)(state->next); - state->lenbits = 9; - ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), - &(state->lenbits), state->work); - if (ret) { - strm->msg = (char *)"invalid literal/lengths set"; - state->mode = BAD; - break; - } - state->distcode = (code const FAR *)(state->next); - state->distbits = 6; - ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, - &(state->next), &(state->distbits), state->work); - if (ret) { - strm->msg = (char *)"invalid distances set"; - state->mode = BAD; - break; - } - Tracev((stderr, "inflate: codes ok\n")); - state->mode = LEN; - case LEN: - if (have >= 6 && left >= 258) { - RESTORE(); - inflate_fast(strm, out); - LOAD(); - break; - } - for (;;) { - this = state->lencode[BITS(state->lenbits)]; - if ((unsigned)(this.bits) <= bits) break; - PULLBYTE(); - } - if (this.op && (this.op & 0xf0) == 0) { - last = this; - for (;;) { - this = state->lencode[last.val + - (BITS(last.bits + last.op) >> last.bits)]; - if ((unsigned)(last.bits + this.bits) <= bits) break; - PULLBYTE(); - } - DROPBITS(last.bits); - } - DROPBITS(this.bits); - state->length = (unsigned)this.val; - if ((int)(this.op) == 0) { - Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ? - "inflate: literal '%c'\n" : - "inflate: literal 0x%02x\n", this.val)); - state->mode = LIT; - break; - } - if (this.op & 32) { - Tracevv((stderr, "inflate: end of block\n")); - state->mode = TYPE; - break; - } - if (this.op & 64) { - strm->msg = (char *)"invalid literal/length code"; - state->mode = BAD; - break; - } - state->extra = (unsigned)(this.op) & 15; - state->mode = LENEXT; - case LENEXT: - if (state->extra) { - NEEDBITS(state->extra); - state->length += BITS(state->extra); - DROPBITS(state->extra); - } - Tracevv((stderr, "inflate: length %u\n", state->length)); - state->mode = DIST; - case DIST: - for (;;) { - this = state->distcode[BITS(state->distbits)]; - if ((unsigned)(this.bits) <= bits) break; - PULLBYTE(); - } - if ((this.op & 0xf0) == 0) { - last = this; - for (;;) { - this = state->distcode[last.val + - (BITS(last.bits + last.op) >> last.bits)]; - if ((unsigned)(last.bits + this.bits) <= bits) break; - PULLBYTE(); - } - DROPBITS(last.bits); - } - DROPBITS(this.bits); - if (this.op & 64) { - strm->msg = (char *)"invalid distance code"; - state->mode = BAD; - break; - } - state->offset = (unsigned)this.val; - state->extra = (unsigned)(this.op) & 15; - state->mode = DISTEXT; - case DISTEXT: - if (state->extra) { - NEEDBITS(state->extra); - state->offset += BITS(state->extra); - DROPBITS(state->extra); - } -#ifdef INFLATE_STRICT - if (state->offset > state->dmax) { - strm->msg = (char *)"invalid distance too far back"; - state->mode = BAD; - break; - } -#endif - if (state->offset > state->whave + out - left) { - strm->msg = (char *)"invalid distance too far back"; - state->mode = BAD; - break; - } - Tracevv((stderr, "inflate: distance %u\n", state->offset)); - state->mode = MATCH; - case MATCH: - if (left == 0) goto inf_leave; - copy = out - left; - if (state->offset > copy) { /* copy from window */ - copy = state->offset - copy; - if (copy > state->write) { - copy -= state->write; - from = state->window + (state->wsize - copy); - } - else - from = state->window + (state->write - copy); - if (copy > state->length) copy = state->length; - } - else { /* copy from output */ - from = put - state->offset; - copy = state->length; - } - if (copy > left) copy = left; - left -= copy; - state->length -= copy; - do { - *put++ = *from++; - } while (--copy); - if (state->length == 0) state->mode = LEN; - break; - case LIT: - if (left == 0) goto inf_leave; - *put++ = (unsigned char)(state->length); - left--; - state->mode = LEN; - break; - case CHECK: - if (state->wrap) { - NEEDBITS(32); - out -= left; - strm->total_out += out; - state->total += out; - if (out) - strm->adler = state->check = - UPDATE(state->check, put - out, out); - out = left; - if (( -#ifdef GUNZIP - state->flags ? hold : -#endif - REVERSE(hold)) != state->check) { - strm->msg = (char *)"incorrect data check"; - state->mode = BAD; - break; - } - INITBITS(); - Tracev((stderr, "inflate: check matches trailer\n")); - } -#ifdef GUNZIP - state->mode = LENGTH; - case LENGTH: - if (state->wrap && state->flags) { - NEEDBITS(32); - if (hold != (state->total & 0xffffffffUL)) { - strm->msg = (char *)"incorrect length check"; - state->mode = BAD; - break; - } - INITBITS(); - Tracev((stderr, "inflate: length matches trailer\n")); - } -#endif - state->mode = DONE; - case DONE: - ret = Z_STREAM_END; - goto inf_leave; - case BAD: - ret = Z_DATA_ERROR; - goto inf_leave; - case MEM: - return Z_MEM_ERROR; - case SYNC: - default: - return Z_STREAM_ERROR; - } - - /* - Return from inflate(), updating the total counts and the check value. - If there was no progress during the inflate() call, return a buffer - error. Call updatewindow() to create and/or update the window state. - Note: a memory error from inflate() is non-recoverable. - */ - inf_leave: - RESTORE(); - if (state->wsize || (state->mode < CHECK && out != strm->avail_out)) - if (updatewindow(strm, out)) { - state->mode = MEM; - return Z_MEM_ERROR; - } - in -= strm->avail_in; - out -= strm->avail_out; - strm->total_in += in; - strm->total_out += out; - state->total += out; - if (state->wrap && out) - strm->adler = state->check = - UPDATE(state->check, strm->next_out - out, out); - strm->data_type = state->bits + (state->last ? 64 : 0) + - (state->mode == TYPE ? 128 : 0); - if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) - ret = Z_BUF_ERROR; - return ret; -} - -int ZEXPORT inflateEnd(strm) -z_streamp strm; -{ - struct inflate_state FAR *state; - if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) - return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - if (state->window != Z_NULL) ZFREE(strm, state->window); - ZFREE(strm, strm->state); - strm->state = Z_NULL; - Tracev((stderr, "inflate: end\n")); - return Z_OK; -} - -int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) -z_streamp strm; -const Bytef *dictionary; -uInt dictLength; -{ - struct inflate_state FAR *state; - unsigned long id; - - /* check state */ - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - if (state->wrap != 0 && state->mode != DICT) - return Z_STREAM_ERROR; - - /* check for correct dictionary id */ - if (state->mode == DICT) { - id = adler32(0L, Z_NULL, 0); - id = adler32(id, dictionary, dictLength); - if (id != state->check) - return Z_DATA_ERROR; - } - - /* copy dictionary to window */ - if (updatewindow(strm, strm->avail_out)) { - state->mode = MEM; - return Z_MEM_ERROR; - } - if (dictLength > state->wsize) { - zmemcpy(state->window, dictionary + dictLength - state->wsize, - state->wsize); - state->whave = state->wsize; - } - else { - zmemcpy(state->window + state->wsize - dictLength, dictionary, - dictLength); - state->whave = dictLength; - } - state->havedict = 1; - Tracev((stderr, "inflate: dictionary set\n")); - return Z_OK; -} - -int ZEXPORT inflateGetHeader(strm, head) -z_streamp strm; -gz_headerp head; -{ - struct inflate_state FAR *state; - - /* check state */ - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - if ((state->wrap & 2) == 0) return Z_STREAM_ERROR; - - /* save header structure */ - state->head = head; - head->done = 0; - return Z_OK; -} - -/* - Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found - or when out of input. When called, *have is the number of pattern bytes - found in order so far, in 0..3. On return *have is updated to the new - state. If on return *have equals four, then the pattern was found and the - return value is how many bytes were read including the last byte of the - pattern. If *have is less than four, then the pattern has not been found - yet and the return value is len. In the latter case, syncsearch() can be - called again with more data and the *have state. *have is initialized to - zero for the first call. - */ -local unsigned syncsearch(have, buf, len) -unsigned FAR *have; -unsigned char FAR *buf; -unsigned len; -{ - unsigned got; - unsigned next; - - got = *have; - next = 0; - while (next < len && got < 4) { - if ((int)(buf[next]) == (got < 2 ? 0 : 0xff)) - got++; - else if (buf[next]) - got = 0; - else - got = 4 - got; - next++; - } - *have = got; - return next; -} - -int ZEXPORT inflateSync(strm) -z_streamp strm; -{ - unsigned len; /* number of bytes to look at or looked at */ - unsigned long in, out; /* temporary to save total_in and total_out */ - unsigned char buf[4]; /* to restore bit buffer to byte string */ - struct inflate_state FAR *state; - - /* check parameters */ - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR; - - /* if first time, start search in bit buffer */ - if (state->mode != SYNC) { - state->mode = SYNC; - state->hold <<= state->bits & 7; - state->bits -= state->bits & 7; - len = 0; - while (state->bits >= 8) { - buf[len++] = (unsigned char)(state->hold); - state->hold >>= 8; - state->bits -= 8; - } - state->have = 0; - syncsearch(&(state->have), buf, len); - } - - /* search available input */ - len = syncsearch(&(state->have), strm->next_in, strm->avail_in); - strm->avail_in -= len; - strm->next_in += len; - strm->total_in += len; - - /* return no joy or set up to restart inflate() on a new block */ - if (state->have != 4) return Z_DATA_ERROR; - in = strm->total_in; out = strm->total_out; - inflateReset(strm); - strm->total_in = in; strm->total_out = out; - state->mode = TYPE; - return Z_OK; -} - -/* - Returns true if inflate is currently at the end of a block generated by - Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP - implementation to provide an additional safety check. PPP uses - Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored - block. When decompressing, PPP checks that at the end of input packet, - inflate is waiting for these length bytes. - */ -int ZEXPORT inflateSyncPoint(strm) -z_streamp strm; -{ - struct inflate_state FAR *state; - - if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - return state->mode == STORED && state->bits == 0; -} - -int ZEXPORT inflateCopy(dest, source) -z_streamp dest; -z_streamp source; -{ - struct inflate_state FAR *state; - struct inflate_state FAR *copy; - unsigned char FAR *window; - unsigned wsize; - - /* check input */ - if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL || - source->zalloc == (alloc_func)0 || source->zfree == (free_func)0) - return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)source->state; - - /* allocate space */ - copy = (struct inflate_state FAR *) - ZALLOC(source, 1, sizeof(struct inflate_state)); - if (copy == Z_NULL) return Z_MEM_ERROR; - window = Z_NULL; - if (state->window != Z_NULL) { - window = (unsigned char FAR *) - ZALLOC(source, 1U << state->wbits, sizeof(unsigned char)); - if (window == Z_NULL) { - ZFREE(source, copy); - return Z_MEM_ERROR; - } - } - - /* copy state */ - zmemcpy(dest, source, sizeof(z_stream)); - zmemcpy(copy, state, sizeof(struct inflate_state)); - if (state->lencode >= state->codes && - state->lencode <= state->codes + ENOUGH - 1) { - copy->lencode = copy->codes + (state->lencode - state->codes); - copy->distcode = copy->codes + (state->distcode - state->codes); - } - copy->next = copy->codes + (state->next - state->codes); - if (window != Z_NULL) { - wsize = 1U << state->wbits; - zmemcpy(window, state->window, wsize); - } - copy->window = window; - dest->state = (struct internal_state FAR *)copy; - return Z_OK; -} diff --git a/ndk/sources/external/zlib/inflate.h b/ndk/sources/external/zlib/inflate.h deleted file mode 100644 index 07bd3e78a..000000000 --- a/ndk/sources/external/zlib/inflate.h +++ /dev/null @@ -1,115 +0,0 @@ -/* inflate.h -- internal inflate state definition - * Copyright (C) 1995-2004 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* WARNING: this file should *not* be used by applications. It is - part of the implementation of the compression library and is - subject to change. Applications should only use zlib.h. - */ - -/* define NO_GZIP when compiling if you want to disable gzip header and - trailer decoding by inflate(). NO_GZIP would be used to avoid linking in - the crc code when it is not needed. For shared libraries, gzip decoding - should be left enabled. */ -#ifndef NO_GZIP -# define GUNZIP -#endif - -/* Possible inflate modes between inflate() calls */ -typedef enum { - HEAD, /* i: waiting for magic header */ - FLAGS, /* i: waiting for method and flags (gzip) */ - TIME, /* i: waiting for modification time (gzip) */ - OS, /* i: waiting for extra flags and operating system (gzip) */ - EXLEN, /* i: waiting for extra length (gzip) */ - EXTRA, /* i: waiting for extra bytes (gzip) */ - NAME, /* i: waiting for end of file name (gzip) */ - COMMENT, /* i: waiting for end of comment (gzip) */ - HCRC, /* i: waiting for header crc (gzip) */ - DICTID, /* i: waiting for dictionary check value */ - DICT, /* waiting for inflateSetDictionary() call */ - TYPE, /* i: waiting for type bits, including last-flag bit */ - TYPEDO, /* i: same, but skip check to exit inflate on new block */ - STORED, /* i: waiting for stored size (length and complement) */ - COPY, /* i/o: waiting for input or output to copy stored block */ - TABLE, /* i: waiting for dynamic block table lengths */ - LENLENS, /* i: waiting for code length code lengths */ - CODELENS, /* i: waiting for length/lit and distance code lengths */ - LEN, /* i: waiting for length/lit code */ - LENEXT, /* i: waiting for length extra bits */ - DIST, /* i: waiting for distance code */ - DISTEXT, /* i: waiting for distance extra bits */ - MATCH, /* o: waiting for output space to copy string */ - LIT, /* o: waiting for output space to write literal */ - CHECK, /* i: waiting for 32-bit check value */ - LENGTH, /* i: waiting for 32-bit length (gzip) */ - DONE, /* finished check, done -- remain here until reset */ - BAD, /* got a data error -- remain here until reset */ - MEM, /* got an inflate() memory error -- remain here until reset */ - SYNC /* looking for synchronization bytes to restart inflate() */ -} inflate_mode; - -/* - State transitions between above modes - - - (most modes can go to the BAD or MEM mode -- not shown for clarity) - - Process header: - HEAD -> (gzip) or (zlib) - (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME - NAME -> COMMENT -> HCRC -> TYPE - (zlib) -> DICTID or TYPE - DICTID -> DICT -> TYPE - Read deflate blocks: - TYPE -> STORED or TABLE or LEN or CHECK - STORED -> COPY -> TYPE - TABLE -> LENLENS -> CODELENS -> LEN - Read deflate codes: - LEN -> LENEXT or LIT or TYPE - LENEXT -> DIST -> DISTEXT -> MATCH -> LEN - LIT -> LEN - Process trailer: - CHECK -> LENGTH -> DONE - */ - -/* state maintained between inflate() calls. Approximately 7K bytes. */ -struct inflate_state { - inflate_mode mode; /* current inflate mode */ - int last; /* true if processing last block */ - int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ - int havedict; /* true if dictionary provided */ - int flags; /* gzip header method and flags (0 if zlib) */ - unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */ - unsigned long check; /* protected copy of check value */ - unsigned long total; /* protected copy of output count */ - gz_headerp head; /* where to save gzip header information */ - /* sliding window */ - unsigned wbits; /* log base 2 of requested window size */ - unsigned wsize; /* window size or zero if not using window */ - unsigned whave; /* valid bytes in the window */ - unsigned write; /* window write index */ - unsigned char FAR *window; /* allocated sliding window, if needed */ - /* bit accumulator */ - unsigned long hold; /* input bit accumulator */ - unsigned bits; /* number of bits in "in" */ - /* for string and stored block copying */ - unsigned length; /* literal or length of data to copy */ - unsigned offset; /* distance back to copy string from */ - /* for table and code decoding */ - unsigned extra; /* extra bits needed */ - /* fixed and dynamic code tables */ - code const FAR *lencode; /* starting table for length/literal codes */ - code const FAR *distcode; /* starting table for distance codes */ - unsigned lenbits; /* index bits for lencode */ - unsigned distbits; /* index bits for distcode */ - /* dynamic table building */ - unsigned ncode; /* number of code length code lengths */ - unsigned nlen; /* number of length code lengths */ - unsigned ndist; /* number of distance code lengths */ - unsigned have; /* number of code lengths in lens[] */ - code FAR *next; /* next available space in codes[] */ - unsigned short lens[320]; /* temporary storage for code lengths */ - unsigned short work[288]; /* work area for code table building */ - code codes[ENOUGH]; /* space for code tables */ -}; diff --git a/ndk/sources/external/zlib/inftrees.c b/ndk/sources/external/zlib/inftrees.c deleted file mode 100644 index 8a9c13ff0..000000000 --- a/ndk/sources/external/zlib/inftrees.c +++ /dev/null @@ -1,329 +0,0 @@ -/* inftrees.c -- generate Huffman trees for efficient decoding - * Copyright (C) 1995-2005 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -#include "zutil.h" -#include "inftrees.h" - -#define MAXBITS 15 - -const char inflate_copyright[] = - " inflate 1.2.3 Copyright 1995-2005 Mark Adler "; -/* - If you use the zlib library in a product, an acknowledgment is welcome - in the documentation of your product. If for some reason you cannot - include such an acknowledgment, I would appreciate that you keep this - copyright string in the executable of your product. - */ - -/* - Build a set of tables to decode the provided canonical Huffman code. - The code lengths are lens[0..codes-1]. The result starts at *table, - whose indices are 0..2^bits-1. work is a writable array of at least - lens shorts, which is used as a work area. type is the type of code - to be generated, CODES, LENS, or DISTS. On return, zero is success, - -1 is an invalid code, and +1 means that ENOUGH isn't enough. table - on return points to the next available entry's address. bits is the - requested root table index bits, and on return it is the actual root - table index bits. It will differ if the request is greater than the - longest code or if it is less than the shortest code. - */ -int inflate_table(type, lens, codes, table, bits, work) -codetype type; -unsigned short FAR *lens; -unsigned codes; -code FAR * FAR *table; -unsigned FAR *bits; -unsigned short FAR *work; -{ - unsigned len; /* a code's length in bits */ - unsigned sym; /* index of code symbols */ - unsigned min, max; /* minimum and maximum code lengths */ - unsigned root; /* number of index bits for root table */ - unsigned curr; /* number of index bits for current table */ - unsigned drop; /* code bits to drop for sub-table */ - int left; /* number of prefix codes available */ - unsigned used; /* code entries in table used */ - unsigned huff; /* Huffman code */ - unsigned incr; /* for incrementing code, index */ - unsigned fill; /* index for replicating entries */ - unsigned low; /* low bits for current root entry */ - unsigned mask; /* mask for low root bits */ - code this; /* table entry for duplication */ - code FAR *next; /* next available space in table */ - const unsigned short FAR *base; /* base value table to use */ - const unsigned short FAR *extra; /* extra bits table to use */ - int end; /* use base and extra for symbol > end */ - unsigned short count[MAXBITS+1]; /* number of codes of each length */ - unsigned short offs[MAXBITS+1]; /* offsets in table for each length */ - static const unsigned short lbase[31] = { /* Length codes 257..285 base */ - 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, - 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; - static const unsigned short lext[31] = { /* Length codes 257..285 extra */ - 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, - 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196}; - static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ - 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, - 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, - 8193, 12289, 16385, 24577, 0, 0}; - static const unsigned short dext[32] = { /* Distance codes 0..29 extra */ - 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, - 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, - 28, 28, 29, 29, 64, 64}; - - /* - Process a set of code lengths to create a canonical Huffman code. The - code lengths are lens[0..codes-1]. Each length corresponds to the - symbols 0..codes-1. The Huffman code is generated by first sorting the - symbols by length from short to long, and retaining the symbol order - for codes with equal lengths. Then the code starts with all zero bits - for the first code of the shortest length, and the codes are integer - increments for the same length, and zeros are appended as the length - increases. For the deflate format, these bits are stored backwards - from their more natural integer increment ordering, and so when the - decoding tables are built in the large loop below, the integer codes - are incremented backwards. - - This routine assumes, but does not check, that all of the entries in - lens[] are in the range 0..MAXBITS. The caller must assure this. - 1..MAXBITS is interpreted as that code length. zero means that that - symbol does not occur in this code. - - The codes are sorted by computing a count of codes for each length, - creating from that a table of starting indices for each length in the - sorted table, and then entering the symbols in order in the sorted - table. The sorted table is work[], with that space being provided by - the caller. - - The length counts are used for other purposes as well, i.e. finding - the minimum and maximum length codes, determining if there are any - codes at all, checking for a valid set of lengths, and looking ahead - at length counts to determine sub-table sizes when building the - decoding tables. - */ - - /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ - for (len = 0; len <= MAXBITS; len++) - count[len] = 0; - for (sym = 0; sym < codes; sym++) - count[lens[sym]]++; - - /* bound code lengths, force root to be within code lengths */ - root = *bits; - for (max = MAXBITS; max >= 1; max--) - if (count[max] != 0) break; - if (root > max) root = max; - if (max == 0) { /* no symbols to code at all */ - this.op = (unsigned char)64; /* invalid code marker */ - this.bits = (unsigned char)1; - this.val = (unsigned short)0; - *(*table)++ = this; /* make a table to force an error */ - *(*table)++ = this; - *bits = 1; - return 0; /* no symbols, but wait for decoding to report error */ - } - for (min = 1; min <= MAXBITS; min++) - if (count[min] != 0) break; - if (root < min) root = min; - - /* check for an over-subscribed or incomplete set of lengths */ - left = 1; - for (len = 1; len <= MAXBITS; len++) { - left <<= 1; - left -= count[len]; - if (left < 0) return -1; /* over-subscribed */ - } - if (left > 0 && (type == CODES || max != 1)) - return -1; /* incomplete set */ - - /* generate offsets into symbol table for each length for sorting */ - offs[1] = 0; - for (len = 1; len < MAXBITS; len++) - offs[len + 1] = offs[len] + count[len]; - - /* sort symbols by length, by symbol order within each length */ - for (sym = 0; sym < codes; sym++) - if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym; - - /* - Create and fill in decoding tables. In this loop, the table being - filled is at next and has curr index bits. The code being used is huff - with length len. That code is converted to an index by dropping drop - bits off of the bottom. For codes where len is less than drop + curr, - those top drop + curr - len bits are incremented through all values to - fill the table with replicated entries. - - root is the number of index bits for the root table. When len exceeds - root, sub-tables are created pointed to by the root entry with an index - of the low root bits of huff. This is saved in low to check for when a - new sub-table should be started. drop is zero when the root table is - being filled, and drop is root when sub-tables are being filled. - - When a new sub-table is needed, it is necessary to look ahead in the - code lengths to determine what size sub-table is needed. The length - counts are used for this, and so count[] is decremented as codes are - entered in the tables. - - used keeps track of how many table entries have been allocated from the - provided *table space. It is checked when a LENS table is being made - against the space in *table, ENOUGH, minus the maximum space needed by - the worst case distance code, MAXD. This should never happen, but the - sufficiency of ENOUGH has not been proven exhaustively, hence the check. - This assumes that when type == LENS, bits == 9. - - sym increments through all symbols, and the loop terminates when - all codes of length max, i.e. all codes, have been processed. This - routine permits incomplete codes, so another loop after this one fills - in the rest of the decoding tables with invalid code markers. - */ - - /* set up for code type */ - switch (type) { - case CODES: - base = extra = work; /* dummy value--not used */ - end = 19; - break; - case LENS: - base = lbase; - base -= 257; - extra = lext; - extra -= 257; - end = 256; - break; - default: /* DISTS */ - base = dbase; - extra = dext; - end = -1; - } - - /* initialize state for loop */ - huff = 0; /* starting code */ - sym = 0; /* starting code symbol */ - len = min; /* starting code length */ - next = *table; /* current table to fill in */ - curr = root; /* current table index bits */ - drop = 0; /* current bits to drop from code for index */ - low = (unsigned)(-1); /* trigger new sub-table when len > root */ - used = 1U << root; /* use root table entries */ - mask = used - 1; /* mask for comparing low */ - - /* check available table space */ - if (type == LENS && used >= ENOUGH - MAXD) - return 1; - - /* process all codes and make table entries */ - for (;;) { - /* create table entry */ - this.bits = (unsigned char)(len - drop); - if ((int)(work[sym]) < end) { - this.op = (unsigned char)0; - this.val = work[sym]; - } - else if ((int)(work[sym]) > end) { - this.op = (unsigned char)(extra[work[sym]]); - this.val = base[work[sym]]; - } - else { - this.op = (unsigned char)(32 + 64); /* end of block */ - this.val = 0; - } - - /* replicate for those indices with low len bits equal to huff */ - incr = 1U << (len - drop); - fill = 1U << curr; - min = fill; /* save offset to next table */ - do { - fill -= incr; - next[(huff >> drop) + fill] = this; - } while (fill != 0); - - /* backwards increment the len-bit code huff */ - incr = 1U << (len - 1); - while (huff & incr) - incr >>= 1; - if (incr != 0) { - huff &= incr - 1; - huff += incr; - } - else - huff = 0; - - /* go to next symbol, update count, len */ - sym++; - if (--(count[len]) == 0) { - if (len == max) break; - len = lens[work[sym]]; - } - - /* create new sub-table if needed */ - if (len > root && (huff & mask) != low) { - /* if first time, transition to sub-tables */ - if (drop == 0) - drop = root; - - /* increment past last table */ - next += min; /* here min is 1 << curr */ - - /* determine length of next table */ - curr = len - drop; - left = (int)(1 << curr); - while (curr + drop < max) { - left -= count[curr + drop]; - if (left <= 0) break; - curr++; - left <<= 1; - } - - /* check for enough space */ - used += 1U << curr; - if (type == LENS && used >= ENOUGH - MAXD) - return 1; - - /* point entry in root table to sub-table */ - low = huff & mask; - (*table)[low].op = (unsigned char)curr; - (*table)[low].bits = (unsigned char)root; - (*table)[low].val = (unsigned short)(next - *table); - } - } - - /* - Fill in rest of table for incomplete codes. This loop is similar to the - loop above in incrementing huff for table indices. It is assumed that - len is equal to curr + drop, so there is no loop needed to increment - through high index bits. When the current sub-table is filled, the loop - drops back to the root table to fill in any remaining entries there. - */ - this.op = (unsigned char)64; /* invalid code marker */ - this.bits = (unsigned char)(len - drop); - this.val = (unsigned short)0; - while (huff != 0) { - /* when done with sub-table, drop back to root table */ - if (drop != 0 && (huff & mask) != low) { - drop = 0; - len = root; - next = *table; - this.bits = (unsigned char)len; - } - - /* put invalid code marker in table */ - next[huff >> drop] = this; - - /* backwards increment the len-bit code huff */ - incr = 1U << (len - 1); - while (huff & incr) - incr >>= 1; - if (incr != 0) { - huff &= incr - 1; - huff += incr; - } - else - huff = 0; - } - - /* set return parameters */ - *table += used; - *bits = root; - return 0; -} diff --git a/ndk/sources/external/zlib/inftrees.h b/ndk/sources/external/zlib/inftrees.h deleted file mode 100644 index b1104c87e..000000000 --- a/ndk/sources/external/zlib/inftrees.h +++ /dev/null @@ -1,55 +0,0 @@ -/* inftrees.h -- header to use inftrees.c - * Copyright (C) 1995-2005 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* WARNING: this file should *not* be used by applications. It is - part of the implementation of the compression library and is - subject to change. Applications should only use zlib.h. - */ - -/* Structure for decoding tables. Each entry provides either the - information needed to do the operation requested by the code that - indexed that table entry, or it provides a pointer to another - table that indexes more bits of the code. op indicates whether - the entry is a pointer to another table, a literal, a length or - distance, an end-of-block, or an invalid code. For a table - pointer, the low four bits of op is the number of index bits of - that table. For a length or distance, the low four bits of op - is the number of extra bits to get after the code. bits is - the number of bits in this code or part of the code to drop off - of the bit buffer. val is the actual byte to output in the case - of a literal, the base length or distance, or the offset from - the current table to the next table. Each entry is four bytes. */ -typedef struct { - unsigned char op; /* operation, extra bits, table bits */ - unsigned char bits; /* bits in this part of the code */ - unsigned short val; /* offset in table or code value */ -} code; - -/* op values as set by inflate_table(): - 00000000 - literal - 0000tttt - table link, tttt != 0 is the number of table index bits - 0001eeee - length or distance, eeee is the number of extra bits - 01100000 - end of block - 01000000 - invalid code - */ - -/* Maximum size of dynamic tree. The maximum found in a long but non- - exhaustive search was 1444 code structures (852 for length/literals - and 592 for distances, the latter actually the result of an - exhaustive search). The true maximum is not known, but the value - below is more than safe. */ -#define ENOUGH 2048 -#define MAXD 592 - -/* Type of code to build for inftable() */ -typedef enum { - CODES, - LENS, - DISTS -} codetype; - -extern int inflate_table OF((codetype type, unsigned short FAR *lens, - unsigned codes, code FAR * FAR *table, - unsigned FAR *bits, unsigned short FAR *work)); diff --git a/ndk/sources/external/zlib/minigzip.c b/ndk/sources/external/zlib/minigzip.c deleted file mode 100644 index 4524b96a1..000000000 --- a/ndk/sources/external/zlib/minigzip.c +++ /dev/null @@ -1,322 +0,0 @@ -/* minigzip.c -- simulate gzip using the zlib compression library - * Copyright (C) 1995-2005 Jean-loup Gailly. - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* - * minigzip is a minimal implementation of the gzip utility. This is - * only an example of using zlib and isn't meant to replace the - * full-featured gzip. No attempt is made to deal with file systems - * limiting names to 14 or 8+3 characters, etc... Error checking is - * very limited. So use minigzip only for testing; use gzip for the - * real thing. On MSDOS, use only on file names without extension - * or in pipe mode. - */ - -/* @(#) $Id$ */ - -#include -#include "zlib.h" - -#ifdef STDC -# include -# include -#endif - -#ifdef USE_MMAP -# include -# include -# include -#endif - -#if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__) -# include -# include -# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY) -#else -# define SET_BINARY_MODE(file) -#endif - -#ifdef VMS -# define unlink delete -# define GZ_SUFFIX "-gz" -#endif -#ifdef RISCOS -# define unlink remove -# define GZ_SUFFIX "-gz" -# define fileno(file) file->__file -#endif -#if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os -# include /* for fileno */ -#endif - -#ifndef WIN32 /* unlink already in stdio.h for WIN32 */ - extern int unlink OF((const char *)); -#endif - -#ifndef GZ_SUFFIX -# define GZ_SUFFIX ".gz" -#endif -#define SUFFIX_LEN (sizeof(GZ_SUFFIX)-1) - -#define BUFLEN 16384 -#define MAX_NAME_LEN 1024 - -#ifdef MAXSEG_64K -# define local static - /* Needed for systems with limitation on stack size. */ -#else -# define local -#endif - -char *prog; - -void error OF((const char *msg)); -void gz_compress OF((FILE *in, gzFile out)); -#ifdef USE_MMAP -int gz_compress_mmap OF((FILE *in, gzFile out)); -#endif -void gz_uncompress OF((gzFile in, FILE *out)); -void file_compress OF((char *file, char *mode)); -void file_uncompress OF((char *file)); -int main OF((int argc, char *argv[])); - -/* =========================================================================== - * Display error message and exit - */ -void error(msg) - const char *msg; -{ - fprintf(stderr, "%s: %s\n", prog, msg); - exit(1); -} - -/* =========================================================================== - * Compress input to output then close both files. - */ - -void gz_compress(in, out) - FILE *in; - gzFile out; -{ - local char buf[BUFLEN]; - int len; - int err; - -#ifdef USE_MMAP - /* Try first compressing with mmap. If mmap fails (minigzip used in a - * pipe), use the normal fread loop. - */ - if (gz_compress_mmap(in, out) == Z_OK) return; -#endif - for (;;) { - len = (int)fread(buf, 1, sizeof(buf), in); - if (ferror(in)) { - perror("fread"); - exit(1); - } - if (len == 0) break; - - if (gzwrite(out, buf, (unsigned)len) != len) error(gzerror(out, &err)); - } - fclose(in); - if (gzclose(out) != Z_OK) error("failed gzclose"); -} - -#ifdef USE_MMAP /* MMAP version, Miguel Albrecht */ - -/* Try compressing the input file at once using mmap. Return Z_OK if - * if success, Z_ERRNO otherwise. - */ -int gz_compress_mmap(in, out) - FILE *in; - gzFile out; -{ - int len; - int err; - int ifd = fileno(in); - caddr_t buf; /* mmap'ed buffer for the entire input file */ - off_t buf_len; /* length of the input file */ - struct stat sb; - - /* Determine the size of the file, needed for mmap: */ - if (fstat(ifd, &sb) < 0) return Z_ERRNO; - buf_len = sb.st_size; - if (buf_len <= 0) return Z_ERRNO; - - /* Now do the actual mmap: */ - buf = mmap((caddr_t) 0, buf_len, PROT_READ, MAP_SHARED, ifd, (off_t)0); - if (buf == (caddr_t)(-1)) return Z_ERRNO; - - /* Compress the whole file at once: */ - len = gzwrite(out, (char *)buf, (unsigned)buf_len); - - if (len != (int)buf_len) error(gzerror(out, &err)); - - munmap(buf, buf_len); - fclose(in); - if (gzclose(out) != Z_OK) error("failed gzclose"); - return Z_OK; -} -#endif /* USE_MMAP */ - -/* =========================================================================== - * Uncompress input to output then close both files. - */ -void gz_uncompress(in, out) - gzFile in; - FILE *out; -{ - local char buf[BUFLEN]; - int len; - int err; - - for (;;) { - len = gzread(in, buf, sizeof(buf)); - if (len < 0) error (gzerror(in, &err)); - if (len == 0) break; - - if ((int)fwrite(buf, 1, (unsigned)len, out) != len) { - error("failed fwrite"); - } - } - if (fclose(out)) error("failed fclose"); - - if (gzclose(in) != Z_OK) error("failed gzclose"); -} - - -/* =========================================================================== - * Compress the given file: create a corresponding .gz file and remove the - * original. - */ -void file_compress(file, mode) - char *file; - char *mode; -{ - local char outfile[MAX_NAME_LEN]; - FILE *in; - gzFile out; - - strcpy(outfile, file); - strcat(outfile, GZ_SUFFIX); - - in = fopen(file, "rb"); - if (in == NULL) { - perror(file); - exit(1); - } - out = gzopen(outfile, mode); - if (out == NULL) { - fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile); - exit(1); - } - gz_compress(in, out); - - unlink(file); -} - - -/* =========================================================================== - * Uncompress the given file and remove the original. - */ -void file_uncompress(file) - char *file; -{ - local char buf[MAX_NAME_LEN]; - char *infile, *outfile; - FILE *out; - gzFile in; - uInt len = (uInt)strlen(file); - - strcpy(buf, file); - - if (len > SUFFIX_LEN && strcmp(file+len-SUFFIX_LEN, GZ_SUFFIX) == 0) { - infile = file; - outfile = buf; - outfile[len-3] = '\0'; - } else { - outfile = file; - infile = buf; - strcat(infile, GZ_SUFFIX); - } - in = gzopen(infile, "rb"); - if (in == NULL) { - fprintf(stderr, "%s: can't gzopen %s\n", prog, infile); - exit(1); - } - out = fopen(outfile, "wb"); - if (out == NULL) { - perror(file); - exit(1); - } - - gz_uncompress(in, out); - - unlink(infile); -} - - -/* =========================================================================== - * Usage: minigzip [-d] [-f] [-h] [-r] [-1 to -9] [files...] - * -d : decompress - * -f : compress with Z_FILTERED - * -h : compress with Z_HUFFMAN_ONLY - * -r : compress with Z_RLE - * -1 to -9 : compression level - */ - -int main(argc, argv) - int argc; - char *argv[]; -{ - int uncompr = 0; - gzFile file; - char outmode[20]; - - strcpy(outmode, "wb6 "); - - prog = argv[0]; - argc--, argv++; - - while (argc > 0) { - if (strcmp(*argv, "-d") == 0) - uncompr = 1; - else if (strcmp(*argv, "-f") == 0) - outmode[3] = 'f'; - else if (strcmp(*argv, "-h") == 0) - outmode[3] = 'h'; - else if (strcmp(*argv, "-r") == 0) - outmode[3] = 'R'; - else if ((*argv)[0] == '-' && (*argv)[1] >= '1' && (*argv)[1] <= '9' && - (*argv)[2] == 0) - outmode[2] = (*argv)[1]; - else - break; - argc--, argv++; - } - if (outmode[3] == ' ') - outmode[3] = 0; - if (argc == 0) { - SET_BINARY_MODE(stdin); - SET_BINARY_MODE(stdout); - if (uncompr) { - file = gzdopen(fileno(stdin), "rb"); - if (file == NULL) error("can't gzdopen stdin"); - gz_uncompress(file, stdout); - } else { - file = gzdopen(fileno(stdout), outmode); - if (file == NULL) error("can't gzdopen stdout"); - gz_compress(stdin, file); - } - } else { - do { - if (uncompr) { - file_uncompress(*argv); - } else { - file_compress(*argv, outmode); - } - } while (argv++, --argc); - } - return 0; -} diff --git a/ndk/sources/external/zlib/trees.c b/ndk/sources/external/zlib/trees.c deleted file mode 100644 index 395e4e168..000000000 --- a/ndk/sources/external/zlib/trees.c +++ /dev/null @@ -1,1219 +0,0 @@ -/* trees.c -- output deflated data using Huffman coding - * Copyright (C) 1995-2005 Jean-loup Gailly - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* - * ALGORITHM - * - * The "deflation" process uses several Huffman trees. The more - * common source values are represented by shorter bit sequences. - * - * Each code tree is stored in a compressed form which is itself - * a Huffman encoding of the lengths of all the code strings (in - * ascending order by source values). The actual code strings are - * reconstructed from the lengths in the inflate process, as described - * in the deflate specification. - * - * REFERENCES - * - * Deutsch, L.P.,"'Deflate' Compressed Data Format Specification". - * Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc - * - * Storer, James A. - * Data Compression: Methods and Theory, pp. 49-50. - * Computer Science Press, 1988. ISBN 0-7167-8156-5. - * - * Sedgewick, R. - * Algorithms, p290. - * Addison-Wesley, 1983. ISBN 0-201-06672-6. - */ - -/* @(#) $Id$ */ - -/* #define GEN_TREES_H */ - -#include "deflate.h" - -#ifdef DEBUG -# include -#endif - -/* =========================================================================== - * Constants - */ - -#define MAX_BL_BITS 7 -/* Bit length codes must not exceed MAX_BL_BITS bits */ - -#define END_BLOCK 256 -/* end of block literal code */ - -#define REP_3_6 16 -/* repeat previous bit length 3-6 times (2 bits of repeat count) */ - -#define REPZ_3_10 17 -/* repeat a zero length 3-10 times (3 bits of repeat count) */ - -#define REPZ_11_138 18 -/* repeat a zero length 11-138 times (7 bits of repeat count) */ - -local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */ - = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0}; - -local const int extra_dbits[D_CODES] /* extra bits for each distance code */ - = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; - -local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */ - = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7}; - -local const uch bl_order[BL_CODES] - = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15}; -/* The lengths of the bit length codes are sent in order of decreasing - * probability, to avoid transmitting the lengths for unused bit length codes. - */ - -#define Buf_size (8 * 2*sizeof(char)) -/* Number of bits used within bi_buf. (bi_buf might be implemented on - * more than 16 bits on some systems.) - */ - -/* =========================================================================== - * Local data. These are initialized only once. - */ - -#define DIST_CODE_LEN 512 /* see definition of array dist_code below */ - -#if defined(GEN_TREES_H) || !defined(STDC) -/* non ANSI compilers may not accept trees.h */ - -local ct_data static_ltree[L_CODES+2]; -/* The static literal tree. Since the bit lengths are imposed, there is no - * need for the L_CODES extra codes used during heap construction. However - * The codes 286 and 287 are needed to build a canonical tree (see _tr_init - * below). - */ - -local ct_data static_dtree[D_CODES]; -/* The static distance tree. (Actually a trivial tree since all codes use - * 5 bits.) - */ - -uch _dist_code[DIST_CODE_LEN]; -/* Distance codes. The first 256 values correspond to the distances - * 3 .. 258, the last 256 values correspond to the top 8 bits of - * the 15 bit distances. - */ - -uch _length_code[MAX_MATCH-MIN_MATCH+1]; -/* length code for each normalized match length (0 == MIN_MATCH) */ - -local int base_length[LENGTH_CODES]; -/* First normalized length for each code (0 = MIN_MATCH) */ - -local int base_dist[D_CODES]; -/* First normalized distance for each code (0 = distance of 1) */ - -#else -# include "trees.h" -#endif /* GEN_TREES_H */ - -struct static_tree_desc_s { - const ct_data *static_tree; /* static tree or NULL */ - const intf *extra_bits; /* extra bits for each code or NULL */ - int extra_base; /* base index for extra_bits */ - int elems; /* max number of elements in the tree */ - int max_length; /* max bit length for the codes */ -}; - -local static_tree_desc static_l_desc = -{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS}; - -local static_tree_desc static_d_desc = -{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS}; - -local static_tree_desc static_bl_desc = -{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS}; - -/* =========================================================================== - * Local (static) routines in this file. - */ - -local void tr_static_init OF((void)); -local void init_block OF((deflate_state *s)); -local void pqdownheap OF((deflate_state *s, ct_data *tree, int k)); -local void gen_bitlen OF((deflate_state *s, tree_desc *desc)); -local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count)); -local void build_tree OF((deflate_state *s, tree_desc *desc)); -local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code)); -local void send_tree OF((deflate_state *s, ct_data *tree, int max_code)); -local int build_bl_tree OF((deflate_state *s)); -local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, - int blcodes)); -local void compress_block OF((deflate_state *s, ct_data *ltree, - ct_data *dtree)); -local void set_data_type OF((deflate_state *s)); -local unsigned bi_reverse OF((unsigned value, int length)); -local void bi_windup OF((deflate_state *s)); -local void bi_flush OF((deflate_state *s)); -local void copy_block OF((deflate_state *s, charf *buf, unsigned len, - int header)); - -#ifdef GEN_TREES_H -local void gen_trees_header OF((void)); -#endif - -#ifndef DEBUG -# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len) - /* Send a code of the given tree. c and tree must not have side effects */ - -#else /* DEBUG */ -# define send_code(s, c, tree) \ - { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \ - send_bits(s, tree[c].Code, tree[c].Len); } -#endif - -/* =========================================================================== - * Output a short LSB first on the stream. - * IN assertion: there is enough room in pendingBuf. - */ -#define put_short(s, w) { \ - put_byte(s, (uch)((w) & 0xff)); \ - put_byte(s, (uch)((ush)(w) >> 8)); \ -} - -/* =========================================================================== - * Send a value on a given number of bits. - * IN assertion: length <= 16 and value fits in length bits. - */ -#ifdef DEBUG -local void send_bits OF((deflate_state *s, int value, int length)); - -local void send_bits(s, value, length) - deflate_state *s; - int value; /* value to send */ - int length; /* number of bits */ -{ - Tracevv((stderr," l %2d v %4x ", length, value)); - Assert(length > 0 && length <= 15, "invalid length"); - s->bits_sent += (ulg)length; - - /* If not enough room in bi_buf, use (valid) bits from bi_buf and - * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) - * unused bits in value. - */ - if (s->bi_valid > (int)Buf_size - length) { - s->bi_buf |= (value << s->bi_valid); - put_short(s, s->bi_buf); - s->bi_buf = (ush)value >> (Buf_size - s->bi_valid); - s->bi_valid += length - Buf_size; - } else { - s->bi_buf |= value << s->bi_valid; - s->bi_valid += length; - } -} -#else /* !DEBUG */ - -#define send_bits(s, value, length) \ -{ int len = length;\ - if (s->bi_valid > (int)Buf_size - len) {\ - int val = value;\ - s->bi_buf |= (val << s->bi_valid);\ - put_short(s, s->bi_buf);\ - s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\ - s->bi_valid += len - Buf_size;\ - } else {\ - s->bi_buf |= (value) << s->bi_valid;\ - s->bi_valid += len;\ - }\ -} -#endif /* DEBUG */ - - -/* the arguments must not have side effects */ - -/* =========================================================================== - * Initialize the various 'constant' tables. - */ -local void tr_static_init() -{ -#if defined(GEN_TREES_H) || !defined(STDC) - static int static_init_done = 0; - int n; /* iterates over tree elements */ - int bits; /* bit counter */ - int length; /* length value */ - int code; /* code value */ - int dist; /* distance index */ - ush bl_count[MAX_BITS+1]; - /* number of codes at each bit length for an optimal tree */ - - if (static_init_done) return; - - /* For some embedded targets, global variables are not initialized: */ - static_l_desc.static_tree = static_ltree; - static_l_desc.extra_bits = extra_lbits; - static_d_desc.static_tree = static_dtree; - static_d_desc.extra_bits = extra_dbits; - static_bl_desc.extra_bits = extra_blbits; - - /* Initialize the mapping length (0..255) -> length code (0..28) */ - length = 0; - for (code = 0; code < LENGTH_CODES-1; code++) { - base_length[code] = length; - for (n = 0; n < (1< dist code (0..29) */ - dist = 0; - for (code = 0 ; code < 16; code++) { - base_dist[code] = dist; - for (n = 0; n < (1<>= 7; /* from now on, all distances are divided by 128 */ - for ( ; code < D_CODES; code++) { - base_dist[code] = dist << 7; - for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) { - _dist_code[256 + dist++] = (uch)code; - } - } - Assert (dist == 256, "tr_static_init: 256+dist != 512"); - - /* Construct the codes of the static literal tree */ - for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0; - n = 0; - while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++; - while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++; - while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++; - while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++; - /* Codes 286 and 287 do not exist, but we must include them in the - * tree construction to get a canonical Huffman tree (longest code - * all ones) - */ - gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count); - - /* The static distance tree is trivial: */ - for (n = 0; n < D_CODES; n++) { - static_dtree[n].Len = 5; - static_dtree[n].Code = bi_reverse((unsigned)n, 5); - } - static_init_done = 1; - -# ifdef GEN_TREES_H - gen_trees_header(); -# endif -#endif /* defined(GEN_TREES_H) || !defined(STDC) */ -} - -/* =========================================================================== - * Genererate the file trees.h describing the static trees. - */ -#ifdef GEN_TREES_H -# ifndef DEBUG -# include -# endif - -# define SEPARATOR(i, last, width) \ - ((i) == (last)? "\n};\n\n" : \ - ((i) % (width) == (width)-1 ? ",\n" : ", ")) - -void gen_trees_header() -{ - FILE *header = fopen("trees.h", "w"); - int i; - - Assert (header != NULL, "Can't open trees.h"); - fprintf(header, - "/* header created automatically with -DGEN_TREES_H */\n\n"); - - fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n"); - for (i = 0; i < L_CODES+2; i++) { - fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code, - static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5)); - } - - fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n"); - for (i = 0; i < D_CODES; i++) { - fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code, - static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5)); - } - - fprintf(header, "const uch _dist_code[DIST_CODE_LEN] = {\n"); - for (i = 0; i < DIST_CODE_LEN; i++) { - fprintf(header, "%2u%s", _dist_code[i], - SEPARATOR(i, DIST_CODE_LEN-1, 20)); - } - - fprintf(header, "const uch _length_code[MAX_MATCH-MIN_MATCH+1]= {\n"); - for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) { - fprintf(header, "%2u%s", _length_code[i], - SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20)); - } - - fprintf(header, "local const int base_length[LENGTH_CODES] = {\n"); - for (i = 0; i < LENGTH_CODES; i++) { - fprintf(header, "%1u%s", base_length[i], - SEPARATOR(i, LENGTH_CODES-1, 20)); - } - - fprintf(header, "local const int base_dist[D_CODES] = {\n"); - for (i = 0; i < D_CODES; i++) { - fprintf(header, "%5u%s", base_dist[i], - SEPARATOR(i, D_CODES-1, 10)); - } - - fclose(header); -} -#endif /* GEN_TREES_H */ - -/* =========================================================================== - * Initialize the tree data structures for a new zlib stream. - */ -void _tr_init(s) - deflate_state *s; -{ - tr_static_init(); - - s->l_desc.dyn_tree = s->dyn_ltree; - s->l_desc.stat_desc = &static_l_desc; - - s->d_desc.dyn_tree = s->dyn_dtree; - s->d_desc.stat_desc = &static_d_desc; - - s->bl_desc.dyn_tree = s->bl_tree; - s->bl_desc.stat_desc = &static_bl_desc; - - s->bi_buf = 0; - s->bi_valid = 0; - s->last_eob_len = 8; /* enough lookahead for inflate */ -#ifdef DEBUG - s->compressed_len = 0L; - s->bits_sent = 0L; -#endif - - /* Initialize the first block of the first file: */ - init_block(s); -} - -/* =========================================================================== - * Initialize a new block. - */ -local void init_block(s) - deflate_state *s; -{ - int n; /* iterates over tree elements */ - - /* Initialize the trees. */ - for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0; - for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0; - for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0; - - s->dyn_ltree[END_BLOCK].Freq = 1; - s->opt_len = s->static_len = 0L; - s->last_lit = s->matches = 0; -} - -#define SMALLEST 1 -/* Index within the heap array of least frequent node in the Huffman tree */ - - -/* =========================================================================== - * Remove the smallest element from the heap and recreate the heap with - * one less element. Updates heap and heap_len. - */ -#define pqremove(s, tree, top) \ -{\ - top = s->heap[SMALLEST]; \ - s->heap[SMALLEST] = s->heap[s->heap_len--]; \ - pqdownheap(s, tree, SMALLEST); \ -} - -/* =========================================================================== - * Compares to subtrees, using the tree depth as tie breaker when - * the subtrees have equal frequency. This minimizes the worst case length. - */ -#define smaller(tree, n, m, depth) \ - (tree[n].Freq < tree[m].Freq || \ - (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m])) - -/* =========================================================================== - * Restore the heap property by moving down the tree starting at node k, - * exchanging a node with the smallest of its two sons if necessary, stopping - * when the heap property is re-established (each father smaller than its - * two sons). - */ -local void pqdownheap(s, tree, k) - deflate_state *s; - ct_data *tree; /* the tree to restore */ - int k; /* node to move down */ -{ - int v = s->heap[k]; - int j = k << 1; /* left son of k */ - while (j <= s->heap_len) { - /* Set j to the smallest of the two sons: */ - if (j < s->heap_len && - smaller(tree, s->heap[j+1], s->heap[j], s->depth)) { - j++; - } - /* Exit if v is smaller than both sons */ - if (smaller(tree, v, s->heap[j], s->depth)) break; - - /* Exchange v with the smallest son */ - s->heap[k] = s->heap[j]; k = j; - - /* And continue down the tree, setting j to the left son of k */ - j <<= 1; - } - s->heap[k] = v; -} - -/* =========================================================================== - * Compute the optimal bit lengths for a tree and update the total bit length - * for the current block. - * IN assertion: the fields freq and dad are set, heap[heap_max] and - * above are the tree nodes sorted by increasing frequency. - * OUT assertions: the field len is set to the optimal bit length, the - * array bl_count contains the frequencies for each bit length. - * The length opt_len is updated; static_len is also updated if stree is - * not null. - */ -local void gen_bitlen(s, desc) - deflate_state *s; - tree_desc *desc; /* the tree descriptor */ -{ - ct_data *tree = desc->dyn_tree; - int max_code = desc->max_code; - const ct_data *stree = desc->stat_desc->static_tree; - const intf *extra = desc->stat_desc->extra_bits; - int base = desc->stat_desc->extra_base; - int max_length = desc->stat_desc->max_length; - int h; /* heap index */ - int n, m; /* iterate over the tree elements */ - int bits; /* bit length */ - int xbits; /* extra bits */ - ush f; /* frequency */ - int overflow = 0; /* number of elements with bit length too large */ - - for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0; - - /* In a first pass, compute the optimal bit lengths (which may - * overflow in the case of the bit length tree). - */ - tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */ - - for (h = s->heap_max+1; h < HEAP_SIZE; h++) { - n = s->heap[h]; - bits = tree[tree[n].Dad].Len + 1; - if (bits > max_length) bits = max_length, overflow++; - tree[n].Len = (ush)bits; - /* We overwrite tree[n].Dad which is no longer needed */ - - if (n > max_code) continue; /* not a leaf node */ - - s->bl_count[bits]++; - xbits = 0; - if (n >= base) xbits = extra[n-base]; - f = tree[n].Freq; - s->opt_len += (ulg)f * (bits + xbits); - if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits); - } - if (overflow == 0) return; - - Trace((stderr,"\nbit length overflow\n")); - /* This happens for example on obj2 and pic of the Calgary corpus */ - - /* Find the first bit length which could increase: */ - do { - bits = max_length-1; - while (s->bl_count[bits] == 0) bits--; - s->bl_count[bits]--; /* move one leaf down the tree */ - s->bl_count[bits+1] += 2; /* move one overflow item as its brother */ - s->bl_count[max_length]--; - /* The brother of the overflow item also moves one step up, - * but this does not affect bl_count[max_length] - */ - overflow -= 2; - } while (overflow > 0); - - /* Now recompute all bit lengths, scanning in increasing frequency. - * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all - * lengths instead of fixing only the wrong ones. This idea is taken - * from 'ar' written by Haruhiko Okumura.) - */ - for (bits = max_length; bits != 0; bits--) { - n = s->bl_count[bits]; - while (n != 0) { - m = s->heap[--h]; - if (m > max_code) continue; - if ((unsigned) tree[m].Len != (unsigned) bits) { - Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); - s->opt_len += ((long)bits - (long)tree[m].Len) - *(long)tree[m].Freq; - tree[m].Len = (ush)bits; - } - n--; - } - } -} - -/* =========================================================================== - * Generate the codes for a given tree and bit counts (which need not be - * optimal). - * IN assertion: the array bl_count contains the bit length statistics for - * the given tree and the field len is set for all tree elements. - * OUT assertion: the field code is set for all tree elements of non - * zero code length. - */ -local void gen_codes (tree, max_code, bl_count) - ct_data *tree; /* the tree to decorate */ - int max_code; /* largest code with non zero frequency */ - ushf *bl_count; /* number of codes at each bit length */ -{ - ush next_code[MAX_BITS+1]; /* next code value for each bit length */ - ush code = 0; /* running code value */ - int bits; /* bit index */ - int n; /* code index */ - - /* The distribution counts are first used to generate the code values - * without bit reversal. - */ - for (bits = 1; bits <= MAX_BITS; bits++) { - next_code[bits] = code = (code + bl_count[bits-1]) << 1; - } - /* Check that the bit counts in bl_count are consistent. The last code - * must be all ones. - */ - Assert (code + bl_count[MAX_BITS]-1 == (1<dyn_tree; - const ct_data *stree = desc->stat_desc->static_tree; - int elems = desc->stat_desc->elems; - int n, m; /* iterate over heap elements */ - int max_code = -1; /* largest code with non zero frequency */ - int node; /* new node being created */ - - /* Construct the initial heap, with least frequent element in - * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. - * heap[0] is not used. - */ - s->heap_len = 0, s->heap_max = HEAP_SIZE; - - for (n = 0; n < elems; n++) { - if (tree[n].Freq != 0) { - s->heap[++(s->heap_len)] = max_code = n; - s->depth[n] = 0; - } else { - tree[n].Len = 0; - } - } - - /* The pkzip format requires that at least one distance code exists, - * and that at least one bit should be sent even if there is only one - * possible code. So to avoid special checks later on we force at least - * two codes of non zero frequency. - */ - while (s->heap_len < 2) { - node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0); - tree[node].Freq = 1; - s->depth[node] = 0; - s->opt_len--; if (stree) s->static_len -= stree[node].Len; - /* node is 0 or 1 so it does not have extra bits */ - } - desc->max_code = max_code; - - /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, - * establish sub-heaps of increasing lengths: - */ - for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n); - - /* Construct the Huffman tree by repeatedly combining the least two - * frequent nodes. - */ - node = elems; /* next internal node of the tree */ - do { - pqremove(s, tree, n); /* n = node of least frequency */ - m = s->heap[SMALLEST]; /* m = node of next least frequency */ - - s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */ - s->heap[--(s->heap_max)] = m; - - /* Create a new node father of n and m */ - tree[node].Freq = tree[n].Freq + tree[m].Freq; - s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ? - s->depth[n] : s->depth[m]) + 1); - tree[n].Dad = tree[m].Dad = (ush)node; -#ifdef DUMP_BL_TREE - if (tree == s->bl_tree) { - fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)", - node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq); - } -#endif - /* and insert the new node in the heap */ - s->heap[SMALLEST] = node++; - pqdownheap(s, tree, SMALLEST); - - } while (s->heap_len >= 2); - - s->heap[--(s->heap_max)] = s->heap[SMALLEST]; - - /* At this point, the fields freq and dad are set. We can now - * generate the bit lengths. - */ - gen_bitlen(s, (tree_desc *)desc); - - /* The field len is now set, we can generate the bit codes */ - gen_codes ((ct_data *)tree, max_code, s->bl_count); -} - -/* =========================================================================== - * Scan a literal or distance tree to determine the frequencies of the codes - * in the bit length tree. - */ -local void scan_tree (s, tree, max_code) - deflate_state *s; - ct_data *tree; /* the tree to be scanned */ - int max_code; /* and its largest code of non zero frequency */ -{ - int n; /* iterates over all tree elements */ - int prevlen = -1; /* last emitted length */ - int curlen; /* length of current code */ - int nextlen = tree[0].Len; /* length of next code */ - int count = 0; /* repeat count of the current code */ - int max_count = 7; /* max repeat count */ - int min_count = 4; /* min repeat count */ - - if (nextlen == 0) max_count = 138, min_count = 3; - tree[max_code+1].Len = (ush)0xffff; /* guard */ - - for (n = 0; n <= max_code; n++) { - curlen = nextlen; nextlen = tree[n+1].Len; - if (++count < max_count && curlen == nextlen) { - continue; - } else if (count < min_count) { - s->bl_tree[curlen].Freq += count; - } else if (curlen != 0) { - if (curlen != prevlen) s->bl_tree[curlen].Freq++; - s->bl_tree[REP_3_6].Freq++; - } else if (count <= 10) { - s->bl_tree[REPZ_3_10].Freq++; - } else { - s->bl_tree[REPZ_11_138].Freq++; - } - count = 0; prevlen = curlen; - if (nextlen == 0) { - max_count = 138, min_count = 3; - } else if (curlen == nextlen) { - max_count = 6, min_count = 3; - } else { - max_count = 7, min_count = 4; - } - } -} - -/* =========================================================================== - * Send a literal or distance tree in compressed form, using the codes in - * bl_tree. - */ -local void send_tree (s, tree, max_code) - deflate_state *s; - ct_data *tree; /* the tree to be scanned */ - int max_code; /* and its largest code of non zero frequency */ -{ - int n; /* iterates over all tree elements */ - int prevlen = -1; /* last emitted length */ - int curlen; /* length of current code */ - int nextlen = tree[0].Len; /* length of next code */ - int count = 0; /* repeat count of the current code */ - int max_count = 7; /* max repeat count */ - int min_count = 4; /* min repeat count */ - - /* tree[max_code+1].Len = -1; */ /* guard already set */ - if (nextlen == 0) max_count = 138, min_count = 3; - - for (n = 0; n <= max_code; n++) { - curlen = nextlen; nextlen = tree[n+1].Len; - if (++count < max_count && curlen == nextlen) { - continue; - } else if (count < min_count) { - do { send_code(s, curlen, s->bl_tree); } while (--count != 0); - - } else if (curlen != 0) { - if (curlen != prevlen) { - send_code(s, curlen, s->bl_tree); count--; - } - Assert(count >= 3 && count <= 6, " 3_6?"); - send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2); - - } else if (count <= 10) { - send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3); - - } else { - send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7); - } - count = 0; prevlen = curlen; - if (nextlen == 0) { - max_count = 138, min_count = 3; - } else if (curlen == nextlen) { - max_count = 6, min_count = 3; - } else { - max_count = 7, min_count = 4; - } - } -} - -/* =========================================================================== - * Construct the Huffman tree for the bit lengths and return the index in - * bl_order of the last bit length code to send. - */ -local int build_bl_tree(s) - deflate_state *s; -{ - int max_blindex; /* index of last bit length code of non zero freq */ - - /* Determine the bit length frequencies for literal and distance trees */ - scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code); - scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code); - - /* Build the bit length tree: */ - build_tree(s, (tree_desc *)(&(s->bl_desc))); - /* opt_len now includes the length of the tree representations, except - * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. - */ - - /* Determine the number of bit length codes to send. The pkzip format - * requires that at least 4 bit length codes be sent. (appnote.txt says - * 3 but the actual value used is 4.) - */ - for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) { - if (s->bl_tree[bl_order[max_blindex]].Len != 0) break; - } - /* Update opt_len to include the bit length tree and counts */ - s->opt_len += 3*(max_blindex+1) + 5+5+4; - Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", - s->opt_len, s->static_len)); - - return max_blindex; -} - -/* =========================================================================== - * Send the header for a block using dynamic Huffman trees: the counts, the - * lengths of the bit length codes, the literal tree and the distance tree. - * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. - */ -local void send_all_trees(s, lcodes, dcodes, blcodes) - deflate_state *s; - int lcodes, dcodes, blcodes; /* number of codes for each tree */ -{ - int rank; /* index in bl_order */ - - Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); - Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, - "too many codes"); - Tracev((stderr, "\nbl counts: ")); - send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */ - send_bits(s, dcodes-1, 5); - send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */ - for (rank = 0; rank < blcodes; rank++) { - Tracev((stderr, "\nbl code %2d ", bl_order[rank])); - send_bits(s, s->bl_tree[bl_order[rank]].Len, 3); - } - Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); - - send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */ - Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); - - send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */ - Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); -} - -/* =========================================================================== - * Send a stored block - */ -void _tr_stored_block(s, buf, stored_len, eof) - deflate_state *s; - charf *buf; /* input block */ - ulg stored_len; /* length of input block */ - int eof; /* true if this is the last block for a file */ -{ - send_bits(s, (STORED_BLOCK<<1)+eof, 3); /* send block type */ -#ifdef DEBUG - s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; - s->compressed_len += (stored_len + 4) << 3; -#endif - copy_block(s, buf, (unsigned)stored_len, 1); /* with header */ -} - -/* =========================================================================== - * Send one empty static block to give enough lookahead for inflate. - * This takes 10 bits, of which 7 may remain in the bit buffer. - * The current inflate code requires 9 bits of lookahead. If the - * last two codes for the previous block (real code plus EOB) were coded - * on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode - * the last real code. In this case we send two empty static blocks instead - * of one. (There are no problems if the previous block is stored or fixed.) - * To simplify the code, we assume the worst case of last real code encoded - * on one bit only. - */ -void _tr_align(s) - deflate_state *s; -{ - send_bits(s, STATIC_TREES<<1, 3); - send_code(s, END_BLOCK, static_ltree); -#ifdef DEBUG - s->compressed_len += 10L; /* 3 for block type, 7 for EOB */ -#endif - bi_flush(s); - /* Of the 10 bits for the empty block, we have already sent - * (10 - bi_valid) bits. The lookahead for the last real code (before - * the EOB of the previous block) was thus at least one plus the length - * of the EOB plus what we have just sent of the empty static block. - */ - if (1 + s->last_eob_len + 10 - s->bi_valid < 9) { - send_bits(s, STATIC_TREES<<1, 3); - send_code(s, END_BLOCK, static_ltree); -#ifdef DEBUG - s->compressed_len += 10L; -#endif - bi_flush(s); - } - s->last_eob_len = 7; -} - -/* =========================================================================== - * Determine the best encoding for the current block: dynamic trees, static - * trees or store, and output the encoded block to the zip file. - */ -void _tr_flush_block(s, buf, stored_len, eof) - deflate_state *s; - charf *buf; /* input block, or NULL if too old */ - ulg stored_len; /* length of input block */ - int eof; /* true if this is the last block for a file */ -{ - ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ - int max_blindex = 0; /* index of last bit length code of non zero freq */ - - /* Build the Huffman trees unless a stored block is forced */ - if (s->level > 0) { - - /* Check if the file is binary or text */ - if (stored_len > 0 && s->strm->data_type == Z_UNKNOWN) - set_data_type(s); - - /* Construct the literal and distance trees */ - build_tree(s, (tree_desc *)(&(s->l_desc))); - Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, - s->static_len)); - - build_tree(s, (tree_desc *)(&(s->d_desc))); - Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, - s->static_len)); - /* At this point, opt_len and static_len are the total bit lengths of - * the compressed block data, excluding the tree representations. - */ - - /* Build the bit length tree for the above two trees, and get the index - * in bl_order of the last bit length code to send. - */ - max_blindex = build_bl_tree(s); - - /* Determine the best encoding. Compute the block lengths in bytes. */ - opt_lenb = (s->opt_len+3+7)>>3; - static_lenb = (s->static_len+3+7)>>3; - - Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", - opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, - s->last_lit)); - - if (static_lenb <= opt_lenb) opt_lenb = static_lenb; - - } else { - Assert(buf != (char*)0, "lost buf"); - opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ - } - -#ifdef FORCE_STORED - if (buf != (char*)0) { /* force stored block */ -#else - if (stored_len+4 <= opt_lenb && buf != (char*)0) { - /* 4: two words for the lengths */ -#endif - /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. - * Otherwise we can't have processed more than WSIZE input bytes since - * the last block flush, because compression would have been - * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to - * transform a block into a stored block. - */ - _tr_stored_block(s, buf, stored_len, eof); - -#ifdef FORCE_STATIC - } else if (static_lenb >= 0) { /* force static trees */ -#else - } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) { -#endif - send_bits(s, (STATIC_TREES<<1)+eof, 3); - compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree); -#ifdef DEBUG - s->compressed_len += 3 + s->static_len; -#endif - } else { - send_bits(s, (DYN_TREES<<1)+eof, 3); - send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, - max_blindex+1); - compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree); -#ifdef DEBUG - s->compressed_len += 3 + s->opt_len; -#endif - } - Assert (s->compressed_len == s->bits_sent, "bad compressed size"); - /* The above check is made mod 2^32, for files larger than 512 MB - * and uLong implemented on 32 bits. - */ - init_block(s); - - if (eof) { - bi_windup(s); -#ifdef DEBUG - s->compressed_len += 7; /* align on byte boundary */ -#endif - } - Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, - s->compressed_len-7*eof)); -} - -/* =========================================================================== - * Save the match info and tally the frequency counts. Return true if - * the current block must be flushed. - */ -int _tr_tally (s, dist, lc) - deflate_state *s; - unsigned dist; /* distance of matched string */ - unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ -{ - s->d_buf[s->last_lit] = (ush)dist; - s->l_buf[s->last_lit++] = (uch)lc; - if (dist == 0) { - /* lc is the unmatched char */ - s->dyn_ltree[lc].Freq++; - } else { - s->matches++; - /* Here, lc is the match length - MIN_MATCH */ - dist--; /* dist = match distance - 1 */ - Assert((ush)dist < (ush)MAX_DIST(s) && - (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && - (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); - - s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++; - s->dyn_dtree[d_code(dist)].Freq++; - } - -#ifdef TRUNCATE_BLOCK - /* Try to guess if it is profitable to stop the current block here */ - if ((s->last_lit & 0x1fff) == 0 && s->level > 2) { - /* Compute an upper bound for the compressed length */ - ulg out_length = (ulg)s->last_lit*8L; - ulg in_length = (ulg)((long)s->strstart - s->block_start); - int dcode; - for (dcode = 0; dcode < D_CODES; dcode++) { - out_length += (ulg)s->dyn_dtree[dcode].Freq * - (5L+extra_dbits[dcode]); - } - out_length >>= 3; - Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", - s->last_lit, in_length, out_length, - 100L - out_length*100L/in_length)); - if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1; - } -#endif - return (s->last_lit == s->lit_bufsize-1); - /* We avoid equality with lit_bufsize because of wraparound at 64K - * on 16 bit machines and because stored blocks are restricted to - * 64K-1 bytes. - */ -} - -/* =========================================================================== - * Send the block data compressed using the given Huffman trees - */ -local void compress_block(s, ltree, dtree) - deflate_state *s; - ct_data *ltree; /* literal tree */ - ct_data *dtree; /* distance tree */ -{ - unsigned dist; /* distance of matched string */ - int lc; /* match length or unmatched char (if dist == 0) */ - unsigned lx = 0; /* running index in l_buf */ - unsigned code; /* the code to send */ - int extra; /* number of extra bits to send */ - - if (s->last_lit != 0) do { - dist = s->d_buf[lx]; - lc = s->l_buf[lx++]; - if (dist == 0) { - send_code(s, lc, ltree); /* send a literal byte */ - Tracecv(isgraph(lc), (stderr," '%c' ", lc)); - } else { - /* Here, lc is the match length - MIN_MATCH */ - code = _length_code[lc]; - send_code(s, code+LITERALS+1, ltree); /* send the length code */ - extra = extra_lbits[code]; - if (extra != 0) { - lc -= base_length[code]; - send_bits(s, lc, extra); /* send the extra length bits */ - } - dist--; /* dist is now the match distance - 1 */ - code = d_code(dist); - Assert (code < D_CODES, "bad d_code"); - - send_code(s, code, dtree); /* send the distance code */ - extra = extra_dbits[code]; - if (extra != 0) { - dist -= base_dist[code]; - send_bits(s, dist, extra); /* send the extra distance bits */ - } - } /* literal or match pair ? */ - - /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ - Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx, - "pendingBuf overflow"); - - } while (lx < s->last_lit); - - send_code(s, END_BLOCK, ltree); - s->last_eob_len = ltree[END_BLOCK].Len; -} - -/* =========================================================================== - * Set the data type to BINARY or TEXT, using a crude approximation: - * set it to Z_TEXT if all symbols are either printable characters (33 to 255) - * or white spaces (9 to 13, or 32); or set it to Z_BINARY otherwise. - * IN assertion: the fields Freq of dyn_ltree are set. - */ -local void set_data_type(s) - deflate_state *s; -{ - int n; - - for (n = 0; n < 9; n++) - if (s->dyn_ltree[n].Freq != 0) - break; - if (n == 9) - for (n = 14; n < 32; n++) - if (s->dyn_ltree[n].Freq != 0) - break; - s->strm->data_type = (n == 32) ? Z_TEXT : Z_BINARY; -} - -/* =========================================================================== - * Reverse the first len bits of a code, using straightforward code (a faster - * method would use a table) - * IN assertion: 1 <= len <= 15 - */ -local unsigned bi_reverse(code, len) - unsigned code; /* the value to invert */ - int len; /* its bit length */ -{ - register unsigned res = 0; - do { - res |= code & 1; - code >>= 1, res <<= 1; - } while (--len > 0); - return res >> 1; -} - -/* =========================================================================== - * Flush the bit buffer, keeping at most 7 bits in it. - */ -local void bi_flush(s) - deflate_state *s; -{ - if (s->bi_valid == 16) { - put_short(s, s->bi_buf); - s->bi_buf = 0; - s->bi_valid = 0; - } else if (s->bi_valid >= 8) { - put_byte(s, (Byte)s->bi_buf); - s->bi_buf >>= 8; - s->bi_valid -= 8; - } -} - -/* =========================================================================== - * Flush the bit buffer and align the output on a byte boundary - */ -local void bi_windup(s) - deflate_state *s; -{ - if (s->bi_valid > 8) { - put_short(s, s->bi_buf); - } else if (s->bi_valid > 0) { - put_byte(s, (Byte)s->bi_buf); - } - s->bi_buf = 0; - s->bi_valid = 0; -#ifdef DEBUG - s->bits_sent = (s->bits_sent+7) & ~7; -#endif -} - -/* =========================================================================== - * Copy a stored block, storing first the length and its - * one's complement if requested. - */ -local void copy_block(s, buf, len, header) - deflate_state *s; - charf *buf; /* the input data */ - unsigned len; /* its length */ - int header; /* true if block header must be written */ -{ - bi_windup(s); /* align on byte boundary */ - s->last_eob_len = 8; /* enough lookahead for inflate */ - - if (header) { - put_short(s, (ush)len); - put_short(s, (ush)~len); -#ifdef DEBUG - s->bits_sent += 2*16; -#endif - } -#ifdef DEBUG - s->bits_sent += (ulg)len<<3; -#endif - while (len--) { - put_byte(s, *buf++); - } -} diff --git a/ndk/sources/external/zlib/trees.h b/ndk/sources/external/zlib/trees.h deleted file mode 100644 index 72facf900..000000000 --- a/ndk/sources/external/zlib/trees.h +++ /dev/null @@ -1,128 +0,0 @@ -/* header created automatically with -DGEN_TREES_H */ - -local const ct_data static_ltree[L_CODES+2] = { -{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}}, -{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}}, -{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}}, -{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}}, -{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}}, -{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}}, -{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}}, -{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}}, -{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}}, -{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}}, -{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}}, -{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}}, -{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}}, -{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}}, -{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}}, -{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}}, -{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}}, -{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}}, -{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}}, -{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}}, -{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}}, -{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}}, -{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}}, -{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}}, -{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}}, -{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}}, -{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}}, -{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}}, -{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}}, -{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}}, -{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}}, -{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}}, -{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}}, -{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}}, -{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}}, -{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}}, -{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}}, -{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}}, -{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}}, -{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}}, -{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}}, -{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}}, -{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}}, -{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}}, -{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}}, -{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}}, -{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}}, -{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}}, -{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}}, -{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}}, -{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}}, -{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}}, -{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}}, -{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}}, -{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}}, -{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}}, -{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}}, -{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}} -}; - -local const ct_data static_dtree[D_CODES] = { -{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}}, -{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}}, -{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}}, -{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}}, -{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}}, -{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}} -}; - -const uch _dist_code[DIST_CODE_LEN] = { - 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, - 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, -10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, -11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, -12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, -18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, -23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, -24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, -26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, -26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, -27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, -27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, -28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, -28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, -28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, -29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, -29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, -29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 -}; - -const uch _length_code[MAX_MATCH-MIN_MATCH+1]= { - 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, -13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, -17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, -19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, -21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, -22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, -23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, -24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, -25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, -25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, -26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, -26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, -27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 -}; - -local const int base_length[LENGTH_CODES] = { -0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, -64, 80, 96, 112, 128, 160, 192, 224, 0 -}; - -local const int base_dist[D_CODES] = { - 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, - 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, - 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 -}; - diff --git a/ndk/sources/external/zlib/uncompr.c b/ndk/sources/external/zlib/uncompr.c deleted file mode 100644 index b59e3d0de..000000000 --- a/ndk/sources/external/zlib/uncompr.c +++ /dev/null @@ -1,61 +0,0 @@ -/* uncompr.c -- decompress a memory buffer - * Copyright (C) 1995-2003 Jean-loup Gailly. - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* @(#) $Id$ */ - -#define ZLIB_INTERNAL -#include "zlib.h" - -/* =========================================================================== - Decompresses the source buffer into the destination buffer. sourceLen is - the byte length of the source buffer. Upon entry, destLen is the total - size of the destination buffer, which must be large enough to hold the - entire uncompressed data. (The size of the uncompressed data must have - been saved previously by the compressor and transmitted to the decompressor - by some mechanism outside the scope of this compression library.) - Upon exit, destLen is the actual size of the compressed buffer. - This function can be used to decompress a whole file at once if the - input file is mmap'ed. - - uncompress returns Z_OK if success, Z_MEM_ERROR if there was not - enough memory, Z_BUF_ERROR if there was not enough room in the output - buffer, or Z_DATA_ERROR if the input data was corrupted. -*/ -int ZEXPORT uncompress (dest, destLen, source, sourceLen) - Bytef *dest; - uLongf *destLen; - const Bytef *source; - uLong sourceLen; -{ - z_stream stream; - int err; - - stream.next_in = (Bytef*)source; - stream.avail_in = (uInt)sourceLen; - /* Check for source > 64K on 16-bit machine: */ - if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; - - stream.next_out = dest; - stream.avail_out = (uInt)*destLen; - if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; - - stream.zalloc = (alloc_func)0; - stream.zfree = (free_func)0; - - err = inflateInit(&stream); - if (err != Z_OK) return err; - - err = inflate(&stream, Z_FINISH); - if (err != Z_STREAM_END) { - inflateEnd(&stream); - if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0)) - return Z_DATA_ERROR; - return err; - } - *destLen = stream.total_out; - - err = inflateEnd(&stream); - return err; -} diff --git a/ndk/sources/external/zlib/zutil.c b/ndk/sources/external/zlib/zutil.c deleted file mode 100644 index d55f5948a..000000000 --- a/ndk/sources/external/zlib/zutil.c +++ /dev/null @@ -1,318 +0,0 @@ -/* zutil.c -- target dependent utility functions for the compression library - * Copyright (C) 1995-2005 Jean-loup Gailly. - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* @(#) $Id$ */ - -#include "zutil.h" - -#ifndef NO_DUMMY_DECL -struct internal_state {int dummy;}; /* for buggy compilers */ -#endif - -const char * const z_errmsg[10] = { -"need dictionary", /* Z_NEED_DICT 2 */ -"stream end", /* Z_STREAM_END 1 */ -"", /* Z_OK 0 */ -"file error", /* Z_ERRNO (-1) */ -"stream error", /* Z_STREAM_ERROR (-2) */ -"data error", /* Z_DATA_ERROR (-3) */ -"insufficient memory", /* Z_MEM_ERROR (-4) */ -"buffer error", /* Z_BUF_ERROR (-5) */ -"incompatible version",/* Z_VERSION_ERROR (-6) */ -""}; - - -const char * ZEXPORT zlibVersion() -{ - return ZLIB_VERSION; -} - -uLong ZEXPORT zlibCompileFlags() -{ - uLong flags; - - flags = 0; - switch (sizeof(uInt)) { - case 2: break; - case 4: flags += 1; break; - case 8: flags += 2; break; - default: flags += 3; - } - switch (sizeof(uLong)) { - case 2: break; - case 4: flags += 1 << 2; break; - case 8: flags += 2 << 2; break; - default: flags += 3 << 2; - } - switch (sizeof(voidpf)) { - case 2: break; - case 4: flags += 1 << 4; break; - case 8: flags += 2 << 4; break; - default: flags += 3 << 4; - } - switch (sizeof(z_off_t)) { - case 2: break; - case 4: flags += 1 << 6; break; - case 8: flags += 2 << 6; break; - default: flags += 3 << 6; - } -#ifdef DEBUG - flags += 1 << 8; -#endif -#if defined(ASMV) || defined(ASMINF) - flags += 1 << 9; -#endif -#ifdef ZLIB_WINAPI - flags += 1 << 10; -#endif -#ifdef BUILDFIXED - flags += 1 << 12; -#endif -#ifdef DYNAMIC_CRC_TABLE - flags += 1 << 13; -#endif -#ifdef NO_GZCOMPRESS - flags += 1L << 16; -#endif -#ifdef NO_GZIP - flags += 1L << 17; -#endif -#ifdef PKZIP_BUG_WORKAROUND - flags += 1L << 20; -#endif -#ifdef FASTEST - flags += 1L << 21; -#endif -#ifdef STDC -# ifdef NO_vsnprintf - flags += 1L << 25; -# ifdef HAS_vsprintf_void - flags += 1L << 26; -# endif -# else -# ifdef HAS_vsnprintf_void - flags += 1L << 26; -# endif -# endif -#else - flags += 1L << 24; -# ifdef NO_snprintf - flags += 1L << 25; -# ifdef HAS_sprintf_void - flags += 1L << 26; -# endif -# else -# ifdef HAS_snprintf_void - flags += 1L << 26; -# endif -# endif -#endif - return flags; -} - -#ifdef DEBUG - -# ifndef verbose -# define verbose 0 -# endif -int z_verbose = verbose; - -void z_error (m) - char *m; -{ - fprintf(stderr, "%s\n", m); - exit(1); -} -#endif - -/* exported to allow conversion of error code to string for compress() and - * uncompress() - */ -const char * ZEXPORT zError(err) - int err; -{ - return ERR_MSG(err); -} - -#if defined(_WIN32_WCE) - /* The Microsoft C Run-Time Library for Windows CE doesn't have - * errno. We define it as a global variable to simplify porting. - * Its value is always 0 and should not be used. - */ - int errno = 0; -#endif - -#ifndef HAVE_MEMCPY - -void zmemcpy(dest, source, len) - Bytef* dest; - const Bytef* source; - uInt len; -{ - if (len == 0) return; - do { - *dest++ = *source++; /* ??? to be unrolled */ - } while (--len != 0); -} - -int zmemcmp(s1, s2, len) - const Bytef* s1; - const Bytef* s2; - uInt len; -{ - uInt j; - - for (j = 0; j < len; j++) { - if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1; - } - return 0; -} - -void zmemzero(dest, len) - Bytef* dest; - uInt len; -{ - if (len == 0) return; - do { - *dest++ = 0; /* ??? to be unrolled */ - } while (--len != 0); -} -#endif - - -#ifdef SYS16BIT - -#ifdef __TURBOC__ -/* Turbo C in 16-bit mode */ - -# define MY_ZCALLOC - -/* Turbo C malloc() does not allow dynamic allocation of 64K bytes - * and farmalloc(64K) returns a pointer with an offset of 8, so we - * must fix the pointer. Warning: the pointer must be put back to its - * original form in order to free it, use zcfree(). - */ - -#define MAX_PTR 10 -/* 10*64K = 640K */ - -local int next_ptr = 0; - -typedef struct ptr_table_s { - voidpf org_ptr; - voidpf new_ptr; -} ptr_table; - -local ptr_table table[MAX_PTR]; -/* This table is used to remember the original form of pointers - * to large buffers (64K). Such pointers are normalized with a zero offset. - * Since MSDOS is not a preemptive multitasking OS, this table is not - * protected from concurrent access. This hack doesn't work anyway on - * a protected system like OS/2. Use Microsoft C instead. - */ - -voidpf zcalloc (voidpf opaque, unsigned items, unsigned size) -{ - voidpf buf = opaque; /* just to make some compilers happy */ - ulg bsize = (ulg)items*size; - - /* If we allocate less than 65520 bytes, we assume that farmalloc - * will return a usable pointer which doesn't have to be normalized. - */ - if (bsize < 65520L) { - buf = farmalloc(bsize); - if (*(ush*)&buf != 0) return buf; - } else { - buf = farmalloc(bsize + 16L); - } - if (buf == NULL || next_ptr >= MAX_PTR) return NULL; - table[next_ptr].org_ptr = buf; - - /* Normalize the pointer to seg:0 */ - *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; - *(ush*)&buf = 0; - table[next_ptr++].new_ptr = buf; - return buf; -} - -void zcfree (voidpf opaque, voidpf ptr) -{ - int n; - if (*(ush*)&ptr != 0) { /* object < 64K */ - farfree(ptr); - return; - } - /* Find the original pointer */ - for (n = 0; n < next_ptr; n++) { - if (ptr != table[n].new_ptr) continue; - - farfree(table[n].org_ptr); - while (++n < next_ptr) { - table[n-1] = table[n]; - } - next_ptr--; - return; - } - ptr = opaque; /* just to make some compilers happy */ - Assert(0, "zcfree: ptr not found"); -} - -#endif /* __TURBOC__ */ - - -#ifdef M_I86 -/* Microsoft C in 16-bit mode */ - -# define MY_ZCALLOC - -#if (!defined(_MSC_VER) || (_MSC_VER <= 600)) -# define _halloc halloc -# define _hfree hfree -#endif - -voidpf zcalloc (voidpf opaque, unsigned items, unsigned size) -{ - if (opaque) opaque = 0; /* to make compiler happy */ - return _halloc((long)items, size); -} - -void zcfree (voidpf opaque, voidpf ptr) -{ - if (opaque) opaque = 0; /* to make compiler happy */ - _hfree(ptr); -} - -#endif /* M_I86 */ - -#endif /* SYS16BIT */ - - -#ifndef MY_ZCALLOC /* Any system without a special alloc function */ - -#ifndef STDC -extern voidp malloc OF((uInt size)); -extern voidp calloc OF((uInt items, uInt size)); -extern void free OF((voidpf ptr)); -#endif - -voidpf zcalloc (opaque, items, size) - voidpf opaque; - unsigned items; - unsigned size; -{ - if (opaque) items += size - size; /* make compiler happy */ - return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : - (voidpf)calloc(items, size); -} - -void zcfree (opaque, ptr) - voidpf opaque; - voidpf ptr; -{ - free(ptr); - if (opaque) return; /* make compiler happy */ -} - -#endif /* MY_ZCALLOC */ diff --git a/ndk/sources/external/zlib/zutil.h b/ndk/sources/external/zlib/zutil.h deleted file mode 100644 index b7d5eff81..000000000 --- a/ndk/sources/external/zlib/zutil.h +++ /dev/null @@ -1,269 +0,0 @@ -/* zutil.h -- internal interface and configuration of the compression library - * Copyright (C) 1995-2005 Jean-loup Gailly. - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* WARNING: this file should *not* be used by applications. It is - part of the implementation of the compression library and is - subject to change. Applications should only use zlib.h. - */ - -/* @(#) $Id$ */ - -#ifndef ZUTIL_H -#define ZUTIL_H - -#define ZLIB_INTERNAL -#include "zlib.h" - -#ifdef STDC -# ifndef _WIN32_WCE -# include -# endif -# include -# include -#endif -#ifdef NO_ERRNO_H -# ifdef _WIN32_WCE - /* The Microsoft C Run-Time Library for Windows CE doesn't have - * errno. We define it as a global variable to simplify porting. - * Its value is always 0 and should not be used. We rename it to - * avoid conflict with other libraries that use the same workaround. - */ -# define errno z_errno -# endif - extern int errno; -#else -# ifndef _WIN32_WCE -# include -# endif -#endif - -#ifndef local -# define local static -#endif -/* compile with -Dlocal if your debugger can't find static symbols */ - -typedef unsigned char uch; -typedef uch FAR uchf; -typedef unsigned short ush; -typedef ush FAR ushf; -typedef unsigned long ulg; - -extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ -/* (size given to avoid silly warnings with Visual C++) */ - -#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)] - -#define ERR_RETURN(strm,err) \ - return (strm->msg = (char*)ERR_MSG(err), (err)) -/* To be used only when the state is known to be valid */ - - /* common constants */ - -#ifndef DEF_WBITS -# define DEF_WBITS MAX_WBITS -#endif -/* default windowBits for decompression. MAX_WBITS is for compression only */ - -#if MAX_MEM_LEVEL >= 8 -# define DEF_MEM_LEVEL 8 -#else -# define DEF_MEM_LEVEL MAX_MEM_LEVEL -#endif -/* default memLevel */ - -#define STORED_BLOCK 0 -#define STATIC_TREES 1 -#define DYN_TREES 2 -/* The three kinds of block type */ - -#define MIN_MATCH 3 -#define MAX_MATCH 258 -/* The minimum and maximum match lengths */ - -#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */ - - /* target dependencies */ - -#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32)) -# define OS_CODE 0x00 -# if defined(__TURBOC__) || defined(__BORLANDC__) -# if(__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) - /* Allow compilation with ANSI keywords only enabled */ - void _Cdecl farfree( void *block ); - void *_Cdecl farmalloc( unsigned long nbytes ); -# else -# include -# endif -# else /* MSC or DJGPP */ -# include -# endif -#endif - -#ifdef AMIGA -# define OS_CODE 0x01 -#endif - -#if defined(VAXC) || defined(VMS) -# define OS_CODE 0x02 -# define F_OPEN(name, mode) \ - fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512") -#endif - -#if defined(ATARI) || defined(atarist) -# define OS_CODE 0x05 -#endif - -#ifdef OS2 -# define OS_CODE 0x06 -# ifdef M_I86 - #include -# endif -#endif - -#if defined(MACOS) || defined(TARGET_OS_MAC) -# define OS_CODE 0x07 -# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os -# include /* for fdopen */ -# else -# ifndef fdopen -# define fdopen(fd,mode) NULL /* No fdopen() */ -# endif -# endif -#endif - -#ifdef TOPS20 -# define OS_CODE 0x0a -#endif - -#ifdef WIN32 -# ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */ -# define OS_CODE 0x0b -# endif -#endif - -#ifdef __50SERIES /* Prime/PRIMOS */ -# define OS_CODE 0x0f -#endif - -#if defined(_BEOS_) || defined(RISCOS) -# define fdopen(fd,mode) NULL /* No fdopen() */ -#endif - -#if (defined(_MSC_VER) && (_MSC_VER > 600)) -# if defined(_WIN32_WCE) -# define fdopen(fd,mode) NULL /* No fdopen() */ -# ifndef _PTRDIFF_T_DEFINED - typedef int ptrdiff_t; -# define _PTRDIFF_T_DEFINED -# endif -# else -# define fdopen(fd,type) _fdopen(fd,type) -# endif -#endif - - /* common defaults */ - -#ifndef OS_CODE -# define OS_CODE 0x03 /* assume Unix */ -#endif - -#ifndef F_OPEN -# define F_OPEN(name, mode) fopen((name), (mode)) -#endif - - /* functions */ - -#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550) -# ifndef HAVE_VSNPRINTF -# define HAVE_VSNPRINTF -# endif -#endif -#if defined(__CYGWIN__) -# ifndef HAVE_VSNPRINTF -# define HAVE_VSNPRINTF -# endif -#endif -#ifndef HAVE_VSNPRINTF -# ifdef MSDOS - /* vsnprintf may exist on some MS-DOS compilers (DJGPP?), - but for now we just assume it doesn't. */ -# define NO_vsnprintf -# endif -# ifdef __TURBOC__ -# define NO_vsnprintf -# endif -# ifdef WIN32 - /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */ -# if !defined(vsnprintf) && !defined(NO_vsnprintf) -# define vsnprintf _vsnprintf -# endif -# endif -# ifdef __SASC -# define NO_vsnprintf -# endif -#endif -#ifdef VMS -# define NO_vsnprintf -#endif - -#if defined(pyr) -# define NO_MEMCPY -#endif -#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) - /* Use our own functions for small and medium model with MSC <= 5.0. - * You may have to use the same strategy for Borland C (untested). - * The __SC__ check is for Symantec. - */ -# define NO_MEMCPY -#endif -#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY) -# define HAVE_MEMCPY -#endif -#ifdef HAVE_MEMCPY -# ifdef SMALL_MEDIUM /* MSDOS small or medium model */ -# define zmemcpy _fmemcpy -# define zmemcmp _fmemcmp -# define zmemzero(dest, len) _fmemset(dest, 0, len) -# else -# define zmemcpy memcpy -# define zmemcmp memcmp -# define zmemzero(dest, len) memset(dest, 0, len) -# endif -#else - extern void zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); - extern int zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); - extern void zmemzero OF((Bytef* dest, uInt len)); -#endif - -/* Diagnostic functions */ -#ifdef DEBUG -# include - extern int z_verbose; - extern void z_error OF((char *m)); -# define Assert(cond,msg) {if(!(cond)) z_error(msg);} -# define Trace(x) {if (z_verbose>=0) fprintf x ;} -# define Tracev(x) {if (z_verbose>0) fprintf x ;} -# define Tracevv(x) {if (z_verbose>1) fprintf x ;} -# define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;} -# define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;} -#else -# define Assert(cond,msg) -# define Trace(x) -# define Tracev(x) -# define Tracevv(x) -# define Tracec(c,x) -# define Tracecv(c,x) -#endif - - -voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size)); -void zcfree OF((voidpf opaque, voidpf ptr)); - -#define ZALLOC(strm, items, size) \ - (*((strm)->zalloc))((strm)->opaque, (items), (size)) -#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) -#define TRY_FREE(s, p) {if (p) ZFREE(s, p);} - -#endif /* ZUTIL_H */