From 6d8778d8e7af50f0a7055d239df796e34f188239 Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Mon, 9 Oct 2017 16:44:31 -0700
Subject: [PATCH 001/145] [doc] Add images for release notes

---
 doc/images/linux-4.7-12-compress.png   | Bin 0 -> 93913 bytes
 doc/images/linux-4.7-12-decompress.png | Bin 0 -> 56215 bytes
 doc/images/linux-git-compress.png      | Bin 0 -> 105620 bytes
 doc/images/linux-git-decompress.png    | Bin 0 -> 54333 bytes
 4 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 doc/images/linux-4.7-12-compress.png
 create mode 100644 doc/images/linux-4.7-12-decompress.png
 create mode 100644 doc/images/linux-git-compress.png
 create mode 100644 doc/images/linux-git-decompress.png

diff --git a/doc/images/linux-4.7-12-compress.png b/doc/images/linux-4.7-12-compress.png
new file mode 100644
index 0000000000000000000000000000000000000000..71f3381bdef8fb1e0d811513c588b03dfb03d0a2
GIT binary patch
literal 93913
zcmeAS@N?(olHy`uVBq!ia0y~yV2xm4U{T{>V_;x7y7bBw1_lPk;vjb?hIQv;UNSH+
za29w(7Beu23xP0W`us~l3=9qoo-U3d6^w80a?g<st+n{D`Q{!E1;vLGr#mR9ba8R~
za1cDQ>W7$!fFt+9tx>w7(H{flL$kL=xUT-QHY2-{OQU1$iXTV3SaY1T6&6ikS8x=X
zr>Lm-WaG(y-^~->-Mf2d@6O#fchB7Uz4}kiyE`+Dji1-l7mI%{KR@T?j>mo0>)yY3
zVWFkT!XcpG(7?dRgu=M6!J)kT`&Zd+G2K^r75t){*c3S|P%^NJpJkpOx9`PNbQ2(E
zzT(h{+hcLtYL%btY^)YJEa+=s$(EJDE*s$Q(6n`4UoMK<ASQDNtWZ`s7{z{E4b|mP
z*(<^m64owHmPYdzMD`Vj$A)VMH+Eum^H&y?h}SP~xM75eLjyyj6_e1K(t;c%h&iY}
za<FCOyjEqkO%O|Xj(U?rKw-qhW<tr{UbJM;n8soA=fmNbUE1qBl8^WKrq3yKlQK^8
zG4^{r1Dv`Sykrtu<EviA1WL{s(++frYF~Q0{r<df_p0B2Ig@TzynA`4{iAogUau>;
zQ+RyoVSf9X-Cv`Z9{Tn5^<`i4yHn;>JnG!?dfo1{TKO~b8~bfOdF=Xp&RY7>ix)3E
z+U2S;z8x=ew&p2bD*HBj?X#RaI}Gm@9Ol)GoB#jM^W~nC)vm6(mVUSP``zhzyWegT
zIoVwJ_}J3O&1p-Q+kIV``RdBb+E<mAZ!x|7Wu0!Z=v1DCNOyhDkM}>mUXPz|`lUC&
zW-&|lN9Sd&AfFgCG_bs8FbES?aA<J&$XfU7^897;e_yy~uHXC3EB?nJ@mFRRLizW9
zo-5yEHFxgZ+^GqFuh;**{^fN1zfF%mFXXS)uzf6fe#M^q_YPeRkDqIqzdml?-@EVY
z%B$WL&!4?t_TqKfx7q)XxlJ<Z`}v@mKW+B6JH_WqjtIJcSszxpKjq}4FJIT!+v>*d
z+OkP6zC$odeO^UU)!Xd&+3P>uI>hw$k9E5H;Zu3;tZ)4xIlN~}1IufVZfki^QSnBk
z@#Ev;%a_~#efjd;?)QG}GDRo+G7q1#$n5#h`{dP&i;IK9!>>=6Rq&vZeOc}IyW8LG
zdwp%~X}4^*r5o-^rds@(wY~c7t*tLFdF%WB|9k)c-1WEKy?%Cf_GNYZpC@ycyw=<O
zX412Bb7z0Mk=!q$yye}F$9*|}&G&um%@O(79slRiTRH#MBJM4(-_LpLs_S<6|6}`q
z$!4ei?)iLfwdJk3cfX0`szZvNE;WUNQCm7P_(85V@qKVu{$Ii6zStwo`8PMI#+F=k
zjl3N9dDit1w-0>V*6LRr<PQ3CMZ0j`{6A0BGq>L@^JbSV3D~>J_oi7)ZSS$88dp62
z*nGQ@d{g)D`ii64mr|$4UJKZr{Hj&h&q8tUpQrl%6I0Hf{{Qd&|7GXv|9!rB+hdbl
z^_z{F%Yp-<q8Hq)du}3h_Q$8Bv$ISiul~5C?pAhP>rK|m2zN*bi-abG1WGT91*Hy$
zh68<^M?|>3->c4_Wm{eLYq9;W#j@5BbN4DIPU`<sbJ9C*Q}DA3(&zRatJ&Ib|F6R8
z-;c+eU9uNnmOXMsSUje{aazJ!zjbVPi|2iwQ*tA*J+<rM*9*@4R|U5s73YmcoDv74
zmStpWgM#PHgaf75W2aBkkDoX1`<~~ip2uG`yEc7jWS2W3*Rb{XyWPtxJT9I!zdz^f
zQpwMG$KKwXn6cXQ)rVQx>pVXytXSM<rDgk6(|@I1&bB>OUti^vr1#|Y{4`e<6z8Aw
z>mYyKgh$&xWt^}3{dW7=y25|1-D0V^wx3QYZ@(Fr@7lBP&$aFQriRY6udkCbT~&F1
z<-hCof5UHWNOZooe)`@wsb6PZosxU_?sf5fA6jp6T+Y0_jCa>w!P|{qKAQy$dxdiQ
z+BfqqTNAU>=<ogif8(c_^k-|WJMD2xuI9r*Q-0yk5&xc<@Av$Er`Z43VflX()O==4
z_;xdW{+p=2O!=&-|K>N}Fc&)av0%rKm?NhDwk)?@yXp1fe!E$Ze)U%wihtTu`8g<N
z^;SFe>v7e&(<17gYRAv?oh*?1>!^O+#9Fn(O5bX)ZJrle+|~K2?5OjxM{~B{tIGby
zuyMz;RkuZYyH&pFZof0hms9BE8%g7|l=&NH*qh5)g{^kk`$JYR*y_j>al!xT_P=l5
zyrT5?wRzO`d++D`nQ>Tf`N2Q?PMwc_zcuiE=<2Yg@qb^1-+X^^huUMsD#6n~oEH9n
zzvag!^>zP0oITB7|Kso}aifpBH~)Ire0J06^Ra)Wiq(#%XP=s)dGp2RSGiYD8w%Mj
zv*@r~v)aDAH;(`6@l{*zyeKStvU$q<a*g>DZ<Me2tsA{f=Xb5he(y(Coz}9CtOCK+
zw!>-;j}6<rRK7NYS^?X%Kiqv^XYM`6O-RSBG;I3&`v1RgZu7Wur{Zz%%lrTT-VeT0
z78k1|_^YpcPx9>OsQrK6<}bI|8K8Yosy^c1^ZI}3Wh*2+r8pOPY}1R_pkST82UPB@
zQ;}Mfq*DF=<@|q|xwp1x{(U+BUuLPXR1_%IW~z4f+5LK<Qz&|JXWEn<N53Dp|5sS{
z!o$J6DQU^+g72l*)<pWgbW(Zy$*A(vlbVeSuX~uq)_gn~>9e}LqkWI<=b7hyp3f=v
zoB!HqlEnY_|NrhU`TzHOc=&o9_n=Q_^XrP|*Cr)@eg2?LI`70Xw-@i;t$Xu*^ZdU$
zb89}GeED^KeQnf^g2Z31!uQXrjhqnPk*#QF|GwtA_3xPT8*SyLiFF=u=C?KRu8S+Z
z8oKh=jf>Nn`79LnzOQ|M+D`eW;bYVMaFs;mog&Xqc%Qi*IX9tqXT|<6OZAsVU9UOv
z?ak)%_nvi6_%Z3hqIsEmzs?8C<W{|ozJDv7<wwG+Yrp3Tzm@N^;QjVJ^j+Bdt%C1o
zm?;Y_`KTKBUuggPB$f&rQ9J#@y?>6^|8f6kR^5AlZe``G;Q6=I58l$*{io*Y`j3{K
zpItl4zWjghyrw_<v3C4VuWyn)*?RsP_?}gDJmv{uE1o0!Q|IW<_D_;GC;olJ*Zkve
z=->NSBE+v1UT<~+mq}5M4ozD{7p>q2l}QFUOyMzwuG7AB1V$K6GIV<yTmSd#%kBIB
z=1vRfvgb(lJ149A@xn@vIsfk7{~J4v<@des`=;Of&}JUOSN*V6JniIF4-MXL-~LG?
zih8ct;rn;XWxv%jn<cp?%Jc>H1SX|C@|ZsH&Fj8zZ_D@pjxFn`_z>D-m%HT%$3gx2
zpQj_g?)ayaDaU!s<IZu9bGP$$>q<LH@E3M(s`&WmOQ(O0l6TEfjWavylD_2hZ0ZY~
zYZ#<IN!sw&hxPwnt>0Ap>wodjr_<9H+ozwKGxJen%*R#-mC~e^yHmsCW+q)pRe7l9
zH)qCCTQ_YtCo{J*Zc4h7{F!67Pt53SKYMgzzxBHvZzT5r`?`Mf`A8L+<bSvO>;F9d
zJA2CB{v)wxCR*42`jWFG=Zj|F<moSdgEB#S=WPku@0X_UGx^Qqo@D+@WO3TzXWa2W
zoKlzM<aD2pR^dwicjrT|;Qjso|GwWm@%hi1g@t_wubjPYa^ZEsk(D?1uV?$zC-_6~
z|BPbGJ&$g6>xV0?l=Zy6<J$hubKj>ZPkLM)G3B}a|DQKYMU*3wpA=2`F<1P0*pw*G
zvpLSa^=*gO{n}s{WcjS=?vBFbZ%4z|ZadQP@{jkV7v57I?viV(nzOKGTH7bd&V78P
z`+vMoui3Zgh`7eb`&T6%%Kd-aVQrH1WdruupZLJ?$pq(1@&CWZhr4}uWqOz_|2yJa
zdxFi0Obekk7avHJil1B!YAI>DeLnj3`b2@>^Z);x|K{6siA?Fm&$I64*#@*HyCn1+
z=`MQIsh-xk<Bjj+f1R0pi_Xk6R_86bT{+oruIfd%P3x^M^?Pu+38{M77_7NC<JgLw
z-uin@ZtLgG?|*GH>2u(tvhN;Q$3p}r7M$_E(w~y3(rNeOAb;BS$Iosny_8h0OWqQ9
z=ben_WE;k5*E_F!G#q<->wVq#-P+H)UvelZN-w_fh`Z54sQ!tv{7Io18~s)M9@V~)
zR*q%&+HmaKzr_b1-<oe#nssg6hOQ;vYhP<_J6a-paedVGU+(uG8w=!i25zb3oWEnO
z^)30uXO%f678fjb39{Iu^fTD@k&#{Z#dEI$w>7VvJ->Rv^@kn7o9pARe(t;YXX25*
zi*qV(*8l&jz29E>r>y6eKfk&z9{wnN@{7&EU#r6RYR%rIbbtTF>kl`qwhRBFXy^ZN
zw|U*YFU!nB^UqC7uAQ>u-=kX{Mlsh92lN|HIe#g@PWj^Xg>S^?&;5}fJ>^Hfi_H$5
z|96fxGbnS)#|vqIva7=aQI=WeiqYCHUND2I_bqcB&TxO9_kGXuNin<)5@*FaFK86L
zuKSwXck`6&kLOo{{m<sL_pM}5ij+`ZvhUy5_37?CKcljJEd$<{7#5kjmAWY@|7*xi
z>kP~?Jf(l?oWx$MNwsIKERWPbsyZor(9qW9$kvNOCs+J2`#;&wYUQLiXTJ9zxgh`l
zqkQ_wlM&*JBb7D9o=yq&dpSAgY}mIy!i(9GpJYz?acDtUr(oyRlUG*=FW#x_DXHqF
zSNFnMew9jia%_#CQlOOTGb_0jN7CQu|9hnWtLE6EydJr;laCv!I;|CY+gJ9~bJi=X
zLff$Kd#j>#+C%4k=?&add2%^xM`dAl?Y7mEA2zR?Ex-TT>w=@8eD$jGxVZn-lUMi5
zH&imcCHnLryZo7O{@bq$Zhp-VP<gueh{oH0i?tqqFFxZcqq_fCa^;S7?F;47H_TtU
zu+FV4W&fY<r9b{&{a-9S|K}@f^Ftwu;8td;=!68_>?d1hgR00`N&@v8o^4+fHeX?q
zcVLo>Ur&SdIwAhw9W0SkJeJjdnmqqZ-rYXI@{h-#CwSTXv~yE;1GRd-U08YWjs1;X
zKVMwkVQTR#Ue>3Red!U7?f>jI?we?IsWx|sFZ0#Ti}MUG>3AJcO}dwHa`Nhr4J#!Q
zckZ1uUtK8K@OtK2q3uq`Gp=Y{<(FBtPI~d`&nf9&fBiWa^Kn-Hqt*B3)%!hKm|iGd
zxmIZY#;D_cDY1694ELQ_5t_8`SmU#wy|@1_K62vLjJAbgCvV5h{c(D7BftHhf?s!@
z+f7%!k@Z&kHCu4`g5)E=9(F+z^}6f(Jr1~Me)$~pKH~3o-s!RbA0L~`UAg=7#Z{Ga
zXGAHld%k0}!hAV}ZM@gN8eDmNq^|j=4)0fEqbq+u=|?GToOM2O_Uvct4c~Uc%9;Zr
zjB5p4YeAy|jmx;7DF1upGSNoroRIRON7HWZ@HO$5JMw4EL=I`6&gi4b`%dgwYbl>;
zG2<_Lu(?q2&yIB!2|;V^KfRWHAN#&4+^j$SztzNuK9%d=PI-JQt<GJ!-8S!V|4#eG
zEte;{%SEpLWp?`$%WDVEqyMa*be?>B_Twydh1J5nfBQpU*ZvpG`1?8}e)Cqjx-0wZ
z{(rBuSN<5c`pWKeMXNog%&YtLa%<W8o`7DK+8(K%$4A$mHtf=qJ0NnsMCGy)qpb3Q
z$Bao=Qw>U2e}BFI&KnEf>+e@r-MhGaMz{Gg#*TKiqcLYbJ`LV+EaO4i)U=yVPhOU|
zDqCB1I{IGF%u~wu+&lGkKdI#Gkze;ZaYvtU?kVrJ=Pw1=D?8uS|1Wd=i@f2XSV)pv
ztD|u6)~SnE&B5K^E{CtWhYy!FRd58VL@Yiczo@zPRLz}hQv7;d+gyd#|JPl2m9u|G
zs<BY&NB8_cJWG$rObblfl3#cGYeJv!=j>z7(|%2#ak#KLb;<8td%y8)v3+*DXZcO{
z&Y!a9EgttYuHxHaSKkm}vtiA|N&V~Y#r?Gjl-h15zVgZ2Rr9`Yx%lnr^@^UByZ18g
z--w%Q({p=zvP!H<<l}?Z9}_nI=xm8P^E7I1h_uh$##?ri3bT&AU;QHd$C0nHp4T)c
zUg2GyrhaKwrubzRmnKuY@<Q1o9`7nXg#Jqnvg>uY_E7!5WZ!E=KGT@vCvS(n-fVK^
z{E5DI;eU^M-?Li}DdVoPs6<5TF8bvRYOg5kO;9&zGfL8zsy=V~J%#^n=Tnb>BN|uM
z*S^hung9P=zP9p;r0Bgu{!`9R4*J;grAl=^zsaPThN=e>ytnArd-(S3>#cNUkA9@+
z>a44L^ZLSVhIuP(zuzg|{KQ9P^8Ziz|BF02m)kJLX-meg&aM1w!x_5TZ_R1p?LT!t
zGhdZ{`L)u1yE)VLu-%_(A650VzvS6=MEA@`;f>wx4M#7ZPrlW+zV7Sln|sb&JudBY
z_toD|Pd6RctV=)oex}4)sr}549wz+!B5?8e40o&lLTc|n7wk2=tY^3S<IIl0O@_V>
zDiQhnem;A%uJy+yCAmLgtKYo%Izhg8N1yQV)n6l}UZtn3`2F;MZpZ&L4QR-)-dTO|
zmEbjda1z<&V7E(G{^{laEnDU0OupWkJMlp0^*<+HZPa!1|NG~;{rT0o-%az@_TTnV
z&Ww7UKEL+cN}1$iJ(7`gD<)hFIAwZ0X0j?@^8N5Vk3^j<kMO-Uo>VLA<*aP^d8L1?
z*6eztJNLiu`_5antNqWO%1c^#)%_DoZfpOPS!sA``@KKYe;z)0sA$P)hxzRh^S5jJ
zzu;MxTe+#?>8Ytx+xdCZ{_n}NiO_RfJFn)`$(ySr_Ri?PbmsMw_0211zZYJg+7Vn@
z{agR|i>n^%+~(Z-*jN6=bKSS~(eM8{TzA@AJ1cj({gJGPhgxsGe_B)3FeAOHTG_C@
z%J$3q{Kdy5PvkFv<sbjH<KkA#f4>*5i1+zs{&^m#tmb%=!>AllUdA$KK8Wk3FHn5<
zZuR@UnI9h=z5PY?*@DyVJ$aiqrXTIE`?5Ia-qjs*ji3GL-f1}h@0;}H6{miJMkL-`
z`{cHadxmLt*smk%c7d-&Ztn81np=7;^5&=ce@@Qlv2f4ssp<-JXTJMP+H>lRE(I@@
zjO485iF(RcuP^+fJx6(`RG)GBIUmEIas&RYuj<cv%yRF1lGP(s_tHE5)_$*V3s!YR
z-dQB8{BDuUoJIdu$9-Lu`|9`=R_|##C$ELuZ%Cir<r^h<z2;8U{r?Zm3|-xRxOPsg
zY1TFTW#IMY@2%|hYcow}B)dr`ue&cHDaUzjMpeQBqZzvjdyI}`F4%YM*Pn+Og=eq+
zik*0VZ{%wUVKtu>Yx*u8+Uc75v`p;Nud}<3DIb&yc6D(w5ISktWa_o{B_mtbtAzE4
zYO!rsyxi&^Ja;P|_uj5id+fcyTW@E|f_Kr7aU(C)1eWZThn8*xCCUJA1-Ao7<iBjK
zdz5H)R`28Sk|{I3o4A!fQ*~SDcFDM2!+W1yeQ#jf!~>l|{5Ma^+lcVL=$sgI@!O88
zWlK&S6_20Od#C&MO?D~Cub^SDqSr4$t&kY8-Y=yao_DF-vHx?}KE;3G{o3z$FW*d`
zKi9U@W)jEWdNwJ+oB!ubJTlKbKW>|q(7VFZRdGr$f9-u=t6%$oS^k8ak;rRhMQP4o
z8iD`Yr1Mtz$O^uGx99V@FE`KEnTc(#^h&<+#bf%5YM=Q6+Y{U;>3G#RetfE5ZyDVe
zxb=MHx#CSv5B?Ee+}dyV>qXA=iVYDpo)`D8iQcX!Eh)#Jdg}E4zqj|N`u%mkbX0^f
z@DcZvj`S%9ubeHDcrf4SNM^&b^wp0~H)|M%I()4;FL=KG-}Cx&lQJV)rT#zJ|2!$U
zhwtqAMz{KK^V@oEKc2_u9C_dQW6n|2f(wr9xtC`{+VcnNrnUW&lzdh9ku~Pu@7I^S
z_1_k+JrbfX|NF-AOP`*e-d?!136#D$rUWLGNJ_6g3yKSe1yKradtHMzgmv0KJ8%F0
zPt@$T+`FK`HJyv1i^U%EKV7|Um)2}+)4bPxE-!E2`?f7ds^On{Pi2^S&W#DZB{fgA
z<0Eg%Y`+U?DxRNbC(n5{xzAEfw&;Z7)VF7&PPjif_I6HU)N8Z1tJm+dvaY?e%=$u2
z%h{~^1#;Wt;+0>1p1QtfY0<8lyxS2UkLuTLG)mG>`u+2Kz1>sgPmjVrRWw9Q*&%lC
z|G)3)r?>v=Y;XR1djFr(W%-tUwaF>PDk{pBKVJIRTS+I%aPF6ImEd35W!bPgx%Ab_
z<!PPkJsuo)?$F!w;ZV+!!ae8R#oUBGpa1{oy!5=s+r#ABcICahv-9SPw?AUqVte+T
zogXBpyz}|_`SFHwZ!G;RpH9gs$&-0sJpXr0+3Tu1d9wZ;{n=K_6gu?zAAS38lPI>h
z@^SY>2~Y9PtuwNXUp?Je^Lh6Dn9O4dufoct5*EHFlv;4}=BpobMT*xP6K4mF=xz>N
zVHkQUzy9~_H{A<2to2I@m)FjdKEM4q^U|c0<eF)ZX7#m1D=)oSX4qxAujhn&$o>bc
z`YS4Z`M?b)o~N5lrkwXUlCt9W+_GDlH{Y*SpI4zYJKScObjQU96X*1^pFR41A-CR+
z1rs-{2G@ctT)GJ?*$WRZE(FDMfWN}O9X&@p_fE3+w0z|fr0w;`@c#ZQx5Y|7znyqy
zRo$<OoNjxu<Rw{mKFQqvJaNm!HJvSve>Tc(zj$ohp1s@emPPOSdM$c$Y5Kg%XJ*H1
zzOIg+t7Ism>h}0;M(5{aKNml#eOZ6T=Anr4j#ch6pMF((DWc4~c+WG_^($u<oOu22
z3}_fyMOXRb-2WlxYoqqA{jYIl#wkVfdvX6)-`=rzS7CKtPfzVJ<9QQf?F(NQ_5ACa
zSZ{d9R48V1`uTM-YLCP@Z+iSWu6t+VjJ=QhtT(+jniQd5dD44RCeNqWt2ZT|cdE<1
z@~g*XZ%ysLsJ;0*&wn5PIxqh9-`7Xp{{P6Z-J*Vr?xcke#fsVM|2&po|1;I8?oQ*m
z+4Germ0$e+<B!WB{Yj?^yUTmhdRGc6x#?HmJZ&_)X1;`>+_8@d8$2c*Uvb}K-7$@`
z60I^Px9;ItmiH!j{oS)Y!FBfv-v0ls_1=5$^_u^Udmevxu4xq5|M(GihsQFvMJDUE
zm+$|5S5s&~Alt3~Yx8Tf#on(Fj(4;9@t|4L%`<FzRqhSJ-LHyyw#WphyDYNxiaD-d
zb+J1uO!m#!fX@oH+U@WzdKrJ|eu;y>Cid5;beG5U7rMLq@CyFl+jF0J;+p=5<J+Px
z`|_lu*@C)v0vfX%+|R%5zI$=SpKra3OarRH<97!NI9;5yCM9isc4W<VUHkfZ0jtf$
zldp8z%PBJooNU|UvPn-!@apelFV=fF@Jwmxm{?YLJLk=0b?Hx!d7qlz5;%TFn0;%X
zAm{oTmuC*QAM-z~I=*7-eUJ6hef#=KW=mVf$1I=tr`sjJ$7yY;?st2?c?Y_F{S4mw
z`})cI`R|Jbt{22i7X05Rw4#vr=(bn-=8t~7uYF&=dE4<43H7-pL1m|2cwgy{?)-iI
z{B4o-x3j}b@4kBK;pWa{KB=d0cKIKkkVl@+C;sWQJI3+0s#xAUs@&kM+&K$ZdFh|E
zrW1}P+>-5l=`rD(dH0TE@3&QP-g{Bp^M(KQpT@k(*=(2F4&Hcr{QkXcA4$R5j3?jo
z7hga8?c7c9sOOdayv;v*Lf%_X`TJ;A&-t1&i(~)ZKlDRL``_)5z3YC(Oao8kI!t8!
zWc^qrqFY8aSJ?s7z+~ar(&4anNkDgruQ^B0iiY!-I*P0%!NI>mdxCm|uVBFRlWw2}
z7pNNp7Kbr-bQBI+ZRphn<w>Ynh{@s=+6o7wrXPpvY<wtiLO#Lx!kx8;3;B*KT;OA}
z^L{IkTB`z@T;0Suqj_tN;N>`|Jr10#j~X363e2xys@=;jKXpU)ET04y)|zQ<Q*NIG
zCjy7q#u~nB7fZ8mdO&<3px}@o!2%ivf8?&{kZ_!(W?I>q^Y_4RTOi4_j3c9MRk9Gw
z=?Hf!To7XtT9Yf7HW%a)6#oe*I4qE45?XUMpwtKIFmRm%(|pUxp=qn`p*54imcX3>
zVVF2OG;Nh!)#nM}!t_8K9}OCTcAZf=3B^3H97AIohsOpp=c|U`2t!kl!Oh5dZ5zjC
zKde6CVdT7)w!%sc-4`Gy<SHs0yd{=+%@dnXW`QJmLXTq&0$moBh}%kMtg!mTm_;RG
z_QF??nM{y9NMW(1wSgr&x+PK_t54b*Sh9^nWGAEf5EMg=+XN;g<aQgpR>9_zvmnWl
z5t&k}USD7DAH6MS<;K+4t8RP)O?RyoHkDp${-84l6jJEnv)}^LV(z=U=3dyLU;EPg
zWt()KhjH2&kLPpC<K~Omd^{rjvWZ*IWBa|TY|uoMlzm-|)vFbYFU?G!H`A^6)!9(<
zsP*R$?uB&7kzx{*6H1tb)`Tklew$xETQ&Uqz3TT{GA}P%rK?$5UcS8eysf!z{5~7+
z74P={|Mzm)>^!gO@pYB2-n{Yo{QUg+S9pw_!nF6Wp7+f^53|33W=mbgW2eM@StP#n
z=H~SL;s>tXVoO!Mr!6r)XQ3=xe8w<ye(g8U<MQ=2RiG*1b-Ul~+EV!VSk8R6*SW<^
z+K>!{8YUWZ8(3aXR{VX^ziv|4x|o@u0m!R7kD6GygWTQStsZqK|H`p{v*B=%52rxq
zRgK<juZsopu^P0rL6fQK(6*|tuS%Xy4PQ3d&q~vGp3TlQ1^K!k54Rkbt6maYc5~_Z
zZ<&{urM`bG5h%5Gdg#5zdNKXDJ<Qd&(U-|&gf>=wezrC1`j>78Mb@5#x16U_r^ilH
z_3yWSw}Y`+g!9V3lUG;FSs%SQ&39Y=;;(Erfy~nD_I|sSqj!UC)hfsk6RJBMgjsLZ
zv1IqK^je14|9Qxt&c9mfMAhkOx|+{2-^RQ3-kP=eT)gz!>;EmBE8k16T)5(9J7(rP
z@PTv7Uyf_t`ui-7+N}EhZg+mv?y}r(m#<!(suU>oKH2hA-tM>4uC0yU-dl5Kzm)3y
zs0A0RZp)nD!d9+$sb9FJ9ATb!XU4mIzu)O(<X7Lmy^S+&P4(T^ano&oXbG(_<UIgd
z$MEChW9`!LH4zha-|u`r?`HPmuUhOIFzOTqhX#jC)>~Ewt;*iq`0}y8evgrtX@8Q<
zhpeBUp1uT)lFc$qcH3s<w)0pB)Al<>-d3MZD1Tm+`S4Jy=A_ld&(27O>^;S(gHjel
zLm(ikahu-;w=2)i&E4($;gQ*Y!{lR2n)$3&Y<m0QFu#BBG9ORzxQfJAFJ5?DUgqn~
zEv9oqXdNhRUvqux_Bxa=rx9upvZEU>ac!w>+8XxcQDf*&=hdIy8s7T4SpIK@)&D=A
zFN^R0arDaFyK|TM&7I|E|Mv@MamUlEL5sg?Sw~>a+FO`pyTx>0^<Ar0s?Fzl%ozUB
zxT@sspW-uzrTDjZ39kL>wfO5R*~QnkWv}0B7G3*h<MC^^a%53+1H@oov4}ktg=KBG
zB#)@g-}9n<y=l|dU1vW|SpAAUHZ*^AT;7(ruXd0I1DdZi`VXx5WD@F)twdJ{&|&1f
zmUPrP8#P%%jL?|az>?kBv~(qEu>z?wM7$lEwnlusAcZv%sVE$bT9lBfh0QBRg(f8E
zhS_XsgV+M`AJmFQAx@7C(=;Mxc|mMJiFb#MEGiM*qWo*I7IrR7LTgmHrY*x(&5nAL
zLtr#ESvW=$Efb5^Xx?NRErJ+EOInA9(F#SuVZms<Iob+hA=o@fDA_n`u_?<fpM=xL
zri9g~E@jvAefjZz-rGM%(wCULJ*#=PqS|Zmv2Bta?=Tu*r&JXVMy;#J%+==1*`dGm
z{+?y(8>_tU$E}T=5%g!xkL^?V{?&OsPWyWI9cI(lA(6#LFknVNhDS8#krP+%@2R@|
zB+JxEB~F=9x>OXS?b+zW<*`A`NJr}GCniJP1CRILt20+VDTPa=o#Zs#=xs~d<*GD5
zt3X%o-d%kl;pn!1_ROK@`X$$MHQF&5KF?a5YEUX|yQ~V@Mn!7V9#*>Wt$2gmr_Z<V
z|0~<|Y*zNAS*F=WSMHYG)}34T>*dQ8i~C+R*L=H~p6+?WPP_VE&7a5e{>9JFtzA?1
zs8jtCt9Z<WyuDwqZAm=bW>WX($D4@sd6j8Wre1!#nXaDW{>i*n%22}Ru3O)7J|s&a
z&N#4vb4zVg>CH{4FU9x&aJBk)MELTa%FmZTD@H++4myrj>F4H{)c*Ry^)0#Ic3Pj!
zrxPV76x&0t9X%90@6(i1za{Qgz1#VG+0)b0mwR9x1XzD%D{|Ke<^+eGthekA?mBPx
zd&%c>*807&)@I#L-rU@L`PJ3cm&5n}y1J#}<0CuHYbyklL;G#N-B^>iwq8s(YRWX7
z$VvBpo-1DlT0R>&)#CWw^80f^;{heNGM9&*3(c;7eaj``k#SJe<_#Oqxy80(^bZzH
zV9KrEU)7^^cJk`VmQR)u<u_BO*MuHk&n>3oAuB8UvO~G=#pd&g?XuI7UNv|e&|<l?
z#oWBlV8*Uq`A}cX#F8kG@mp}sUtal&2aR7qOG@8vy&m`Sf;0cy{g%7G{tw^(E3~UJ
zD*0D~=VZ07D?fiY%)i|B+YRNf{^$H=o9V6=U!2^&`Upq#(m71Bck8EoldTPqx?Wm+
zmoMkV%FQ`%<(KAdT=zOf85V9}?|k7pBGSRd$fT^UaPU_0-jbJ>N<JPHPgnMNzyJTg
z9I1xQ=d7}4Ph4ww>1(?E@5o<2&)3g;^f1CO=<AEc{pX%V$(rZIh;8*)@XdeSv9_An
ze+p~YY^uK%wqSR%&#wGe;g{A-&6hVgDFs@`ge}b{ad~X`b|e+FAXoRVv{{Y^Xl3`V
zpU-ArPPh9!^UJ*Nd(@>*&T4=6=kt00#qRy*gjQ>Zuk*S8|KIn^pw)(;G<xdrYNe06
zDnCD~nSSc^ioodf<P-7Q(q#z;&4a8P!aHKC_XXZ5^7hi+H|f&d`q@F(SFK$;>%!)`
zYmu3EdbTfTcFUbBy+h#aRSwM9$Yr@z$9GMjGy0dm#lx18Q<}?{6rZzH2ThK8oSvrZ
z4eHFxZ;&`B#d%3$r_}E`g~uc_udRuEc}zNg&6Vzz%-7aNhgZ(mKk{dFpql@@IqN@p
zDJ=C^aPHUXdEFnbYL<R!IC8#D{^l;fqN}19LophA8d$P>1!QYJ9L#*b_q(6>G@X?j
zx4vJsGI;qiiJ!Bkdn`C+!tna~`t#wb>$StyoQV5=r}(_x>%EE-ID6K4?J4KIZ?m@q
zvxhxP`@%QQYde<iukU>F0+b6?BY)?wu9H^|t^fb~{_>lf)5F8$%Wfpz6k*(c=Th<O
z^3cc~1&LixUd^#AUUe-><--z(^wOrUCs#5(K<NpClaff>g165T_I^60ecAT=oyoRq
zvYwrpsVNs!dNnjWRXHI3->2!}Och_RhA#)L+)lTB9eFeNAHUs?gs^<ju7@X+{nuTw
z{`2ARX3N;*s>T^!3AeUnW*%%})r5|cgla`AOyKUhXB+=&X7^Q&YjHf@kfH}{JJ>yq
zN!(j%o4!__ua4XG_uK7Yn**zM@3!s^yYub;w(Wa$LBoGjUmT5DZU6VBf3Ql_XCdYA
z<bBtc+rG{Gxk}{ombx#C<<ItgKdN76Xq_hW{>x>5|KqadF-zyMGS#yD@)1m6$(EPK
z9NA+Pdl9iEBXC-1&Uf`o$G0%_+x^PuY7cq4>-9S3Hl1aB6@NY+4_5I#-YadMu=j?*
z@t*c*-<d{B^Y$Lh+w<*K_U70=+iy1xzFSon$SU_I&1?JoU0X}5_Zlu;9v^pQT9!CU
zeg%2cq5r_6qus{s+vE?<isyZNyx-qA?aYb$d_Sx*FD((V@10_i_D6$dn|4B1!&{-1
z7)7SWB8S`dPgZp}UR-7-^5XLZ?cxpF9*QnFjTV>=o~$Yn-clB4^9&h_H*AY=C~Zds
zG}uiU;*6Zv$~w2yiA684I=Jg5$F(GO@7EY3H+z|c*6bCV#_`66v3SEfo9c8mbSJ$5
z?fT(+aC7Q`4V)!@Z!E7&K0oL7CcUM)v)kTY;B&zkdbwc3$a(GAO)I0ugPc9{u0-EA
zVFXzK3L9i6vWiVe&@Cu1S$menNBBY-<MmjyOuj%Av`$K~>(>P-rmOtBUVU1y`WnZo
zICOK?>M0z&^-A#C{!bhwe(!R#udlk7ijnjfnOZ>$9&<8G*1TouNyyzj;k5xcln~=d
z0d<U=*FGH&;E!@$P{kL<zcXv<idXDtiY`225?Z4xmvC2mVuK*|0i<nQ9vgNEafrAc
zkXhr}*;0n?UKS~_2?@C~yj+=l#a7HyT992j+5g!GwCH7EWIC*<aL`JotIsjPf@Rfm
z4g>br1szswXzp=9>@DNv3Q>>P9cH>?au%jx*1--<rRlG%%^R~AgIPkdBQRol3TUoN
zB=ORTZ356#=XwTX`buMO155Tx=M~Jl$^o{n4VDqnYHO^}i^nb78d$QkkB7fMr4leV
z!IV9Frqc4YXijpF=JwdIt?)zX-UOy+3AzyuCg{mmVM8q==e4)eD;*P3SloKOS1x|8
z?)ClHlx=J7?|KuDmQ)%T8V`Y*a%Lt{*QPNo<IFg{;k5}`PzA(+;`f-}>FB@%CX8z(
zLTk~tdPYS!G;M8dUY)Hf^1`^Ow3O3&!AUfCGc<k^nvjsYzT$Q6MOG{I@7p$HhrZvW
zis>A9%W@mjRpkhC>4UenU2p6IZJa~S14{)bB<T9CFxjHZat7<<-GWk39#EfFb%_gP
z&hDOs+|~)Nz-yzC($$4qOhRkc%Es^2p50&>aazpqttwh3z7^xpwDqh$!(IIu4T5V}
zxjUXAX@{tN#qF`-+V_o951il%Ie+k#Vz_el`y34KD{^>j;A1?i$1+RpLORRqRm<ic
zYs9R{+T0zQN-Jb!TMvBT_%gHks`I)w_N$Q1Imq5WD?A|~civiMVTnBsUqu*Wh1N8)
zZ$Zy;4hbo&DiQA2Zr|j%BEDjt(gB$@U)ScKdyqrK!J%m@gX0AjCeg-MEZNg7BeeCz
zFiJaCP$`g+V6xhm^_NP7e0DI)UCf-|?$ET=X5*zxWdbiG=3ZLS>Hn>y*lYInZO-ez
zPDFM-C~yLz7&)(9YV$iB9k$@SMi~FDteY0ECD4-I1tCzWA?P+YL$lG2Gwkz*Z6P_O
zZD>YiSTb^6o5sD8Z))6v;-Y-<T|EhJk8Z#yUNz=5uw;KsTIBjx&!Fl%C{4$4V-$Cd
zOrYFgpfT&pGp4J-EIDRPThFd%yQ>a~X?Un`=_wqH`oNGGC(Q*aJI)-u)fV2Mhn`4P
zK_l>i8%(zPviJyIP;0z~-Zn-Q)KN@wMOULfUXe!25DS*FszgLv?Xe2?Vhm=PVw5B0
zi&kxHS>C{sU41NeeYZ})+=Q<aRx7!C-G)09#_(*q>guo{15{*0xop8GG7J_pu)J<C
zF%!7q$@DDYuIC3oZ!~KJB=$70ynb-@jpKryppYq9oAqv|%v`jnP;f|SXHkhL?>K*s
zWtIY@5EE{Y#hA=Ds9_RXb2$B_2TPm#0hu+2AHRUCV})9p*z)@)>?{CKJ<}*CFd;#f
zF=e@efkxxGyH%^obMB^oo;79HcAl*AshGLQ&Cj8!^vRmJoes%NvbOT4bxulM-5q@E
zPek(Xm99`bK;}YHn*pe5Quce-!XhPL;OoHbu?i!Lm+fm{d3~<GQB2@Q*n(e<;jyc?
z-_7HNXh%vK4vH))5!`}oy$Ton7Zex0?^+kS_w+Pa9Dq_iL@^hrr@o>fgQroQwI`ue
z6T?0)MTLV=T?Uycw>d-3AKZ0QgfUmVUKTyWd4V?j&kD%Qh~|_ycq{DTwMg{TvxiA&
z&C}kw)3$E{RXLWsexdK+-!h?rC7YWyI6TVZ0LL{ku4U`c-2z*DzWo!|jOML-HeN15
zw`4776@=Cut7s`k<p^(KEnf5@=2o;r)7HI@*MD~vHDJ#UR9+m52ntBxG}<u<t*N!x
zqZlC2_)3#$SD5&cz*&wMF?At6q2#~lJz<3a29Po{?+s!KO0&RWnya*7Ww!UOU-j?&
z?RURi_~rNS>#2L^+15H$oqSlmG~B+vO3L`wj~26?A|<eO6&E%%uw)+&(Grqy1QmSO
zR|(o|3<e)m(D+TXqT*}YmxuLxZSU^<^U;o@Tqk<=qv!7Cb~FC{Tg$%GR=xlA=DYCB
z+W1ZEgJ@0l@%Z=MS{Kw0X0c=k9$o_W<OM4x!=kUw|3B@{owWL@ZO@Txm4wCX5EZ|I
z_=JSBs(XYqCOJG`XS??0om-1^ZMUnJm5Z({y#-Mg<)^TWbw~EmYnqI&O7$kK2@FTf
z%T3_+*zim!j#I?<fX1~&t}ftZU<+DVlg?drJDu>#tjgyrB!C&2SWbbK9o@T;S-G0~
zi|2+}?OU%NURw`}hz-T8pV*^JFLfQflKZ6M6+8h<0Y%%LkC%UiiM^O}=k{*B&l|oa
zMWEOH93r4n-(uqhA*NbZxA*sc$2D!een<$MH!_+Iym=`sW%nxKm03*y;=l|qkW+45
z$gDWc9pW#z;U>qmY5m*zKm%F_{6s5GKCCva`FHS2?vDjpATe+mGbPNSY3r7Smp@Ds
zU*Wf*Y-aP;r;pb*gPkAD8u$0l%gl3UI&bG5K4W`q`HIzWKM0&)Rf#C(T+h;_mcWM`
zLdSaKrh=mKs{f|4<y$spd%wDMXY&GtzKS4+rmIUG7OVgjnOP}Yx<Rgp3Q0JB^6{mg
z>GG5QJ!<)T`SQ2BroHmkTE8s|t{pMSJG0`--Ou~m!}EROe;>5f)mjh@avwN(ItxnJ
zPMQ10x#0i@M~J^*0^c=3hH}WlfC)i8DYg$^%)IHp_4xU^uL)M)H>uuSwR&Cr#JG|d
zaxWh+tA&Se^nvAt3(J_?Hf+m$P`aCi=_+Sf@rG#%3A4Zpz1He{n56v8?|k*IDPH3C
zpU*DM{Cn)|)bEI@{8qR_)7IML_0L_!4O|^ADle%8IqyOm(|fy2zgZUhj9-84a=*5`
ze($Xi#@sT_7kc10RB%|ZtbrxlS4^8z#NmMRIxYbgUr5=xm&wrmb^M-x4X3(hXg#=Q
z9Ugu!8Y08OA&}wE$a(Es&+fSCjti=~7>YMcQ%t%Ac4w}_hfV3<=W8W+RwXsBWV)sB
zWfxeSg+o9hz@e$sK}wqAO-kb{merOK<wXW_AdC0EaQ(S@l6_fh`Aw_P1An#6m#mNd
z`}<xmqHw+C=g_qEt<$>0O9c(svooERE(H57j;Y#5YWBTKr>h~1=6B}jMebU)SK!Mu
zP;7#7#sVdUgHa1NI4nqDs&(5i>;Bq=ix*`;1zbjP;|#3_CzkuK)Tntj+xzmaudyg$
z2}<;}No$v<3QL&UE$!PF9esDN;!@q$r>`+X+mO1t0>P|r%o0nk9cP!nJ7HhV)w{ZP
z<LAQG77DD;RX7-R`)Cx?Q2~RltrCS7Aju)XIU(zO2;+OJLci40{dqM8x_|DTI#taL
z@(nmCy#=jElPkP-dK1@-_N{9sUd{u%SGX~G{?_!W!1MlbcI8JeeYvsA_h&R@-wY`2
z<SHl}yv62t?WhnpsIylyy)vTOPzO@lJ>uB&`Uvx-D|e5j@J8)S3%2@yyIgd6VHBkN
z;Sf-`P{PQ0ZJDq&W23CV3uD)Y<-+e9mc)YVU5CpoYQ7Sa|NZJ^59_OctINOq2co%p
z3$)VD_R*T@siG_VHsqN#ZC#Ui1>)S=#^<)RSyexazppF#(j9(prd(xC^3%PnAisbT
zQR6ky2?@1E+oHGSc=FqR38;E9(LJcVy!>v*^U}v#<1)9z?M=RM?HSXvgxt^E4&Om;
zS>VI;-lp!qN$#l~Yffg*d*SswcHa`8v)9AmW-4;^$UUml-5jmr2;Quoy>6%4+Q`jn
zudjnv?tqt?TnTjl`trH3zs*Fw9S@pHUa#H0j91!h$;ZdX(@W3Ud_H566_USh*Tt$@
zzIVKhQB2Pg)-Fwg45w=>IneTP@#Sj&xwG&6etNrV-v<Ae_3tC5?)!dP^yOCl8G$Fh
zWr;wuRKtM}9QcQoCt5*=m3^$-w$7`5w=?tSr>B}itA4-VU%%_+ve}oOPLH2wWo>==
z&(F{7q4^buo@?mp2iUqgOt*}Pw!3Eq&QeRoElSQkDS2dQe0l2sy*95;hwuOXyX3~5
zyO)E%-CFvk_A<;l42`!yi_Nn0^M7vr{bsYj)%!i4FBKk_ot}1n-dsNGHyggRneS1|
zy|>3wH*U|4OaIXqpJ{%x{`ceY<>L9j@08pvy}q<pdi%MJS2OmWYSa~2p$=&W+G;|Y
zr4ETK=W4FjWq$j@8CiWT|IQ@4+MAEIRC@o_T)}m@f)`%7No;Yrtsas5<>ify$-fUg
zE#B~MllOa%W>#*oC4GH;;KNN;N^{<vA*3L*I#6ou_2&xr1SC8T$gE*L83Eaj!li9c
z_GQJFM)ULDi><9Uncdr%le_E9tZMGtalG(sc*C%9+kB-3_V=0jZ6@sdefRycz29zW
z%T~QuIQ1-OQ{=7We%qkZOQvSvvFOcJU$3d}F^^hb^guRZg<Rrp=Jt)*jjUy{|0`zw
zO!<9n-7bCI^-`g+57M%wAc1>9`NJz^wI!?bYHT*|c%uG&*-PPTOa6Y7I}GW@n8Ye9
za|q!OkN|aJ<X$iJp1usUz)ZTc>i^&G%Xbz(U$*(2)#~#nu7L-m-DZ3${mHyZYOQ&Z
zV%ahy?wofwwqE)Zc(*@vnl7~NIx1fAa&wvIcHP@E-tDOm?viBE`?cQmWxn5>Nyqwb
zT5a0;!}fv`JV&^(s6<pxS>`iy(%oPC6A!nQyx;qM+3fs%mbK4}=X<`dJYT(O;u^-C
zsi&vq#9jNhVzFE9+*HN-+%0kcAM-rjo4=%OQP`&1YioQnpI$Tbm)NaYEf9UOYQatx
zaM`++)$ZH!*OzbGS9?coPb{t~`1-8m?0c)ryZ!Apto1E{6zl>D7qXag?b)+gO!EHP
zKWq`cq`7>~q;r<f=X`18uTcOUR1sV8uytz1`)#-LGVksxo%;Q!)0zEJsh^&l1g(bK
zbn2ht2HVD0?J=dfbK8=tci->>m3J&0BJK&lu6%sC##|;K^TJhbIS=l--%qwLpSl%M
zBc9SxI2ff|#V%h{aI5<L-pi9zy|tp18>KEYtcl;hZ<C%_*qVrmd+!&Yx7~c*?RDzZ
zzs?EOOhRjJ3vYsSd_>|Nq@KTLEnECTZfe;)P^tT3RxffjaY`3HFs<?mGBEu)w_Ua@
z!p!vm=$w%Cr{cu*VrD4q1m*TOwTr+0k~t#H#LQWeCo4HO*Q}{jLG?ALXlrnI$a>B$
z)9+UDr5kJJuD+HBD%-Yv$i3zOkI7@;VSVlOdyMWDpSOMaVsXD8Xs6l739CR`d!$$X
z`ZRt2o<$Wu9=4|!Z#}k!QC3zq6Ky0KwqDP{wlUDwUrNq&VY<+R8S@rtFFkAPuk>zC
zL_R+x3o|q_arw+LP}}?d%FdU6<A3H}+ts?=e%8M7!(Cr)Elv~Juyq!^`)wf6*yq|U
z_SNRH$=0`ri<Nd(U33*+dbC@7`MY;LO1^WgOy`zd@_czCx&Li4=<K3ppU>Od-z~i!
z8+mud_gUBXsO^0ux?Un^ubnmTqqAGD$IZU_?*2YU8K<j8oPW-rnPQeVw@XR3GT!TP
z)je%+vTJbAWCc~WFYW6#+GPLUVYv8`{r{^AGw)~G#xK)?C}Ch^S}NR8lQd<U|AuE1
zyE7T(YQJ0*;a_>H^m^>)tETab^K9;9otmO)y8XGf^xEmy^S^{PZ4F#0wzB-Oqo!@)
z@oVR7cBfxCePsD|kK-la!%{f5%s+5!o$kvu^}kAYRUf_9zFf{CJIU(*8|O<e&TX5&
zbM;?6Hd|;1&P#uSdc<G*o$Ah(b$@=CBp>T}s}{bv>dM`?qEdse^KzQRnYOapyjZoZ
zdn?$v3tE_x-TS@jKR>I?JoBP&%~$XD)i$v|4yUTV=~ROcIy_+#TC=kyoXJ&GVsCZ+
zX|wh3Vz)tKVM<WKe@WrX^Y^BeEq!}`*SCEor!R$~q*G9bbX`Set~Hm$!CQTS*V94i
zDx<JbIL<=Z_V>!@{Vu)78ESrQQq4TOYaV+PaxhLv(2YG|vg0j_mHPLxou^++gH2#8
z*uw;xEZmzvYqpxd%-qsP53fpJe!hR}mOZkUV4X+@_;98QliP-ADgm<~Yw6k44N5QF
z_%bi}Sy<Vwch}r6^^4gBROZ8%k}i+|^=vyPhi%*3U>R}S^4BkLuGiK3@F(5JcYW=_
zFJAilzs%izsg~b95Lw?3CZRP)`zMNR+ub0z=4~D83wuy8y=BLN+wtbsZ+Cy!i`2gk
zs*_4jKH5@QeE!H9E|5H^Y<19NQHk&tRO`*j28~4(Z`k&A>w?dq2)Zzd>G83WW&0~n
z?=ji6S^4$-N7dJtb=Q^ndw&aE4k`&j1=3m#g@d=c0<SK=CiLR-gw<EqUNwiUCO2wi
zPJcV=-<Qzep(c9&f7ZUd?)|rXKT{ISw*d)^oY$Dx-7j;bFg;5sRRp<)p>dml#Yb1;
z%MU-RrPscFH&gM!ozr5=O<(W2wdg&3LxRTU2A1rZi<iHBt9T*3i$OW^mhy`#a0tKE
zxNz~}#Czqh_LyWoda>p=|N46~K<&n|B^SVP4_Z*X669e~z201JsE41LF1QT#uo<{j
zea<p9Z|VN)|DR3#a=4X01gZ58A8TXz#TDW&cp;S~J6`5JI4B%mbK3lu48EKlZ?N~$
z#`=HfVqfy}+o8l!1SpQW+OL5ITZ)6u?^^3G>NorP5|PQ9peHjrcysUhTe|u3zRP7N
zf9<GyJnhR#Z?UDmvC&bx&Ranb*b>lK-N2F^sl5E|TjdKEKO4Ti^Y!GvZ+{X+J;R_g
z-Wi#Vg~?Wz+wXn4VzR9G_4GB+Y*mfj6x9nmzjhvqT)z9v;ahPBuSbJ(NO&W2nx9Yo
zw_7)-zN>$I>*>p7NB`A3upVK8rkVu`OhRi|Ia|^MR%l;%?il_oacy?0GFUQ0vGKaR
zt+DO*%wR3sUtdzYFTdJ4TkAcn9%tcrQ^Ux4ZLU1CuEK`e##ijIxziHv+RcyxMS#PC
zQkHX-mm4#`#~x3S1-03Ky?N>#wY<0r)@ILOWaPXi#<56mOQXYl!8LijIn5ofmB1FS
z;PAPbn^SdvWwG{q@jve_mR$X+jbd*M$lllQ->^stzc6NBEx4w4;Y!G`S(N(&OWVsV
zdmhf1IhC*WX?6MX-QhNINck(_Ij09?GVH<*=*V>M;g#SN#}eiKVD0*Q`e$EOeh8i7
z8+-R<@N^wNY4hC7xqPoU!7fv9Sg-`NyqI@R+V+_s?avZ&H$Qj{>4@IYGD!Qf;>*G9
zXS^RD%lW(i!~XsCv0W1p8T7z8(FqB6cm6x)x4;lIpflYvLfSbP+;QjFGVj2?%W6x?
z=WM87ntXrn!+&2+-<DgsXS)L^Yl1@5;1iS38s+?VJuGbcpdp;DhJ(zvpe1|Xfz|zU
z=EYTfkekXk7gWoCc*Tocdb))<G?k|8o!fih0?V0$Rwm}vkbaez=#SUtax=c&s?E8!
z`?%bDum3-KRWnaddnfjGZ5~(&BNIy(s2lj^M}}<UTBf;^t5we&yp^2@Iks)f$^&`A
zZp-=SnCX|6<go6jJo&2R=+^IBSGMKBO8v5Rpn=J+<z-C0oL^>whWHV275!j><>bqm
z`n6t5CyW0rh>Y5j<NFk;hc!`fLV~Phdb;9<WTsl7HO~_68v0a&4Q{+9_~Y^8Z@%nr
zw?|)Fc-A(UrRLM5qnUSqt-JPe!8~yB!^p(qrJ!&ys!1VJsWF8wOq>xCg8|M9ibLFg
zJ&1m`wDYm`=C#^#k@L^}@86wuWlI;l(;W%gIyR{^hUu_ofGvCWbip-;JzqzFqQPOo
z8>Y+4`~1`An=HT7n_c%c;Me-ua;uOc>H;WrKKo^5)%Z~G#htCsE&S_Zwy*JBS^fEg
z%ynqjvvHb0#mB_zrH|)rE?=r2zvI(6k;RelRZNY~xIH$Q-M=Bp@n(mEjna<dp!bD6
zNpH8prVLV;()a#rFv&ju@#d#pyt6Oc$86Hby?4jA9q#^<pkpc7$|{%+t0l-?OI%!{
z04fX=E_5;N?s@G~f7w_*`^;&nr{7YuFYo`K5~*DlIv-s2F)%W<g60H5EKJ%QWE(F|
zt~Spz<ImP_Qw8gHP!O+pWw(2&edX1CKW~5Oo&Q(y?=Qdq`xhdrf(tB+oY&MASgABF
z;{eS(gqc1S;e#&XpA!GzNpkwq!_V^mCT-iD-quj8A3NvTn%7$O$G^amc|ZUo=d~s_
zx6K?m%AjPfa>~pu3>u*`9o)~~dHdczH*S_mVad0D;Ocr^gcHKwo*;iWl}0cf*1NE?
z`n{s<lU1;xK7|dv2jnInTUP8hGdi;VZ+_Ua)#7*JkxPajEGiN0=Pym<FbQ8!1sdF$
zo&EL&B+gk`=Kb$k`LfjAcm0<qr|<8y)~!y6MNX;@K}l84-CglQ4P;<w_WQRyFunKw
z-THg^%}e1;^Kx!%QLTM7>1bx~^=V=+X6ivb#?l2ED4!FN!P)qWX|b<hfcy#Qn81Sl
z2W}WHzQlgtNWWL|?!??(#Xldv%(maLyx#OZxZMqk@-hd9rc(9~Z@dy*Sbz0^rdR~G
zmK%X%EFh`zZ@Q0<;UrW2`~TiQeOdp$!leE+d_z+LJF7}Wxxj^YEN(ua`GA#3nOoq-
zx&t5e=S-aU{fp+*s`)>kP1=(6b{X<OkF)rM1le74Z8>|^fQs<dZr|>lgO1-%iF+_7
z_}Mbe-MuG&eS9&?_vL0=c(tbBkZ>Gi?VSsP96db^mJ#m9ZbpKWpF=m-n|-fmeEApr
zJhW>2hi~qe%h$yt*SrZCOhRj%i#LlmP85G(+;mlDjj}vLI%MnPQ*nz&D|auS9A~om
z(!}+3@86Yt?>erHR9*4JIW(1iNc*O+p_paW^MtpP67E_$7C-_zpsvxr@@ie?xiy`U
z?q;Q>%l%_FS>)c?vh<JaWoB?lIy4;c6Pf^-dP=we9*k=)y--&M8Vh1%VliqoT<pG-
ze_v&slzH0g`And)|JSSU_5Se0na}}pd&_3&MnUlxb0!2Gzs4TC<lR@z+?y7Ud<&pG
z-UX&C-{zVr?tT2@ulC%XtJ3wZwQgU(2Dx<E(ZG`ZI4n!(#!seYoHu?NUI3pxt8hVy
zX?@+lFJGF{{nmbYw)uX{EV<an+;_M-U;|bT%}hdTc%4?dEf8Q@#;M^VVbTOjI~-fO
z4piT(NC0=-tU(>Oi7BDr$N<T*sVf|`ve4hk`6j0E70c^1{$00r9xNyW2S`9&qo?rk
zCEw>-ZND^8`hA5-?ekqvk!zi8`U(ek)he5UI=Wxp?ah5T32EAsC-lLG%H7K+_s@;I
zX)9MD%D*oNZmSe%^7xFWF4Iwg6><l)4o3CN$Y2GR-WiOI#_>DjXBlTFU7HN8p}nMc
zZ`<N<z6917y#Q*JJd?I&ZhR;VYRHBjE{}1CP72(LN;vZ(@MUxUyy?fj?Qz>#eRS8C
zt@Dtp=x?kl5!>^Zur)s72<ZncaVUJWNEMcmK~eMf=j*ias!#IQ*LwWl{^BBXe%Q*Y
z5|O<-!h69C(3pH$475Vo(s3ZWf7ZmlnqO1A^6ftNs=nNK+&mPiF?s`3Jx2>?bBI6-
zo^EM%UC8*4s#wK&&Em`NcK4mE+E8?M*_WN#)28h(p9StrfJU+RHLzrV?w#9s-~;E3
z=F%TJvXGitV1=f@$*bS@W#*;c=H0&5$3EtV19Ew_4>X-+yGJ=7r}35Gnr8{RWox$d
zfnuCvO2mVm?7p7I<xTfqY6iD{_qESoft&)h6~HY3hmWjh4o3Zv$W(+xjbNjF_1iaF
z-rw7uvNv*np|{odOGh(5KYJ(ka&8{1oNM!UXaYOZ;WO(h_YJd}xBk3$4${QA6_Idf
z#<?%%`7@`xm6xS(fhM%{_CC93CU&tDoZcK79C8^suietSCZw^f!7`#-QhY5WT6MJw
z9;}JI{3rZP^vhV4i2VKOD9wl|DiN`)ET>cwSh8m>S_)aOvOtx^&#o-Y>PdrVWc;=q
z&zm8P{y8`92-RNZgj#l>0JI*WeNnQ2gl6L_%Lv;iSxc_Wh2-WfTMw)VlzsVk`B`t_
z<K=05r{yE(>-~6lH#c|DXK-3+U}(%@<h+)}dzz(7&mb$uOZM^hZJVlty=L2<-Tp%H
zvK`ox3tUXq{*u$rRUKxWy6#WHLFUYd@590n31bVWb7buvfB&@Rh4fhsp-<m5gAZs1
z4-Qnk6s%sJ%y)P3rFZA!_L;1Wy8XFzJ-l&U%*c7oY(GQE{ua<A%w?7-1`V?yQ#7Zv
z3%+?4Uy_?#^=`#W&51F8m*?y1=BIC&1CD(G1p^<@%s0zR15lMvC3kJzRpqiMbx1(7
zaDWC?=6+trtSw-EXPeRAC-w43g;Rz*XkA**F1zW`pbC^FduQ^>ui)@l(86@S?$wkp
zyB04CkNUUt{~m4I4Mnwx1nIDw(__Q7=p$dZ{{gize_u%DLo72q;KBLlW_H^0$m-nM
z56?gip7eb?O-jql`>(u&Mu>nyfCeMyHK$hRWDXOB09#Paz}v7A8XP>^5B%6T_vPQ^
z=e!qNZIk<Xy?mYD|H`{v5AAv%!&<qp32l`|Eym&vVTlotN`<9t+5yMkZ>Qb+GHH2;
z-~X+v-+R_qeCR~v`o=QB2?@E=Jzl53h87sFkA(Vzi!ujJ)_*^C)Lxo1Q+V^V{5Q8I
z+5PQ3n)z8Qn01Q56liR4AeP|y2^z4!_Dd`e0;dg!gy_bLa~EIw?LT|ATY27G?FW6S
z*_WUG|Jt6b9pwydEoCHv`cQo9)@@zUpve?vvSAmb7j#N<!~dSnmp#+pM`!-IUSE{I
zEBohTq@o$Vu<n{LXxWYPx+wj9Rgj?=FO7mv-RVo4zuh&>uDt&2-ItfA#g?x-8|`&N
z*cUoF#DP?ivaS*awaa&IgjNa;3c@dBu0p!)d1tQK>%WWIs2BU`a`j7C5dc4VL02__
z@7gr3<>$aMjbVZnr|#`uVqg2UZtA<5$LaMR-v2gi`*aW9Q4IwxG%?-u>*_AhoXXuB
zuOKH~XzV<|sXu2TpIt)GwQgNoW0sm{(%zSr=>@Y+u~{<<GS1GC16s9Y?O-OXF$dCX
z(~YSx=>VtrEt?%co5`O~Vb%_2{Zs$#9gE$nS2=%vOm1B>LBPY~hN8|UZ5EcBDWNHa
z_ZK#W#bw8@JQ@|Rb?Mis|7*9EW-i@vRrGaO`O*$9FHzPOh1r|dD<<+rp75LY-$wmh
zidxFd7Ehz{XXSS9Q{LUFez)^^&HEqIY%IT9{_dZobzuH}{vKII76Ata#(F`81F!VU
zXBGbHb13+^M!<N%qnwGGjP6THD?2hkl$_??(#<>l_S_)WJwI7jGU?O@OENHVC^RrI
zaa_@GXxQo|$EWn5m5K47QsYGX(lstiTJEI9RZM>&1W{C{ThOW-dVpbh2xGlkXhVFx
zyo3!zW}luz!`18W4IY2?WqfY4W(ntqv(;x-fLz5Quwg@kr)WVkKPR{5|I)_|x}gWM
zwS#nQly>#O><-a)XxLgM-KX$iFVnfoi0;jMw$J~<1939TpRfhFuMK|woTAtFasN)E
z&~MA0TG?%Ggz5d!#lRRAzjJcW;r%QzOlxNTGc9xLhDuHo+>zwc^yPKbJo|l1w)n`^
z7H^+2WrF=ZBl8J;N+3@wG&Dpru|(WWS|r32rzRj0dr>iMLs-OyR;U4SstZ;!)fGFJ
zb8_na-<s^7wQkSXr-|!dDbIz4D9gFf28P!=xr*$Vd=(w|t}P3AJ_{0{3IY6$e1#8<
zii6aT&;0*K$CXd+ba71@Gt^rG8+I`;hONHu`0M?ACOu8269-?-k7si01>4+E%Cc_f
zj=6KLZ`}FvgJg79!||MzOkTN~%o<R$8yfUE1QNcs?mi*$$Nzxp0WZF=|G$|GlE4Xp
zWsRzUh=juTdpDe$nwfl#Z<jwc@q4)Z#%l^MbRp5jp%Bo^z<4by;YM#mIQN9+tE=<*
z=Q=|YN#kbLT`DdozHrLQvd8^<vOvZ<^udoaY%q-pp^Qvx!uA$_xxJrtPVt6KC#Kfd
zi%Zx-q{W1G6xLL~%;MgXrKzDcb^pH2*PZq*Uk!7#!&N4hh}C6@`b_t9AIwo&&?2+u
zUhU==vJlN2H&~mRnV!y*-sSC3xs2iF2IJr`HTmuG&!Fj>MPS1c2F5V&duCQ|zcZa<
zyp~k7;n&~qj0_M@>!@5<9n8HmD<#^!fBvt6{V7l96e0)rEKqRYHT>1xz%`+H>U&10
zr4bPc*HY&$_4QdH=~$Mx(I%IBQxGKGIxsM<<`PKQ`fBdt`~P$u_`?40``;r6iN0>`
zmUgz2>({@1CUNvsuX@VgKAz+0W^jGloB|13FWp_Vp5q4VoM4s-%~#hQvW8jck>Igj
zLegC0+{MTHZ;I_XrLTkH&MpSVYxCcQL`Ke>V^QejH`glk@!rc-Q{%7B4Ty@$x^<<T
zi%CwjfN#U3=Btahn6!b@3j<TH`iIlnySzeDHtc+`vB#;h^5?>1yDh?<AaTmbVxto9
zZ@nbHY1+{=lOI11vdf=HpI@tX^XAPoj*AyB8WlhDku=MhaeBhLeZTXB4N7lj{{FE4
z|L^^m7Q6EwfA{B4P35zh=_#kD=>|naXe1^k8YLa!*!lHZw5q{`8QYk<dVg`VxZXT>
z^=bKO7q6n6{A~(#4ENXmYA#ZPdfKGbq2zN~(Q@4rzm{JwpMARiL+LCZpRUR8WM`SX
zmhXTmQwY#!+|R#3&ZZ*3?&lNXonJ0_`%VZ+-?;DVwdhS1ACq2QSlC>7Gu4z~wc~Y0
zX0{vUGt1Ye>s#&qI?-Kj;+8EY!U1n@ZC#ynXUD}Yk|H81o72v23V$lw_=}t6M$>Ak
z6w{ZCCMU9fKW-?FyY_4QnVIl(xtPnxBTIRHzJ;E2d8+5ixARTww=U(X_!Q2ZBP{%-
z|D*^ci3vCy_|5vq?!c{$$?lbpI@Om{e(u^oY5J5YC$!h^QJQU@U&guN)!QpGS0x|o
zS^4eUyE{9B%iiD9-T&vQe(IAG6PL}4OaA}w@29WV<4>P8zptaHsCaeWc}A8yVi!yp
zzx`Q#G?FFaZrfrdXqZ*ZKCph>OSR4aKkc2PsW*A9rsbxRvw=HnT%z+|tNn!+K&wPP
z{7&y`Zf=fkTD?j{JbYfx{vA7Zcx{<gwk~#e7*oz>?#YuT#jN6$u?R3JZD32#<fw3I
zuvsIQxI_@@tBk6~ZyO&LUH;Lv{7_s>S%6=vxM}V27qA?n@Sv^X{`rKpr!wyEt4-T(
zcQ1bDi^cy>o;-PJkt?^ShsT5!8fRN01O4XNXs(UkKJCMY4_$M&t^M(%;<KgpX|u~0
zoKvr_i<QgjOk1OIVWEbLQr)YHQ~z=&$-nwFck`neFN~qy{juI5=(tg&oUF?6&0Z?o
z7r6ZUb6&UTHp}(;?BDD8l-(H^Szf7K*qnZT*Ib8O76A)&My54We|-A%Ddp*@sh8Hp
zTED!$e*Wpe+AZ<@wLhOuU(}ua(&uX6Vz-$ws~0X@xNIF;fHr&h*M{2rFE1~Tz4e5d
z>8q#)Z_Yyt(+xfEr!qJ5LIY#N5{H6-hC3#!cK*rD{Mpj-WN&NH#Y)#pyOm#V)v0uT
zX##O>or*)l)=Ouv-C4bB#?`y!_jA41yr1QmcyW>IB28A44OOqMXh!ZTSy}Vz<#Hi0
zv1bu`yqMR|I=r=L<M!10^)-9!=Kt&tsl8J3V$R#Qu6@({m)F)T$(?0Vzwpb#-KPT}
z<;Vwb#<>Mw4^NEUr1Y~z@_+SfuBY;ge|vZsU$3A3Ta~Zb4Vt&ti*ER`KcvKLh26UK
z{a>a}y*W+B_V}lV?eeo)SEQYrqq(>0tJP}Lxd&G<2Jvpll44kUeP3<$&v(1u%aody
zHk@l(8)Nc+)wCBGw-339u-GU*nACi=c%{0{MbldjP#aiYX@7{nyvyVB2ZiFQsH(<2
z`;3<E^DUHv1O<n}1r4TY92>+$MNc-da-UiJvux^>D<M0-->ZJQ@wnV%cDV`%x%xka
zpKt8@TM>Idd~K9!{@$<CV(NZAEjp<>eMfE8>aev-Hf*>M7|*;y>W8j|M!}oQy~^%=
zGtO_^xKZ!-&jyFRtWD8jbE142wlX#A!Xj#ugHN}>&e|;T;{yM_x~^I>PiOv`2RBZ_
zYpMsXAXnwx-F5X$kgQ3@gyy`HlT;UNc1k}pLoqzAa_P*IyUN~19sjs1=SAiJAII%e
z9v$f{dfaQit9I475Zi(W4J9ux9W6X}ppn_PtHF1+ndP^a$99#zc4=OHcUNig&GYOm
zuXF{Tm`KlJ$lfbyDF~?;SoZiQe7aEa^6tu=FK^78WK{X;@85gZJ*!%v<uu11m4r^2
zH7{Sje0H(w_v5dbnVE|mudiOW%S+9FUQXMl+}mb1_toy^k+<99XI_4Oo-L@@>+J5H
zEN5GF!u)>CV+(r?4UaZn=`_3lzwiH_cIJ%F&Ie80KJk6>_Ik5|6x7w-*X@31b=*>l
zrLVJd;`F$xlS_m;`uoLsA7mW>T`iF|f3cA?$DHm4@2-Y3#hIPOg0NU#FLYr_O!2yx
zYXARUKf5g?LFxY66BF{cFFpOCZtdPx^Gn#EJ`@OG^k#`Ly}#0~Z2r`#sZF!r@BhCq
z<3sVG7S6uiD|Y&u-iW+j^y5RK@#7HYW&XBbr<{H{D?c=SNn2anteDmF>;LV{Sa3D2
z<k_n|m7iliZOxi@4Rl=5BJL#HpHC*MnXg$UxZ~-x=vPy!4%G496I>B?!16$pQ&&UQ
zTnk8(je%*J$cu{$clt<9Q}DhnWBRxL*WtfLKlVt7?b-C??vl%pQvJua234jtwZFbh
zJaNKfrhWasnX<de-^WSX*X_A^?RIcfl-BR>@25{xcE9#BuUFF8?MrC%#hI(?|Gth_
zwYH8fDlT?yUM5wscGZ^5%Wh(NF&UpWWJxj4z3An5;4#yags&Ewys#EzIp-a#os<8h
zfA+MT8?NK-FM4Wryv(#{y|+(d=PogaxJKc@ccy744ob<%>3zRjKL2Fmtcep9laKdJ
zeR+Agb>6*MrrBp6|NeITr!2cvg0hyD*R5^2(YXaze@;qFOk@e4>v-ea8V1V<+t;4i
zF!M^80tL@Lc|O_N`q$TKxd&G-ULGSpxl|?v-oDIGYHXNmU4CnmROgpBH#c|gDtI^j
z>d|E-%T_EC`p~{9>#CNqPkGwCU(N0J`wYLkPvosV-7bI6`^llVb>0ULKvTtma#k<z
z(<$ffZ#%K>@Y9zE^j_WelH0X*`+L3_6BQxR(U8hg_V!lluUDnU5%;U#+x~nk|6e1%
z{_obxBll!4c64y;=Ulhzv7@ZLpaT2q`FAqfI>A|?p`M$C?Nw8FCtr)H{hUc(x4EuI
zG;X(ZRKzxzDk?gDdwW~m-~R8GJC)DprafG_HhTLko7MN4-0THDa4{Bbs5+XvKo}Y#
z7d|lUwc0wtQ+!)t%!`%$-@FSwS3WkDhRQZL1ano~RSG}c&Ocqzx$VTUUg@(sVQ1Ix
zs`{Fhd2`d!$Rl3jn_gY%Jo3%==hBC_;*<nLGGBN6Q;*4seyMx@o0YQAjWga>?&gr9
z*@1!aJlCHZFY%vM-n*WNO*!#U_~)mK=I&2lU3_a(Ef@uDN;9&&QhZR#7$)nyIqhu9
ziwg^%O`SVeS1RS|6h`mqdZz2o&9$DL@VY}#+2_GlxyR2$SZbUVEKZ5V+lJaro1_!n
zV0z8`*ij9bm5p9Zy0gtEOA1?`+AJ?`;2!t)%>*BhuE{Gr{vC+v?COX5^uh@y$Kq#a
zDg)NPT+8j!+Scav{oUQvJ39)CF1m_$K8wD)yL|nc=<R;fbfeXFm%pFZ(7@2y-#`69
z!ulTZ>Oa%uED8>6xw+I^ynnlIvzV~Or!~3<W<}n6xvl)hKdXzUl9(6lhFa9n@SDlj
z+H890{rOWaR~`)tiBV&9RW;gT{{LTL`~+Ap=z(YBmoFuk=PXs4^!C=)$*<S%j{_A@
zphC`5c0uDc-RNx|5fL+DDjv2PWnIyDd3X1A7PhL`s!0EP_P3lC#5CBfsS$<-!GV4j
zP!FN+^zKvd<L~6T?FF}oDxzP`5qRj%#UlzWp!WD42x1Jgo_8+d?d9eDm1k#}dQX}>
z*_Vs)?A2da!{a?yhpl}wuln7@BS*Tfy1jk=sjtDGlf^ZhXZek3N)1im)XBia@ngpU
z*V^cl2jnh(`uk4jw$lzJ|N0&Aayu8V@9&@W5SIAOxg+XkrF(dEc*+*sul;`V(b4Xw
z>Gr>8y12V{*LJNle|*`T<y@q~4a)<+f>$*Z=S^XQ`h|h<z1WV=UF(D-0`47u5<7F#
zyW{hVE>)Lre+laj{aDeUn!e%H-W$70S7+#5I&s27(xzgAi>vF*1Fur2$Ey8Wr0_tT
z>6|80$wX}~SXKOhohkOV+o>ttLQfv&_s_a$_xU2Dr`7tU8C;BTH5YC$#mOd|J$-tz
zsCJk~R@SP>mh3|<oR>DGdRPAWcs%v-v0lE_;qkShb)RS7_t;<eSLXK(hXeX7F=-ow
z625j<pHqO94jgCpY?)lM@nZ`t54<-${-kSS?nQX(R4VpBHuD-*R@S2bf4`sp`1rW2
zMtsf3)|qox9Sr4N_G(es%$YMc<=ix?e6@1<llAp~S7)4J;9{y%elV$dst99U@qI}R
zsMkD7KBpPgCb?I>d(7<ic>et5CypE}6cT*4b^oJ+>(D?w;Lf_|TfDq>_&Sq=S5Hn>
zKYe1NvZ}JOb6oXX)5_Otw=ap_p7&|@{l9)C8?|*~cb82)E?0eK39pBj*QbloM>hzp
zaB7fT6S`mnH#8;vadk*vQ@7z)hs=46DQD&we_9{9(kMG9y<XDpu?w_uq%Zj4mWnH=
zGTD}U`&5sl@e=RpdPW5g9A?^9Z%e#9XZ5!StKM1s|MU6m^TqC`iw!C}b?-VXc*uI<
z;H?kGVi=(|?Fmy*u?Wc9yJqs@`uA(RCVzROgw&yIJSOnr7Q^au5my;j7r(r*aq-U;
zl@W8j3ko)P@-E0^)!_IsmBBdT@2fK72x#lbB0AyE0*jZ|>@LY@*aT~NPm{OWEmRE+
zCWb~fkq@^RvOPUJO|q|@Nqr&ZarKc+_0^?J@&X^s8H+ajx-FZ&2b#?TJRR!IXV@<7
zPJaLCec#E0$(4QQbHGDJAc9x-!B)$N(g*GQ^3%%iRUS_ah>6MBc71*P`%OQlzS|;S
z9FoS&STB&kw%Yzq>ah-J=Gw}kGWUAWq^fOGp2W@!ic<S@Xg~ic=j~tDJ=Nh;hEyvI
zO!EZ6evb3?^_>bjadOQ>HFfpweOl8`8OLeMKR0HwQ+MDCo4<Q04+k_5U#S~ZM~UD3
z@k32>Gi${4KLuXf-kqNGuk+&9?4HeVzguxs<TjL^n`1d?+O%ii0+^VYmu6pImv?=+
z5|f?c0iLk=J9>GTpeCM+T@bz7<6_Mk?MePKj>W~4dCc3f`u|RIA8u&qG&txo#Yrdh
zc6ABW1`0SVU}K!lke$XWY6)-f{n&S4jpy8ytIH+_#RRF{{+53Fm#n1GlJK7Q{Bs1M
zZ3u_STorGX!hKgAIx4uK%OPP#?$zxVKHZxp+BromV(IfQ!cgZ3eAwYov)W*$jn2J`
z?@rH`Dat_%gqcifxPC6-?AfzZh1E~Vzb`ER0P2m2=|=5{o?FH7qpjgwl5O#x8l9t&
zN{ZVSXtTnN3~rpQUNYtB>pt(m!j*5V<|wb;zU=gge{27SG$%qM!yy?IW?%E`f6vaj
zy=|=@Tkvwfsk8I<?eu#dAjx=|dyZ(r+8J9De{M8{4#o&LEa+oeyV&VT*F?@w-&TG4
zDiar3=h5~(SGBQ`u{5Xi6)gA~szJeLTl}ntg`NHM1V!g1zO&8pdY9GLPr9+2)m8Pr
z5Jypz?DiQpYxb2EOY%a?f-CM1+BV9jyquLhDLz7pz3<t~J!>B4a3=)9Be@NfVP3n6
z$Es9+doyus_Vq3{KXt!38qDl`TmC+sxn(2oN7n_u+}teN*Sy%XjAH>PErZ=urzdcC
z&&(L(U333@{w$)r@yTW9qK`i}3W*%i3A6v7Wl#gjU{WpzvKLRC9#hn5^Yh8%qN}0d
zCl@-mKLPc3Ko{G6dbj(%mz$ega{{PuByvH7@mr8n!&Se7uu-5N+Yf9N-#%IF;nUBa
zLH=SVo=exAihO@x2R6XOBIN)oIIXVDm?5$A+pTQh1)<HWXK6VwuPJ_ZW}^DM3a4#(
zcePSeQ+W?KP3DO3IAD3;6i*oUU5i~^&^*SgDUiv%F3x`2-p4}g*W2i*F8%ZF0Yf4)
zG~R909&FWQn&ZA=XGA-%bXuIIrsk)c>GMy%y1F{`@2{^y^78tRkM&OO*54PgXwjlM
z{>jpe{{<A-SJ&T3cZ0Ox7??`Mb|j@l|GYkZWs%kXh`uG_C&Z=wPaHY;ZteSk=iP-&
z(AfI1wjum{!rE8sO5WTEto!$Q{^>_YyHlT?nYqoz%kk4O>HHJ1<#$#8|2$v6%Br=N
z<Ht4z%ZS?F|BS34K`pRiyF*3BgqUP+(FFbV>n(Jao=MtT`~fz4EGM)frs1kx-rTEF
zf`W=?XPcYv?&|J-dZbhM+u=RR59~oT<cWi??7z>Q2+eH`(M;jD(l)xavCiDp?*HU;
zz1jSd*EU+vDxHDp9an^sYs2RRK6yJGP-Ru~_v`gZvuA5JHZ~end`OTqPV0#&ILLY~
z^rqVZdzLxOYmUzRXP5>L6^<R63wB1Vm%8fr?`LI~<zv&^zh`hKsVXQOI4iaSHeSbZ
zMJJ(?Av-W|V$Juv<(rD0dfnVvyj(KS$*IX_wwbS6znrda^tLsXQ)FBZOlOTL+K~41
zlZT`<G(;5w^cz>ZZ=YPg-)r)pLqe7nI`LuozS9GllU`pHQwMvbVtd1}3G-^dMOMDu
zdi_bee4WAEx3{;i_nB`O`)<c$K2A=~kM9^SSbK9-ls1@}nqFlIeY-hywrRGSvU}f@
zjmgKo-rw7+%jvgV@WT#J&%@8F8Js;h6dpt~=_)n32D9$j_-TXW4SRcU#RIRRx6il;
z%0g}qk3B$TgYRs!ogJW7=9jOJy7f<8TI#*D_V+iv<LAE~-u-@`cJ{S36W!%&zr@U*
z6ujJTX88AachB!!dn{vt;_ug<*W0#zxW(|=UA|T&f8Wn#lJ(Q|VxR1Kz0UYx=-J&~
zjtq?IjL$_FpCptvCBn<a6#_esnRS2tyZ-W$1uH_n$)22CdfWfxg?nqYv>=1|37L#@
zcUq;M61lmjvUuy`3kO!SC79lLb#msKn>TMxnl~@*ZRzVGhvoy)=6O?|&#%9?#x`Vn
z@$5x;&fl(2UdNmJcq?Pr-%ISQte!zZlS<y+3jOr?^V84g?blyi>_6Y`(qi|1sn-Pp
zjPr#Hzyq_-^YocvL$BvKT+H*;g7v&6l>eWcCiUmK_)3-tTW4==4uyt>aE^?qhFMLk
zzxieD@qB%5rt$H8r&r%o_n)Wp_xJbhE(M_v*Ic{bw(Dk`bi&mV231v6wePE*#g{IB
z5wFOxVVAP2?0lgDPS8;B@^`w;utrxu*Nn(D+hW!%U7ETnHGZ1U%<pSiZi(%FHAz76
zG5gV(3^|)0IP}L&J_ar<rQ98g*X@elvTi$DMCqpm`_=@3Y%KbEi(z%$MSgj^nB|4X
zj~~Cj(r&8Y2ToAa;7D$Y05mCF_`tL+VwFo9>*<$&l8QGjGEUw0-RNea#_>JV>dRyP
z-G94R)y!(kL+it$V5`mv&9JZEcQScZ|8Mh@iz1ASzwEibYRrmyaIgCP)c?Qt|6l#>
z4Zr=L06rND1z~l+De3bn-HM8ep8Wg$e!AW^kr~`#Ivf5jTz}<hOze@^>oS)XX&PT&
zAFt0Xu4giTtL|Cd>Z79JCswcDr)6FCW`bGntrIPr!cQi7>lv16{l74CkN*BYo9<LR
z?lmfT5m0PlZXW*c$8q~p6BM0&X0_b<_3+NKlatlYZrz@LU+?JAqiL~Atl#em23>NV
zT3`Cc{BFr)oybi`zHBdjeGOdNZ%8~Wb9SC(vD>}s_qLOFn;9DiM{UhgwYnK}x<}IZ
zj82?;>T=%P-@WGdCj9;V-8&;=#mnw%{asx}tFHc-4T{d$S5}9wKPLXLizC8U;lQ`~
zg$s1e3p3}feXhFg|7lUqt}VATUg*Q}`-KHe>0REb|Lp5ZSi)EDx^ZtyOyz^0Z#TVo
z$9Tx++Nzct?F>vDCTk8%_P5jIm5s5zE|~Fu%Y0MTh|-74=USJanx-4=(-52-BQ=AU
zk8j$=#qQl~;#-$2S#rYseogYc2iv}T7w@$4x45!xTkh?&Pn-HA44w3Ly-<qWTeX#Q
zL0fC<%x`a=-@0#lv_bB&!fM;Q4eN?azPt$B`QuUd-B;~<b!+3dWK0wh5t$LWUus6&
z?y|KR0U^gjL+eciRx{pdWM)5g*8F}>P~ED?c0SoN-nXy(tNHnKx>5Euoz9+~DXFKY
z%}iLs)_Qwu_VUnkTED-&oeUZf0u{A8U$5Jp^8Vi5Wx2d=|6lsoPdad5SvA+uZ00rT
znwyvzSyqW(Fky6+O4urT_OMsO);mq}p((TBfIrj!xZ*21d7;uBY>`{vO<la|-_v#5
zK3jsTjevT_+F3t09+&(4N?|pdSN+%3@mH-pcpc(uzg{hRyY>36D|_E;I(;VHxBKS-
zW`2+7=jO_84v*Ecs=ctS<k*W9fs4<?@oqXd*E)QfetcYNLnw3a=JfMsj^{wbM@BV2
z3L<wFExl8AJ6A|pIQdq=c6qDYW#{MFrs+tnxq4}Ry#436yZo_pUVXcrKfUnrv6))O
z>K<9c&H|X__F!K1J454Q(-W&w&(1P6Dti;*{=YQr-Ty!5|Ib*k_FTo<RT%->YJYz_
z7SFtwnT=<{jvW@D-jj-@<;^qa*1p<v?8fzyg?Eoh$X<6i5YOTv`~Wm346XVcY+1wd
zY#x4_S-SFd+2RmzA7(|UgM6aCj?R=#n>JbPFKJt{+x7Le=TcRD-_|d?x%!*ki^uPz
z64tJJ(R0?hoo}YY3cXKp!57^hzC9SacDZ95Z<(A;#fLQ|%-_m{goS;%7-J3UK0Z2{
zc6QOn$H#B;Ti?rm-OiT1yZn7#)6V$XuTwn*A6V?1#rt->?T%HULPA15^No#+WYS;w
zB*b307x$+BN4Pn6=-bk;4Qv_Z@9*jEE_-XV{=<iY%PpVR#8=Pm{dtb(+OaFoqBu;Z
zI84Z8TfJ9g^M$E%o64b01&0HA1rJ{M`~SXCe&s{l^j)SVhZR9mjcy`49`{*4IVv7M
z#do&Z)rza!dOIAp<T;D;iiC;lTyg(;zw){4#mFU69BchAHY{P2{ru_EnKkEE-MX-6
z?fkl5E9Y1g9<o^#Z~1=B?!Q02uCLeC-}9mAr26k)uh-A6*)UnncU7=lH1DogYhtS}
z#%!3CwIKO;-=(eD;h;%?j160M-P~x^9UiQmb7x0j-Jg%{)yB{Erk<YGH*=>RyVOT!
z#%pdzo&|B3%xGA~v0=Ip)0#4_d(b{Mw3o^9$JrshG;2cMt1Bz7vPGKiSXH_uFL>JX
z`So!o8Wnd-uV39Qy(?qtvy!WSmR_COZ~yNGi>|5sYQ1?&9etlKSik%4g)L0GHe8>m
z?Cz5gA%6Q(!iyP($*Xpkto>d3ZS6AmAK&-?*R>LhWq7mi_q)ljE-`293+EMht#jw)
z<>l9J)g^~3xH=?v7u&K(IUTS(u*xz*6PD2!nDm%pg>t%^c16Alx_(w|CAfuifrDw*
z{NlU2O49^aEp%?5HFK`ijLW&c+zXCx@e3A<z2TXjkkuD7_v%Z(i^pGn{a8_banFif
z4b#s3TVtbrHO^hU<&w<W>oLW>cZyEyZmR!ZXFU6A-5$HY8Mn8sjeOzd`&IDoFR{6S
z)ejCZ?)>xV^wanC|99{Ca>+aG<Eqc+tk>UCGkxk*Q?n<MWA!aB---swHNG9^mkNHE
z0cy#(c{)Sg{$MuKWA>vb`<yNFc>P{OW_{OaF4!Dgx>2XLGWz12#q0Nen>BN7WK4|C
z{rdlVUoJX#>&=yw!CUWM4PofF`P30p|M#n!{3^R|^XJXeGrv>dJoWjD#Xrv5exGwP
zyz1rB>0Qq%uFhGz>%rAl@i+}ZLBYK5&YzEDEhszG!YL#zt$ll2uCcM-*Ny*vO$%Ea
zHS^}`e!E{QI4fS~MAT;1UG>)6=~8lV^{P`-!{ah9iDc|zdfUIu)1vInjGP-A4lapa
zk@qb-G`F%!o-xe7`;r{S@`D7$Mon?m6QADqoxZo_j#TyCwXsVwVxfaT@3=A;E>|vG
zb!z_Gw@;otnbA78<lD3Of1kvE=SiAmOsHguFAphQcdlfvW%05Xi+@Tjxq2Q{1@_2T
zUb@)!`B;~zwu-8%tC&v2gBRD=L~c&Gx2N*cv)TEx9M*0N4z_>uHdBk4caz<R1I%gD
zzxg-M{>Hjl>-+Xk>DAU&m#@v6=aBv&YeIPQmc{P<W;;Xu=h<l9ulv1rP2Aonx#~BD
zlYcEJir#f$`nhMdzu#_8eR^tY-@h;K?%sZT^T4-%6~Al`m>u2WBmMT~=H<(8uPd)U
zdGch?{Hyy#uFO6bnBNfP7qc~M>dHdBoqAb2S=!gC6@2*b!Z+o=z4gl<))SA|N9D47
z5r=kx1TqR5Cr7q^I`H}SYTiw5Eo>*b{~HG+ExucwviYF(8CGzkMMrS~qw`$TRs9>Y
zSN_?l*Sw-;ot@qPtKso8kH0Y8F=OIH#lphEzJ%1!+-zwp=WRvnBJVDDE#7`@Yf5_h
z?3t^ryszxMd+P7nKR4@SV;6WaFOy2Sx?|e84Y6A?CVHQ{YMOm*My=GDx0jdu_x43b
zMg|20B#3P<de{HAs`qQ2|I~o;i*7F-KA&HoSLAu+YtXFS2j!X8l$I{sC(mK=JRx<W
zw*8KWJg}*!SIP?-FT0lWPpDsSsikdx>(hSOvzyl*&<UzIwr$nMx3=pyM0A~-a&39$
zIdDtyLoy?;)UEV%E$64_OBb$u8N;iRC3opo*S5gW3mfekLw|4mQdm<PsyFp_^v}(E
z_u2kfGoPEA`|LYe>#`Fag34#Mu_c(UUvuqp2xHW$Z0~+oclX)T^QxUco?>{tcKbao
zsm?OJu0Qvx-*-NXz7Tr<jcc)P#yi%t)(b0DH8_4OWw4C+`)QkT2B>sqWD!`g+hOwq
zhn+<s)}J@c|9jxG{i$7VC7(V19WOue|30mYbsex0{=<d_yI1?m-bO|4so1#Z&!^Li
zEF(=_8`xUk?|QvXi+QKqyQbr_Kc8Y)?e=)C@~2sgorLdaEsFMi@j9mD*ebO{e{bLa
zr&jy>+gd}-4WBD>lph3xW^-2FKA8ZHZ2^Y`g{<o~vBtb*yykyhetNY2YZbx7xSy+o
z9v><&1-Z3RP5eU4^1r{nW`C-y*u*@m{wsg|kLHuYtA*7~zc%VExVqGPx>owVs!z9g
zuTE3_cXdPU@3M;uua|gEUR5GtQ?WrsMdie=udg{bglQh}n=fAACm1m2<>$kx4bVcV
zp+TK>(z$HSxsMJ%y|A(7q`uBX(Ua;=J_+X9R&w5gbSf6aG0n9q{d6-T{CJ<NYy7?d
zrnLqfXAduMRlap~>YY0=mW7X8O51PtH{^3$Eay;QU!8wH+YQu01a;APl?qye9lk!!
z?>9SPnjr$s3pK$9gcz^M*;aWtI5gP&ezUpg$qB*f))S{sSNEQ#Gx5wBpO@Fx&OU8u
zr|`g>NzXVU_Otl!UPfkDSoL(yF~KQlPD|^Q|5Z!6<8$vG-@o!)<K$pSCH6s^(R&F;
zM|byR>HIx`_bMLq{ydvsmwbuwMONa^pFbzfnx&<xsyb=L42@YT)0-ONxdalvp1yr<
z0YtaMfnugv#idR`(viEC)qH#9eqUzlzs`&Eb~EULd%6k@4d=Ncln$)=b$OYuv2n<B
z{dhfgez_^O)!#faGFFtlxZv2vFRwT2i@A=@ne==SX6FTNjSDnxKV-PQ+GmN%?QdaO
zzcV^HUzzfC!}_=l4#`|T((@j0Y*=@1mY(GDZk1)O9?4~m*)R)PS#^XHLT}sE{+cnJ
zb?!?eCSL6Y2d^v;dwMWbIK@`?k<IF@iR=Ad!{gMSLuFg{lzp*LC-~X@ybC>N)@*t=
z<BrWibFup$I;D>&KoZ}FAVzQBLTz2$sh~WzDs*+q;Wl2rOPe+sZPagh3Yyyfr}jW5
zKvyk&#{Ro?$6(9c<_Ye&leuwq{q0MvQ>NXTC$I<<&0wodIU>{!%$hVw>GQL*liTI0
zJmyuuv;6t{{{MFp*S6)}ezNU$-sI%teU{%gHa6VnWU+k8p?&Vl?uW(+pp*_u83%-!
z7PD=c_Tt1R_P>4UVkdXKm7JF`4YttfKs&3BV1lle)+Eq?)TT|FQr_IyXjJ+t<YMIN
zZ<n^`$4~AzwY0psue+S(kAH*Ynt$czB@Llnnu?eOkp&B4%uMcGe79-q)9yISvJLP>
zeIY^{TpCL6@2f5P@*;4iVRGA<dA8BNzQ2EO)N|l~!^=B6H^0yc=VGeU7Pzx1>4oYN
zjui(IU}N?ID`qzoH+;3e&2w#XWNT@5!!2-7a40+o2dxKKwsh%C$yLtnd~3fwV_{|W
zbaZswdfc+1;XJoN^VR41hRonLu>(WnF~JORX}#y=+Wz~OXhzsa*Y7FRI}-|tD2D@+
zKxQ2~cFZd=abd=)hE-mko}DswH4%><Ys)=dxk~Q0z=upwZ~4pH)B>pe7j`gBZV&yF
zxAD*J$9kHlq_(Ta@PfjafstiTEGYLKIpWgU(J^89{JN;3qM{g|(rd4@*Y8o9IdkTv
z-R1eylWQCftY?{V@KyNs*#}|m`NLd2Z|+CUYG<F>E#s*_!MEDu;FS%Jwt#y%4GpEN
zr=}nO^68&>{=GX-;%YygRDZf|_q$0mW=Lr2=}r6j`T6WSYkvOxx#%VHIs5-L`tqE2
zofj~IW+obTm_Sw{GBEv96S$-ka7=ycME-DjL+Ae~cMT<P9M*ikcYmWn95kJ*2s<ET
z9I^Ggltb;0hwZ)sp}|ZUmSt~dfC{^}+wbcYKRaXi`$uELeXbp663%{!W@Cdmkb#M#
z!Ykp^g)S4u)!UbNm)(=}H}$oKhSvjUrfD+{W_^EmW#!~EbFHt}=;-QBJ>YQqNc&so
z2eOTA!UdcgK5;}JcD!r^O;bO*9g=o?yu7(_=Nqq+6OC0<HyQnGi7{O@cR$bkLTHFJ
z%x0R_6_6EBdc02-GzorlN8#e+j?~oDqGvqyzGV#?9?oZS^y^<EDxC23yguV%*eV-;
zZj19te@p%r`kVV#!(7PBG>vn^vL#DS?5X_xWMRA9r04Uh{r>&?zTf)C_T1ZQ+wYdm
z_LKy#N%^Ptz@~X?3&U#UjLWNRke0Bfg=PBxTU*Rc!@tR&%$>n~Q48vuh%iv1ShPr~
z@=>R{ing}*u|8St;N^azbGK&c*Z%%C^}>Y!Pd~qH?;puB{s#>_iA`?4`hOooj|4PT
zNjWJP=|r@B&wiTm>of0}q|yX<4s!z;UHkjn$%~8KQ;+pX8dZPGd3k^T{?l(S$E=xa
zT`o5Fsh8t{eAXsU!3W#F&ufIu12l8R7%k~tTzmF#R8W-R&BKKauys=(qCu-dE?>HI
zhUe-+=k~Db#Z663OBO6xaO<&*!-40lF=-nnDIIwJ-W;C6+=L~rY+kx0>*AT1_g7vT
zZz>e`=QfqH6Nl7s2bh=+ioIBT1fInvOqj5FS4>cl5@@RF;$rvtr9HA7KYASkif;!r
z=d2f+7!;kiVN=pX2Jb)W@65M%G{Pd>l(mV8Ii)6O&YrzmXL%ehv+%qWO+I_@LN<$l
z!-3<hr@GF2JZvjpQgB*5sHkSWWNyIhJRz$GMx3%WYu{df^2vV2PYdS5*(r?PXA*pU
ze5Q1Ca8&+!xm;CU{dlWK`r3V;PH9h?Ia70Q_4hK%W9%${{1hx!C7n2WCTT5FnPg$!
z*x9UoiKS-q*C|iLZv30!3u%IBHC}r2c+%fH=T-7=#xHsD!EEB9n$MSV?=C;SrEmFZ
z&`|03d)4dRXW5p%n)2r6=Htq_7d;+xMkpP)wWqRpa&_tDWxhq%W6Mu=>+jPzdi1DK
z{lA)@@BjbHkKCBln(?dQ^LhLIAD`?HV!Ef{AQzUuNBavWG;P#4EXcm?0h%A|S+ZhB
z$i7>1-Z3vu;sA|FzUO#x=IZ73=O#{CynB`G6glg^=i_h6{jdqno%>7X#JO|RzLcE*
z^S<fWp1S|P?|a9^#ntXQWa+Dt(8;j+RtCe@hwbuajv>CB3!dKCm^^911cmMQ>vo@+
zX?*<6V|J!GT>+6;!<sbYMb;b@4hJg5UUNmyV&DQL{f6(LLD5OcyR+X;V2j+kZu>OQ
zOzxSP#%Cwrxp&L`SLwEfr9viUudaALJ2yAmEifudtFdufC;xoi^Kzj6Y3f34vG@#*
zq+8IEobkV?gt<Z3yx$r7r%db2xjSE1eKVJ;nbnngM+r+N4uuD<OtXrw-d$9Bxb5zf
zysvI+uP^tPzbJk*ifJ0x2CK`jbi$a{oKwnCP7nq))|~jl_Q95%fZA$FQ7tD}Z5O3J
zUZ<nEnKd%JwmxW`?B#otr!UY2rLXm@pThpca_x&uir&35@pDYJ-?iZV@*(!G7bI{>
z7k0b&>{xy4v;ChB&Xxra8hqwh1kS5`Cb@aug}>kL>&NaYnaIj5*5M~rqIY?j@8pTf
z?z3X$Yrjlf6Td$Wv?j?eJ9_2Hl|?v)Jqz=WZQNV=Ij!>N)9Fu-N#~pRx4dq=b0-G8
zK*za_XX47><=1ZUyC>)DP)(T0u$nDo|DR9Zkz2E-{!9`T6Pxw&(#MY<LBmg=VZNo2
z#$ipxuh#{iEC*#}p@gq@rO%##)`kmKvK-^<F=h<g`)@i+#OzmQ1+gpw9|9Yjw&t5u
z6nvfYGUs6Y+jL*Xu-Fw@&(F=>lzLiB_`#K}txir(Di#(IpvjK(b5ou-_<DLy%-{FZ
z?afMqt@*P~fBo?Aa9>_l^zCiAlY6DjPjv_?KUvhRH|gr?@YxJm5fL*o&j<co-uv(G
z?{3hrWZvsTA3+laGPYG$j-0>q(*3E~&zQ{(s`EDLZ~j~P<7WDN)9&cEx3~KzB_}T}
ze}7L%TwJ}KPuA$SeD#}+oBuHde7<1W)xgg+q4_F%zLqnj7-C?|7m~QTf2#>MmqF~U
zQVVy!`5V>-Kyz=0!;K5lt~tgodw0Fy2{XUMosyPz3bZui|JV5cs^<4=HfP-O*4_2~
z(`o(bn!(FvIDmXFyE%Nd^!9B_D<kvwehm{=`1>}$Ufa;na8u3CPg?#L)%T^JpQpR)
z$F=?czUtrHnmv6@%+8>^T`$#&<7$5gK0SIPlV#7J=;*rXCX3cz{8{(+*U7o%_g?-m
zdU5gca{trW>-VaGM%h*_uIF5!@L)Trseba{tL^uh;WaL=nt-I7j&s%V6Wee5&CIU(
z`IqzOP1UFSP0Vk&W`e4Y55kQdoy9KkUp1{(o8;e&zhh;Z^eO)?*Q8xnBTT1$(R{sn
z{k~nZ7Au{erfWQz%~aGOARu7t*Dnqk87q3EOiu;6ryqWG=F0m0|8Du1t<h>tOG;Yg
zsrUgjxA^^jy}oVLmkA#qAGf}>A^*x!`ESJ)_R*lW!}oW0v#Zuktm?gBJzY#UYQ}!H
z7bV%fCxQh&WHUZz(6)^D`)l=q2ha||f`=@}c)N;C)@3q5){Ob;3t0V#;`DkEneD!%
z?^^DQMULlJG0m@vtqu7<xBQ;r=15b4sQE&oqN%6Z<J2lEE3eL5R~fzaT&J*l%BLqM
zg#-frv9$eV@&9u8-n9Muqm>S<IvA`w%YM<SMezcEPdgMA9#(T)_v+Rg=L4%*=7{gq
zQe$5oeplM689LQ!r);pszX#O$(VALh6aQ_=vma+}NN_N5C?te7HatkXlyq#eDe9nI
z)V3VW>#^mrdv`DF4$IWLdg8>1tlK|+JnmPuvAN?DcID`1E&X**JL^KK3+=5FIvHO7
zd_F(_)7pLC?^TE1n`fGR&BM*D?R3dYE$vOhjPc?H^A1M&bTP#5zuUtPE#YUmDQt<H
z(DUN@t-`{zjaC{rK<hkbg(w)T>UH^hef1(uh9;{o!knDu`ggC@R{6X(NxjH=r~c1J
z_nm*g-9Eec|GO_sSFAXpGb?rd>c*g0ht<i)`_j*PZM}Zcw8zB#wdwU3<?VNhy5HR2
zA8+^fOYrZ+%@b;3e?PRC*}IuVXJT_``tq!x2loGeo=;nr6%;fnS>bq}?BwZjRi11-
z5((e_emKnEmuy@8&E%`B^$mvu*I6T;oC571f~}m>7nHEp2n)-zNv!&O_1R>j>MU{n
zmy&lue)tpZkiPttQph_Um#a5|e*XNKCc98CcGryM8%)htf$pZX7CX3VmH)39|CRe~
zl&;6u?=5+M?=Fki<;$0!wn^u$ShZ`)lqn~Q&)cfYT9r)j*57;O3F<K2*H`XS#gmr{
zg8Cq@udRL7y~Os~i|WwTOERCt#h-h+uwBk5-sX92j`D-c(8=Y?+h-kwb`2dabE$mI
z(VUp*I4L?n$=zS{)Ve7$FK=$N*&2EIThD56L&{`ZgI>_nJprLl&wu;(<jIo`wn%;%
z3x)ch-bb5an%Q_KRlnbRJ!JK(nAj&-&(6&J^lJ6`S)adt_BFq&qU_$c#r*B3eMv{T
zF0wur#~gsm&HY=DIe~vG7t5PFJ2(4ezs&K^*99%IDtmj&syzS8i;HSn@y~_#{%Hwa
z9X3<0Pty3<>1wa<Qn3p8%TN4@dpezW`(N|gg>Q}F3q%|iII{fv@=GsrVvJq)*JFim
zpFR)XWpbhvGInraH|v*)wR25Z`6qw}$o8(US!cKP@73`5naj7EhBhoa(bL_%x{Oix
z_t(<7izZAEnC^Z1y56NbYemj;yt%dYv`GqQpzj~+%u6cgd**}*d`JcLnm*l4&4IPC
zQ<)Z@?=NME*ne-5U&GbY@A&V6nod&Q3I+xjR3AkCEROvZczLIkL2rNm`mL6^i;D_E
z{gpOEX~*u>j!2rg`juPxuP>RNetu%UcUJ$@(BSy7x1qSJ;gQb%=M1pH3xN!e#wDMl
zyj(IS>~wi`lIiB`X}2d#Uz`i=-GI8~XA-VzUf>qjn^O4r*vT6klX+9KvQ}mEh4OC7
zy4bq@*}1u|KZ!FJH^_7RnCy@+!=vG?V8bS*+p8~pi)nf*D)GvnsRy<?Q6R&lal!)!
z$!qFv`+odevU8bU+10hNDT`z0b1Q<DKK<Bt;K#?uOXK&~?XwT)?!O>p98o$^d+yRz
zp7n22Pfk)*+xWgm()h_K?e!+ck*_B&zj{yZJ;#q8hD@fKXJJMHFgMpV25vK9{I&>I
zL~>LFEeKxjXOwb6z~9U>npXj|{Gh68mkVgvPHM^0rJZcC%YA37O;-0eTRp$@{k_<2
z`S<TJxR`V{9A#-*q;2IhtAUGq8??q}Xk-(RxU_mHsLYF+T6AZd(U*&R*miLF!W!M?
z+@MD4uF~wuTngH&ZI(az{eHi`qoboy;vtsy+-@;l6?OIFA7}Ei{0VEYSyNa2TG9g4
z_5;mg?sLf4tRQ*I`dHz^_1mW`=Pr1Yzzi+ZYT`is7Q5PC9w{kH&dj%u7t@JQxL@<R
zw@1?0Eh*{Le?{2B?j1WU=I>AB5onA8ZNQqc;X>%zxDZh30rtSTz=S6aT_%k8^Q=qz
z))rbpt&Z>o8UNu!!Or*leyf<7g&7$copB1kyxhM$VtwRhHzQ-?)EgTT`)YGQRqHv%
zYma>PrzSjrrql+9WX_ljZ(#u$kp#W%>Zaj+={LlrmO=+(8t!wjM5iw4?CkvXpqW4H
z=3UUV=pxr{mtf8Sfe+P;K`cN1hBLsHPi4e3c5F!4xuAMW&W*@_$KU4HTd0Qj<=oye
z_dyoax(g|w?s3#?KNlC4gI8}&uy|+Bq*L_N{`)NWI+yDlJnyfcx;Q<5`%>#|H(|cN
zFaDvEVYPZ*Fno*ID%<o)&uXsj`V|*kxINA{w}7Y73Nmt-J@=;tY>A@4iv9zxwc1Q;
zqQ9ki`_&cJ&Uz>VO>G+%G^7Txm`qvA=4k)p0rSr{o6oCQTi=dRv$BdxJ2$5?%<nqB
zJ!Bh{!rtcXZIcpy`)g-Ial=%ZHFf_|6Mn!v8o{*j;=-c1<Igr3tGau6oqn?Wt)x+&
zK=%i;Y4+Dag@J&>0!`4qtf~(W9DhEU?EmDFxBgT)+o~BeSAuq$=)~=buqt_x5LeY)
z()JouDP(45sx7#+H9H*C`_H($V1dF+)9h(G``=wNp8B)V!I@)1^H#->OvLh%P>0Jb
z84aP`%QzJdL}^Px)-wov;AGs-zoG2Sjlg*ok2o{$?b-RbZ5q;UFqVk&cXu>Fi>yI6
z=ol3}@dyq-e|LZVe$a}dqR(f|y*)fSc0`{qG&B?Vumv<ZrRxP7TWDyAW;*<P>$K^1
zmMO35wkrpp6PfO{`9YWZ-8)$=UeKUPuw>l-KmPZF2MN<3th#q_$Bs|#m0jK1pVZcZ
zwtg`&sc34Re5%F|+WMv1z!tW3NA&rnf_4fIJQ;&nDuO1%b2H<1(4J3^-PaPA)zu|-
z=G>b6^xICz?63m^<7=*nEVk^dtW`Pp_r-47w8<rXW|-dJUtcHN)&2^(7yJDD?{9C7
zpJzxhR9jYlTCyeYZq%W}hu`i#Q(aTDr}Da8X5sdED{K1f%ii89?b9vTrO(we@8qO&
z_PlEpzR!?(RQ;%X`%FV{(WlVRFrDj5mbgOZ%cpaHmz=fh<jZ-u)OKk!hr)x?Ot#hE
zzC3+sXvVU~?|>2Gwe9!oqVLuJ|0~5<dhF#+wusM&onRLm*6z(<*jiK&+JE!=T)Wy^
zA*I{r?Tx)B_+g7fro&PDN6e>B?VmnxAKP1~wG2!gA-Wf~2Y1wLG`%nL=V8Fa6CJBw
zZ-h-0)wqMog(*`+gky4VZ(AEvdNp*>`?Ir5tzYYH$-4S#O>ODjg*(GHZ{Ga$-R}3(
z4jky>;aa+MY3R9GTd!~2zdL&Uy1%Pd+0{>6<<(kSbnM&xgPld~6B=wDRv#*dtuqzK
zuxVV^x%AVYuJ<m%EOXB2P5m%Uc1iN=j$^MGV4FA_-NZMzG+h06Vjr8Wb?K`s2_Euw
zKNd!A$hx*B^3v*X{pqi_WL$JIGBS$!_LBYV{#B}0R=4)-jy@mqjGc*B@xi7Op=Hi7
zjb_j`Gy@~cD!~h`YbRB?oqn};xleDYeVRbR+GAaJA!+MJm%~vJUwyg2oSZc;=jwS}
z4M@GZD)iH}==_sUr^o9}k10ACIsGETs%4BC8X5(bWlv5Be!h9nz5Mk~lSAw*Hktw%
zv+v4g%vVi}Ua?l?`sB5j#h`_(0%*ys__uWxoAT~{+pL~>rO2us>ZSuppi$LtFD^O@
z2?;%U+;5*JaBpk&^;7o$KJw4BC|m?uy%QRj{NO;Nn(KjOzO!Tc)<<vmGud%#ZM6C3
z`**AKdOt8S`g5~PKfl84tk~wNwaY6rVa;KI6`l_c-81Yv9Q{4jJFf9<|2+|C;q@W1
zv2C`{D@UWbJF9-b-F|xhzc1>Xyu4Eto!dfg?qW-f-kulxbmObCcQ-e?i|NPd6c!dP
zYP^%b@8_{VQ`lZCekl`=q@<)LOQ*+8f^4V|=RK2kAT*fkg`F;}RN<Uq!uWLa>ZKOJ
zDqCWmV>`>B-ezEA(c;|F$2IZYTjf;$taVeSO!NG-PDj#oLEir5Az71PJ3Ag6Wn#20
zf2VW#U*%^fi`nM+W(Tj{l3DIEQ|a<@|MhEUoi6m{{cxxF{LVL<>o2sfj;nacDtzT?
z?eTv3>8{;kozGfywY7y~L$Y68S!tAcN#(cZv%7bz^wh6DZ2lH`dWK>08Ebn13-5%-
zu1d?VPkX=bL3H$_gxl%hF&S`2$6+z&o;`mS?D_UHv3Reyevb0@dlwd8Tz9q=T&IGj
z&cHi?^inz{L1T#1qVskx4V(FkrPI{oW!{2KzO&6X6+CpB+#V{v{gUL`P|@<&p{07i
z1wM3u8e~F2EEPwlxIv9#Xtd(UkPEABD7CGOc&*?b3W=*V>Y!H3>1n#>XQ|$rawRb_
zanbr)UAw<#Ww$@(xDp9knxF~o5`t54uhxat$;Fw1f;!7TcRd9SGXD2iSCT7zb4Bfg
zB(Mq&g$ov-L>IP9Lr-tonl(C|eSKnQ&wDvCG<q?qvA_2J9r0w95T86Osv6tGIe2&`
zESaa9dUe_4XGyQiQ-l(7E6Ub^nr<^#PnGVS%goL<<Hp2E8GlxIPuIJ&x4Qh|*D{;f
zd$r$VBR8k@+WdO4`1zeLD}$H2#NP^EJ*D#Vvy&el9)9}iwElLl>9+U$PrIm_K3}Ql
z@D;R48?;`7FC;c%RqpL=&)E88EQ3tawOAQha+nV4YD;jS45OJWa=26}%6RQbtYp#O
z8{c{>O7%eJ82p&;5EnP^#V*sCGuQbSEnB|4d*8Qrce5|KxVgAgh^Sjz-`?`R(=EQ{
zqbsN~wE6$%^P`t_*Ot~>Z8X%<I<;{{weRz+IeyKD{>A7BPptX>_xsb8%jZo>KHlfK
zK5lQyjSY#QiJs5bJ3y=Trs+gJI{$s*M&$=u59TN}$gEjsRs$PHVUhAo*r0nLOCOX0
zAI=o|?S2m&s5UwQK|w*O1y_F>NmX2BSaa>`HKWQ;DKjmL(<ZZpm$H4BTYfK-Y45#P
zPjdfmI>Hmy+qD1tz3N5X5qFEv+p0C?wd-hT7#zHM-tPAqmRQptUXBOev(8~&^CaQx
z@Ab?Kut+umwIME9+Qsn6ot|!dG<8#I{x+VMp<kVL`d)Tk2U;`zqpyLDRr`F*+N_c&
z_t*2v?^TA%=6$NI{q;q#w$l0H@{^kHKm)I<DviCoy`Mg}|G(3_Ahdl2x97`$UteE8
z&2RrFA#M9E^O7vZ2Zx!KaC~?;`}759YChn_)SSy0%DW-!<_6=*46CQ+$<?|tFnV)l
zyg6}qQK_`ifnN{X<-6jNA06pj<RAO|$&(X*zu(XQbU-g+!+|3^=KQwGy=8Lo%Je9^
zUoVt}A4lydSom{I?$Tw;PKk!cD6Zf4Yt@?@8=Y@$$y63r^O@kSxAVxAm4BSC>#cfg
zrS3n^<ZbT#eX(2W-rw7Mb`5BH`qZth*}jv1ZTWFKe}C?pyxnijHs>F1<L&!0ch>c9
zpt~ZUp8owb-J2!iZGGc~n$@AAz5#P4Oi;+o%nX%HlV|#;en2T4Wh!rJgI>wkclD?0
z{cmnCK78%?y11MER-m+3(R|?9+1aklbyg?WDRw_guKoM<`s-58*#GX$6Q9qouiN_k
z_2e7Y<?p8GMsGWDVWIQV%FoY)goKjBvgB>6w#>0CJ~n6eq)AEFq>KC_7t~tU{MfKK
zH#htCw%lihe+8A@PJq_;uMS^7ZF+p&O&_Z(-?YSI1@>)wtrNAy<IBnqmc`Fz*sPWc
zx%wk|f8F0D8#V-hMk*%H+U(rU2ih=R%qe>wRLQ8B`^~qD1?|-5xBIbx^Fr9W=KZzX
zTpF&{DVzR^zp9n>%k|2GRdok7ITR9v6<itOnIWZ-fWrZ87PgY^NofZe)m#rK-uAgB
zJhN5ky3rNwUvBE4xX%~9upq^mJ^Xy>nOpYY5zxJDY})Jh{mR<;?N)ZIUggcy=`+tu
zovwP&$iAfb`MJKEtMx?Z+GRw~5-z>6A~0<|TjcX|bG1)T*EeqrS-z_8?5uT*lP{QX
z-rE1~@9){gCL30{GOzlzWd~ct<VllKK0G*>w*TLSn_CPG4UO{e*$5lRndi-!dH2_y
z;`5fTe!Ol|72A19^SEx*mI>+eYp?lqm+gz(<uvEr`Sa(^Eu-f4Z|rTj&t<WkBVnTU
z{=ZTN1yEmRR5e~mbG&44c<SQB6xblW!&RnT-}=r8e0{d)Z?XDbhs|kceHb?H+Ncw~
z&4*9cN@a8Ud9hlf-OGfeq+W5X%d(xzySnjWGduq^sR`>|Sy{2oJ+OlD*7|+FPQ8^}
zAvFcGJ$vWAz5A1o^$5zY-Y@QbCgJLdpZawlxhub1bbq>i|KGKp%d(HeG_U@ZdS&I+
zsf%Czt4o&LKc5>ko%pGkr>!4cL4kUYYaN2lOWfSC`p^B8`|r<9@pOJXdz*6%=m?Py
zL5-kAe_ul9FWT%idGh4DR-wrr?^rzVX04g!C3R$tUPR587lD<}=a##q&s0-W3%l%e
zcK6~%i(JGPUb-=3nZk-yS4!r_|NnLU(;;sC88RDZ={Xkf@tb9GatZf}RckLV_n-YE
z`t&s2)mCr5|JD&qxVqb<;DJNskB9AN#S5;li&c|vbvyC46I30)|86eKz#_w>#~7C8
zX%Pb+nFA#kmRSx70sR@rL-*f5EWck?0=&&iPUM2*%<Av&O#7c*zp{pnW3`uk<Ymiw
zcHjPdKHvTA@vhhFR+nGixpSx5^6Zq9l&!f}N@VBmsCd8k`zcW6vBp>Y0vA8O_}qz6
zp%+i~M}65fWix2)!qs)<udaB$+xcA1xNFfOC1X}g1%(H10ynZV){ApoI)35H{$8Vr
zlP+&Fk8b+F@V@TMq5Jugk3nZJfZTas^u;y1pePrX(=YcVowTTR<C8f%S&vh2pLK#8
zX!)N>V}o7V`hy2USBHg4r(9jI?Apq=6aTcm`8PejPSgJ1kHvr9mG2j>{c?ZqB140@
z3$y2!uC@#*J-D(@);i4k@s+!;Uo?H%b>Zr@wb8EXCae1OCM|VMUwf;&cGBW+cXz(I
zvGMR*5$1Exf8N@*lxfYmAG7kCni!a_a%32ou4vWWF)MfVhu{fUE5ou)mv5AY4jc$L
z9Qe#+rTOGf-o;H-*}F1pChPh#FovDCz6?5TLqJeaae7?U%E$wr;$G)ZY1L;bSXo7t
z)XLA@d27nS&{+EyTd&6%*MjEE-|zo_@6MKMYolj-wqCvK=*#-ygmV9huh--Ak1gO1
zSh{@qX<qX?0Z%oz#=2k5&H8thQ&`O-CudF0?QLhz_`JQfb@gKVU;ATc&EH!4``aS!
zqL+t0fp&p!zgOiwO(!x*?D{3i!})tYw%u-gq-FhD*?O<pfn9lbtuFp&sQUU!m6eq>
zZB}{iGfqy<Me$x-OdK~@OcrD@t=aZA>GuB>0trvE;VURiW;QJ2+`t}T{_fl)ZTGF&
zoAwnXg65;9vzj!lGPZrY*;YDvO_lHS1G!Jnf3pKE0d&1(`s4TX{eO<`yR9R$wEuPX
z%2zRSUs@GE^SOBZhiS#C`T4tEs!3WFEm_R_y!Y0+#m1GUCw?7Z=AUu-%Pgs!t;_FU
zX??bS*DI~c_j|uTImj+Qg<F5m1(pcVn3B5xyeXpEVKW$VYijm@rt(>0SD!Y2eMdk3
z9^VFE!)?C#!WXCB+Ossn;p?{BdBS@G{cS$B<lNfg`R~tj`|G#%Y6dSm@#W>^?6v7%
zxvcKScKh94rVz09z^{KwmA6mvtLKVk+AX-XN(MH-!6J|m(Rldy=cm`~b4|oMdAKK)
zi}Oug;BaZK=^CrGpb^+!<puq3UhDYR_QZKVJzx6L^=WZ@)k{_5$szYmLmk}Q+KwDO
z8oIk7EOy=0xpQ;V*1bwOx@w-t^&fMVab9?Qjxl6z?dspA{j0_P##~+$SNd}D)mK?j
zth#ZQ&7s22<BHFkURo8Zec5yFqMFmX+h@F;RaX%_VaKw%BA!M!L5{MhoBrt=AgfJ5
znTchV&jRP!1)aTo6DLQyf(DJN`JSJsoSUOL7c#jqO?-t+%$h$t^_bVZjNxs1mEz(*
zb;Syei{YiNkBh$@T|4J>MqgNULFo6}#oMf|f83tCo@c`=-wO<@_hzgDT{nHx{!<?V
z(>o4}<t!SC2VU_>mV&JnaA0U`6WOt#ddnIQyF|T@dqFwkTHBRn&|yz0{{!2E`bxX~
z-2MFgrq%xb)~WVqsX{};<c8vgtrnMGGR%gytr{4Zd=(8=q#qS_yZ`>-{dC_#e(-@l
z38su^yMLXI|92_t?zi3ls^0R1J-1$HsV1fuqw)Ayud(*Dmm9BK38{Rsu-)ez``<ZJ
zrlbhHeif1hPS;I2-7z=0HJRQB?NJ6btwEz`zG@4MBi^Ro-gmiZ*^ZD|te<~(-)#Y}
z3vArXYE}A5<=3K$?G38`uGhT2wl;0rs|AkDGPAs==@@D+KRd(FdEK5*UdEG4-`?8V
z_c%x4!FMJ-%ZQnZ55M1MXMhICf|IO|qT0NE-!Qn`uM}NSn(pN{`FkfH$ZigWh66i6
zW16$(&C{FJ9vUBY>Cz>a=5?TXS<v+K*X!~6cXyXhe|vlT{M{V73J<iQhk9vmpIQht
zpkXU3TgmDfM|Y*_|99K`?e3EAkPw^#GWQm2tn`n(0_Z>u7FO1iEu6wK-#5B;i%pt*
zIKDwvAxGhX3~15kK7NQs@CG8D7hxNtK2O_wGw!0g6)gWhR|B0gf^_=Dkt0V=+}m62
zI{DA5ZPPAY3c9(!et(aQ<)=F)7SfFILIs|J2i|bR@7mhK3N10$Xd5VOOk#V@&%SBt
zk|k%%Dpd~bVqWwdYO%t!8Suj_Kua{-+}a{vWc~W`vhVixw6jtt&zzZ(c(@I+u8ez!
zPLV5L*#7@^46vAtQ@o(279teYI%}VZ$jwh1<eq8Ttlwc+0vQfzEEd>sgeOckJ}GID
z&5sAop?swe4m57cxTth7gh_-&;D_e{OIHU&<A|Se(2!+dx~H_DGNON;Ro<?}l@Y&7
z@*e8OE|!NnHh>?rc4KW`%yR$v)1Ev@v8?*CVoTQ5RlBm@xF4_wjSo*~zG}apxkn1>
z_dP)g4vUKA!u|=on`++a2N@&^U<a83TI|-!Eq-c8;bWgF2HE(mtW`E&E;y%s)CMJB
zmEz~;rXFzcKHgKRA;My#e1IqHyu~GW5BfnO<J^N;`u1<^byb&cvsu&lBysC(=tjnd
zt1LQ#y?1t%u6}cSyFVMR)RPafn^HQTJbw<_PXrzAzrHT^wZ%C$raJuxLJ6wutMAv#
zGr&r{^@16<t$ZFuwaxhVM0DDTc_E)RRGmG$P#F>kSDZmZSYN)BboTX`>B}ZZMa{~%
zP<m@iCaABq^WU%6ORK-X+f@7eTa`co7n7Zqz?C~@8y0*zIQ3cQ6w%)=93<hxHwm_l
zjGdyJBeuUgyX_vs3q$Czjs**-&2x0M$^ERbu*$kc-|yGQH#Ie-fKG*J1Px3T75zB9
zp1FmWCFDS=nD)=TKZ1}V@4|ge{@2_7vPA5Cy6*x%q~ZBW8G9N|{qy5vS~PoXR22LO
zm*Wk^0v}=-V_&TL5%Tj#S8gWLtgYYfZZtB2m?YqEz=`Sat}vaFuZJ5ii@mapb%jj*
zG@b&Dp-VweWkF5I8`q$Y_%}58Hb}0i;f0nJ42<hVUWmx+=^i@$e0R#TITH`7f7-ig
zehC*e4P}Xg)36&X4fkcBq~QV~j#Ve#svcd!Q7{RyjWHvrv7v$C<>jrdYknIZ{^ER@
zrKE#9|B_u{A=D!)<~OLOZMfCGY$Ze4n;VL&!`4pXl{ULk-hHm1w`*0!kz=3*S$|>=
zRI+7rGKSUvw=$@M>inR`_}ql?N#fUa)z0}4Kdk6(NKM<YY{`-tk*nJI<;@;*b8=1u
zb)|ChZ*TJj)xD<|_uFZG{P?j{(!NyiLoValgIW5sny13g$WVA-%ES_}_gUBlL5MZy
zJVBHB-CbQzI@RY*ShGfFa((HmD=UM-!k$S~+}~HLYGM*HY4T**-=H?{?1s-gVL>b(
zroxgi%O0-<>Bpa4($P5ZMf0mmV}@QBEbm14gVHaS6>Hrk2?+~I-rb2TnFiX^K8NMR
z!B;H@;Rnh+h-Fed*tp0storA{Y3*>AUlZQo(qO8qd-hC#tW`<I)<cetjzIwd0dEWW
z6dp_mt(x!@d@%h!BO7cLWSp+UEQa;_Y)kkc@w*)~$!%(87RJTR?HbIQ@$TxWrAwB$
zn3%tQadEM>{3BzgX~G(Mw#xV4MXR0Ej6ZSlP4lw<oPl#yS3b6ooM#c)#5{Yaz1nk`
zH9AF4_eq-yLW7{uP3Qu{>*)ApvsN26Z=HByCl4fh$%$<^!gK8i>H<-Y63hjnSxhs3
zsz2@2e?RT}b{pMxqcX2R&&JA^+umJHjynGKkx{eh>9?0xbTB}S1&@B!?%GxmlTn_v
zPDFG%(#e|FK!xzNXJ=>6zO&lj?&p#_rPpJHgoTx%%giRvHnq2pH>o`UTA09FTGi<w
z%4AjiRsO!-ge`0ShRW#PpE_;p`LO5TjmqELzcc&ft4W{(J+2-qg5*3#7J&?<#uXiD
zmlXA4_~xIO{%DfX&AF45YjZb8LG~7X717WYvi!8>#K!9`MfDo_Dx21O{3)5Zt-OO}
z-rtlG+x15>IV@Oo44Xr%S2JE|m#@3Q5@@R0Fby;^<>b_Kr|$P#qx5q!oBQQCB0?Q5
zGhGph+1l^jye8`U+DCJg7R-=blQ%OEwj53%Bc;(URx52|o_)oxiR;fj1?3QVA&o6d
zV{T?d?@vF!-o<adu;x}<*0s>(5)nJj%r^H24aji!A28pY*D1NC?3dqMtCM$j7N0$S
z=~56U&laDW8+I(9Bdj1>Y~Q_j7k(w~uB9u3WkmM(Meu{lF0e4|wcbAA{55&=@P88-
zvW4$3>UA<O*(okC4&Uy#@od!Hn7;)@<~LvYh)Sk#@2I-ya}6|5+0`|vp`qc`?|+vk
zD!cccSQ)%LYpr|hG0_b!Ek&Q7oh^F3cDq+m(I)5i2dkQ!c;y8*=x01VS8!+DYncRH
zHP;5~ZC4<3XAF!iQqc?gK|^!)atUm!?}B&JE%0NSCAMJMgH?MCc{gRn>T80|QLui$
zC)h0S&I?uBMbckE>mx#g8AZgzyk1{h``Xy;oa2FdRu91k`@hed2yL`Aq_XT%aq+0g
znD8>cs%)and5tYT_g{jJba`M3UUe5Veb>8fm3?1NojP@HBdcG&7ig!zjt5QLDkdf&
zpfezU9@VdVcx}qdWiC%|aa?g%P+YZH=G2Xs*H%VdUn?Y`C6rJ-_2$2cacR{ti?$s2
zCgCz8dU+5$Rvi`;vM@0-F9~1%?9<<OpXU6$%|CaVnc=qj!{C!5>V<FE$E!TO`00MU
zbkUnxlfT+;weO2h6=%xnPAT0JzU1})nTL0A{BC09b_tHOnx1)i*~t?VmCvr5tnPmb
zw9okV_I&g1ZQtMBy?rJsc2~*DHL<&|U5VV3(z)mFx7$VcDxaUs-F`RiTkeewj&?sD
zFkjrl09w*F|L>dhbJG)UcY|uo-rnA+*6(&WgLdj)+#?da%x9(1|5bVwM|HyWf0bRF
zYQ?EiD)YRoA@udGSQFm^Ge6CVTa?M<By`7aY8Rwt2i2mz$_pwZ-ZF;y3Kx9*xv{r6
zaUH0Lu9$q_p}Mr)j;eK!ub%Y2b$&k6nu7-q8dZJCuq=MolWD1{>bmdeGwF@`7uH#e
z>qe=7x|fY*XE(2Myn5!059m0>%B0_y{q3jjtNrcO&L_Jhc6ZsbxuBuC$Nlztd#k=q
zdU<*I>34T`KRw7UZ^9TA+$bNX3R<glZEf_^lj^zganTp`XY5<0B~@`%UzU|on~TSP
zj?QboI<3se-&t?!cE51BxGPWGSNH+PhFfW_0tuzF`{15(NanP7o_M!TVfRM8)8HP<
zd!Y>b<6?Vi&g^bpW7WL%@cNiLdb{5keU5Bi#c%VWq2%42n}*e)>D#jAU0uC?U(~Pf
z@AF?}CWLmgg&aO~$c1^0r>7@qPx0pX`kEgP+d)McXjjC92?CNxqhuQ%+A>Y!*zijH
z^R(!^m7#0X&(GU>Z6OoWJuLy58$N0L^&bB|zJ0%%cT-kD=<AHw?cJxH!k_lf-C3(A
z3M<1IS)^PY(l^{XJ?~14rk38+2?^dhGZWvNy@&K6RQ?6J#DCRX+3oUe2b<mM+-19S
zh32yr+s1$n<Z9=Woz%)L?iCPFnU@>8WG|>uR`at6bO7MP!|mPYs@AT}2nb6*mQ`>y
z?pTkcvi{yLlm05dk5dWwE&H|U+_s#XL2ACUp0L_3<mND0<8b;z#7ygN`JdkIOWjm;
z|9H`#lCGTz83ipqFRf3XiCG(55PF_((^8HN;=Y0o@WMdggH_{-6KR+1^n8N+MNZ6|
zWOOr|dy^G=?A~>UOF&2Md@yU=R^A~~8K_boeAc#mkAutWsvR=6RU!94duVU2>Fn&(
zTl@dl_5IVt<0>3M3tB7xe!c#*OM9I`p`NdJK&WNyuPvUI3qBfjnX>5oRu8Ps<IXm?
z?9FmV`~t(P7w^JP$SVJvA9=y|zkFUs!Hk>X&mXLc3kzns;mv6r@m6FHv}|Eux~Fzw
zckof2Yjd}?u7mWIO9eQ#oc;1<e~1h7imRfw%SyMbYd`(@yuH4Zz}|PeUZ2Z~l>Z8v
zJ^&p|X}mM6^x*3Mf1cZ?U)}uv!WPD;qT=GWyDPpIfg1Xu&S#T9KAj$aYE|fJ6;soz
zDvW&{9TR^1sF1WSTN6|B@#v*Bk+O2LzkQN+{w~nbnW5~sEg{?UrKDx-3`N%TPbzC7
zUG64&2nLiJpL2j!d9xfI*hDv!x_;s;ek$8uG;0BSj1VJ>z=j<T8PyXVU*{M{&KI@(
zHcQv(r}NJSrQcmgZeM$Iapr1XftafmSNrY%Y3%=f_q~dV$(E=i+j4KuYF$^dc46%9
zvQE2C`TpVyHix}+eH@*8Yl~s-t?w^?_sLpEJUJzKq<fpLV1ll;_T=>WwP9iF<8oiz
z+Mcf;7#KKd`t<ao=siCkb#F>M%m!NW;!+$PAn<{;@j!z^XK#-7aX)#Z!<G{#Ysn^8
zU8&8`W4v}|*ZlL6NX3rQh1J2u$4kqWg#20b7PLQ!L!rUpEt8bP)jz9vCnRrO)&2bW
z^V8Y?=kK*{oV;2~c>n*B@UL-Ky{kMgMS3`KC<v%HrllA&vZe?Y{@v58)Ght*Y3P-}
zk^sr6`*}Lfb#OBs>S$`(*I>NB#ZigJOF}_$0z;&SLiKy^uW_M&?>!HDw>EljSn00S
z@AiJRuIt)W`ufV==QaM^ColWkKA%^ea&eJs+K1x5zrLnzzjZ4ra!0{J$?cbZt$ttg
z+<NJ{b$)SmKU0m3OFuq3T4w+E*{jL^cA8S}FR>h6+;4ZwM{UpheZQZ)+x^}wdt=`H
zeX(_aU&s4P9FWbfnRB|YL7iz0XlHu!>RqRAf%fOVTa@-Oqb0t6!dLb{<_%E{Guj&B
zS)>kqmSwzlH<)LGl^2VPrr?9=^Ld}adg%XzBQ8ZK9&~7Q>6Ka&)xCAMxz@uX|36a?
zy!0_-U~pjYba4zhTi<=K2Q*G&!m2c}BV$78^K)~HF8i9_oFBC@sWno};WXQeW8v51
zs@MLUmshv+;5Fm(HkWH;`P!d?mPv!oT?HMrXZdo;<TDJfS;b=%baiz<-AL}ADV_4t
zd<SS6;^G4BldWc(v-xa3#%K3l%HI8E)9Ik5)m47=0`@;o`k&&~-;=N`TsR?AbXGje
zE9Ya^rTMn0DL0pT>84KBW?B<$^aQq<y1_w=rK`Dhk>fSp-9k?p<BT^&_}gq!<1T+D
z22L=+qAS*~Hy8eY?Dw8J=HJ%$fA*D>md>2Hde+UTm^o3*-<aipG|Z|0_j8eF%ddTA
zyo=%rkBWZU*k60bW_@YQ*4oF?_Z1FgdF^;DKktWKt;Uoet9nA8l&dUU7L;Avm0@D_
zNjFaUL1tsyg_`O=XYcNQ`?!ZsLvVti_*_`2+!(`Uahhe1o9wk1J=X7_T|LV}9hlcf
zHJ7FoT;0`qY>!EVwUKpb_LiuFp>J2OcmK9=-NE8_EH;7(w*P)SJ}YnJJ6&$|-@otc
zr+@oaX8Cr@<zrQ|i#aO74$M5b$~0p6m8L!+Mnj{B<tZoHL2XA+cc@W^QzkX1Bz0@}
z{Uv;>Qx8H<I?faO;L^!(*6*qjgZaIR#WPp#DthX5`^$kwX7E;yPft&uEuL*Adq?qH
z#nzmgMw|EFoyp8%qZaV~M8e#n&W0&GVN7e}ehVh-0Ea7w!i01tcfEp~5?8kDd28)1
zgS)mLR)LZzsCKwhaF}=5#&>&`^-s)we5`j7fBNrh+xMw@PuDA*_eg@#pR>h#^-_}v
zy}uXZBn{;5{(UQ?cXk6`xEJp=KL4}xVf)M&n0~5lSg_DX%ZvHaW%<c{CnlI|<@a#*
z_1tG@5D)SzBa4mdgHDFmhg!LxPV&|}DY0$iM#IPFKQOY~Q45ftr@#Bw_8Et>y55|#
zIq*tHP(Zc$YVPaP6|j(ET;A|bf8&`GNwND)KR!3p6?SO2s(A!DwD3;&gG<BKUAv;r
zSw5Hf{?bs1Ws|}MfmzdeHb_aw%Epz)q?MOW<5<9!omTb*6t7@Iixd{5GEHK<)-k89
zCYI0bpe{5WD8w@Q=M+tSm-3>$L7sI^X~gm^7pEE@SS7jU@Zq|YBtK}FHZ<h3^p)h4
zY)uV6V*WWv2_pO>^nkGB8nHSZvB{t_UDDH+3o1*=s?0J@@4IsCTGZW2w*%r#yl$Ng
zt1~+rdZHa2mRz`@qqwf#qQCn{&+~+$@>@OYkF$f_2PV=&5^nx^;uaoV?tW(f?~IoW
zQqXSMj^G2vjMqQ~cHPJBc#rDp-#aEfpIbf;RPQ|AcV3#KB5;A?6rK%c(yC0$u9$R}
zen|M%JdIP~fR(D79sK0E6laI*bz$vYXMERHu_tZXz0+UJWJ>zuYj<GFDVHfc=w!$)
zF5dj-g}eQv1OtuL;p@fDhVZiVtl1;@_Jnf3Okvw}j*9pN=T;od+B$7st&n`5=fbq5
zX_wA0yq<SNeUYq^>d6JUYSS0O52|T!C}Y{e_j*^j&`H%OwFZXlvO7DuA-)P0{NU2?
zb?f!G$r&bEpapSHZzT86J!SKghiRUu2In-d(9E?Z-?q;>c=g&m<{<g3GdXq#U!~Nq
zJ?sTr6wV@0u=T(uLB?yw;buFk_V7UZ;*B+8AC9Pnx3+dBnwflP@2dHic=q{D>(?91
z{Fm}&pK=R#W7CFhv=neSaFywt)tcxYt2HK&bSqG>9+X$K!`4igHA@P-d+NKFkr7K;
zz=C^$?OQXoN+X!vc*9mtJecMAp$FD+-VyeIL%I2C*6nX!JZ$W$Cda?7od-)|+nMHR
z2nIw&X@$qvZUvnYktTah*x#nm$8_!4sOV_xXVr6D4xDDvl#X@fyB2gd#p#?7<F1pU
zC~n+3_2{DhYwH|e%J-bsOJ2PCaN6dJQ&)@kLYA37SqpOVF00?)-<z9ni`tyl`yzQw
z8K}c?R6O41TJ#*}1DBb;K78U9?t6E)(R^>OP6nnmGnqeeLcQ#u@SDl~%=!t}&Ne^m
z-7b~N#IYf*o_B{bB%)q&RDgCsT%G^#%krS0Af@y<g>4zjvJ5P$UYwq$>z#h?i{pV}
zruKOUU+D-s@P?iL%U}T8Fnq$hQTbW>lbL7VKD)F1UDpZgn=iEV>-lDYPfc(5&Fbc^
z8Ef(E>}>PXA3kh|RC}=FabNL64oM*<V{L=gN!wVsnuMhLywdAe^SJz8q7pIfpYL2%
zrWFTg?US~JhAu;+4A+vplB<&sPb>iK-~+X-W_TPBo*ffe8k&B7p6$h$3Vz1>Tq0sD
zOUz8J&x=1M9lJEA$dzq1?@7do_DPJ--NJ8w|2D%@T~AKW8Ir&h@>xN}{jV2`m+spa
zCs+65;htCxwY~$2Q#lLLHf%a6YVQLn2NW6_)LBX<ubx#f(em29#u;xi-+e!_LsA72
zd_UD5bP6#><$s+#|IZT8lC@`U;p+1$9?f{YWNYNwoa=_x1wxGc+!oAhd?((WdA7xO
zozdq-<`BIc3J-)Dm7ldfxf#xXE%C1K#Gky9Q#y-I%1A&*3+lu{nFzGZtp4}*dgJR!
zXJ?r%>fd;)^7&kK@%WmL5&4CDjOV#cTAtr7KC#2a!K-1a5Tlt2JKW)?S*M*_@4*&P
z?w<0M^Q)e`;bExf|AXtgHyaLvj?9`_QaVjH+ALGvO5s6hW0iZuR?Ejc*Iqr@a`TB+
z=0QOwsBsU9K+*k1Fz@bJw{SBys4Y7@4hS<|d-W>I^7)+Nm?Osm1WxR8aL$-ld->T3
zx!)FRo2U4$v%36?V=lN51QSL21xNO9RSVqi5n_br%lQrJW;>-$iuJlJ-MTgO%gi>1
zeH<-btCp_On0U}Y;O*pd`>uUiE_dO)?4SMBcYZYgEYSIT{t|r6u7g54)8_Q4UORLq
ziVMH&KKakgY}cuqNd?J}JaA0#gA3d0zS@e4h<SCtGC{LYDfjo)K6~BN#5B{oeBGYs
zw(lnf``d<caobAj%cW;p^d87yTzmMJ+wIlQq<38m4UK&J!Y_HQ;lKS#QSGL)ZYVfz
z@o~7gW@A+mq*wxt6COxqifS+Yd+o^f3ESSjoM`EGVJc{TT)|+QgNdC=ef3}dPk+|!
zKk;v!`5C`rE&j<<xzA0QJbjM#!9$BS+MkGI;d4A-EO?S#z9yjV)8zRl8kyOjtXSMP
zss7LL`YFkMmTp$o)=#fR=TF`Je&25ai60tF_XILHRLyr~y}LK}=7Qi;EE_I{rd1%-
zis~Dt7%}cV{QMk;!UN65zI|dp4+_tp%x?ZK<X%p_FI)28XU_d!=j>ZvyXVfjozJ9x
zuK)jQ{g!0{{l`^>X71SI6CXc+<_QZ63yX)QU!!z&buZnkGbqeHbZ_R~m7Y_TXV2R#
zr+mNoakhWThHYE7o@C~?QP|aaReawE)|G44Y|;Jw`}f%guRzNyjbE%f7%s(BC%U5i
zO5#<XYdujHZoJ5P@Id{>3oT_UD`nU`(N2*FEB&1pr>1SV1WqPy+!@bay{-Sf>&@Fc
zhQH1>r++Kkm-ppoTg={H_AygWt~%K)_4-nNmjAUc(RZcPXRpb<w<i*G+TqRp_51&P
zS#CddmDc0vwSC))pZkHXCrG`#%=g>&Blo{;+kO(XlImf>jdv>>uipRnZTqJei~CO<
za8O#Y;QFo~kGjw1PrfZH%l`WM`swd$-&Y5Pgs9B_c_#hIlF5EWduH2QdGLP!pVRw2
zii<bTseZTf)5QLoBQ>9YKA%5*cK*Jb?;_&j^muuB)8zlM?UtUcZWK{^vDC42;@pFw
zth&0orsu;$LT1>D<hi8zaQIAjaIR>qUAfH1IAW_y!_}mmlGH$?YA5zVK|0&(Jf<~y
z@%qQw8JKnoUf9GS%o@HnFmpoa?_EoCZ*TJjO>|a1Y!zRY>M^ThMdMY_ncGPlkNne4
zPVM;ju6)1o`{j%m*4I4MUUcv(tc|gx=W&1ipT&RvecwNQ^Le{y(2m2M58I?u{{8v+
zZ2QUYZzQXk^X{5^zF*lG=sQDZ{okkh^%LK{%hS}>_CDFObyJG|-Y-EvpV$9O-}z*c
z_mU+`j{Hgc{r}(l|9#~<=gj-=(y(>0^2gG&wcD-2xLKG$1G6`Gm%oq5FXm&s&tc)s
zk}~h$D~=6rnt~5z%X6uLMz28QTKmLj#K)_tx_0j0wY7}b%RS}9_u{lBP$zR4Q&h3(
z-D#fpOV(Ge_<M}2$?xeb(7{V@Zf*76_j&I76Pe5Bn!QuC``GD!;`+XCrj}2q1V8!l
zxPSWjx^J7)rmaq!Z#A2(E;~E>sk8jA380}|(1u#MY^5b^?dn;}=hyAp^Yhv4<ZqYH
z+kd-}{Oqr3g;kjKuNRA-wg~$P?CoQVGX3}cjPd!NtESJN+XN~t*tqdx%O#&{OTDM}
zIbH79!xk<&udQJ|>no?;poBl?SGXwU+OoUsXPQ{nn5Qe4VCuyZA!Gwj=Ig{cM8r-^
z+WGX;so9-YRkwSM7`6LL{@gtG)i?okE{sDJQ-97c|H`D(?^VoXeBUz%zgcP;xxVhf
z9L-v*0D&o2PunRxmn~lT^Czff_5auPv-xq>`V|LR#c#wfynbsb=mMIjQ^Vr~->(0t
zeKrboM#I~Nh3|Bi#2>Z)bV3=l_S9T|>A|4v&EH+S#ZJ20{|bDrd(5Wp_wD<6_rv#R
z*~dvo8YxKdoLUpP`OJegpN)T=E!5>*z<<`{Y8q>p>CM7L%YLh8dY(TnUtbeq16oU%
z=6k(--{-kT7cJJl&Nf>!O-4eh=()b6?Zktt>|LV%KTNm(J+sHh{@vTRrsuN*<JMmE
zaz1dL$+a<QrDndtatocp%-%QN^}94@#{?=V)LK+Qw-qrk?G(4LS<3hNi1f54bz6GC
zmH(^*lW)t-`uO106}M@Brm)qQ&I!AGU`bj;mf8wClf%Kr9&6V>&)y%MxAW+l)~c(a
z;WMkbuU@&*Q5XIDMsmNYvB}o{yeI3fU+nSC1s(qRzW)F3pqQAPYt~n#mRyf5pDVe*
z)Vk+0|JhG-ye?m2k}8hgQ&D*8xM{!|Lvvl;1z%&XuZ>oZigS3r>fnRUS!v7W)qFac
zCJ_0!{M@p}aNk8XZ#EpBv;4U2wVZI-#rLlFo)wl{Bc=QQ%X0f%u@hIPB&_|qz`kdf
z#jLC~7hg}+4nNhYKJSHF^0Af!Tez;YKl6@$&-i&(lv+aB(?eg@y<c<CtFz(DnHQj?
zm7wgwvBM={<zl|q-}YWfEIql&fQLn3Mq1-#zWo8$^8WshkxjYEbM5l<edejp-q(HK
zefGLk$lh<avd=D9xK(oU*U(?z_r9+!x>I<3=3kQyt9&0vOMQ;ooOX7_j%n9yuim(B
zdOaqYE%Lm@V;<uLmA7-Z&zwK^U46!Z;(~&JdtcX;FO7*ZpZxz-`2MWCDN7A4=Po`M
zZoboN`P#U>QCqIP0v%R(A~Jn$YMl%7Rw;*T5%*o*vfKY?oVj&XX_TqL+Jm8MMPDC#
z*2%E?P$tX&-S_{llT^LGDYg5}y}h?xu5s*JCOp6L+048zsXiP&yB(Y>_U*Yg#pCn&
zjK$jN4O4yBEvt>)p#W=y7)%B=r6pCFGC-#n$g`fa|7LXYc*w2Ex9jxz^ZsN;$?whh
zIn`~#mqS~ArCoXnI<9FZ$B(!9^|#lEubQu`qhn%hDqs60aOL{-=Ehd0uS+*Ai$8q5
zC+uv()?2GWS3g;|``xBEzuTMD^zD8;Xx>!wvuO98hSEab6|b)U+`VhplO>b=CS8xK
zKKtj?|2H=`zin7~wS3L<!~FI!Vmc8CY>{gjR;Mj~mG(8tDPhsFlT)r<y_&}M_VxPx
zdZ2qPD*qhSuM6bj;!^vSaqa%>8rRKsOFrhW$h;Q+<B<3nKB>^_x483|W$VA}X+H3U
zV@Y1gR_(vtLCvPM+K4QnCmfM;CBf8dqgPEtN_p}8FZ{=rY^lhKXD+>YMS_osL%~3o
zNnPJE{Mz1)Zr{rG***L!wR&2|x4G|@Mb7+nwesw{m`y33r=EiL>YhGd|F0Nyuh-Li
z)$gZr>+cCTXZd_iVRF>0jVte8yY}Fb&-QcY{60%R-ZgP*UWw_Z%wub=HC^T1xJ9Mm
z*yDG5KKuPV|NoD_@sHJx_fO7B+nCiG$t#te^L~B(-`6W1e2ln$fnhUS`r5Mpf4|Q*
z%`|<GJvC^<z0+Seug>0()wRX#|M4uTgV!Idx)#3!v;{fiSHxe7_J;c`Ce2r~g3l!^
zb!l)t0Ubl(P<X)EIB8MCnf3lTdPX@ck>zi^*QP%2^fd5b5pYOgV=ZBR;Xmh(?nQ=I
z6~6Z`+hyj9+1_hCW>J4!wtNQTMgF=E&5Q3{UH_~8rFZ-!P#wKy>niEE%n5~imZdUp
z`TFI|8*{NQzkcNw-mQ489sjed#cAOb#jV@6oeK81O=as{TeVuM|MwGh`^;(j6^}aA
zgMRgYcRH<_acx~*+0w`rRrgoc2;b#em33_G?OEB(Ye3D0_&<-t7ndbUbFQ#2nYHZC
zV)?%()||BZR2!%Kz`XGa&$YWR{q-OGI2%62cipA-#p<xc{eX`#eP+Y;m4{#Txh9Hm
zC_K<=e6`7HXVusGj%f@L5yeYH*uBoS%e}U&_5bZte%ayiv$M0GK9>K#<Ha$*$6I$6
zKkv#bS=#8MTfg$GmiU6m)nS+ObFw{s_AcAJ_t&e{lk<w6zOlc!QBCJw#pB*f_wMDT
zEzkPdG||_5`z5i?C3)*sFh<t;n1nyyTCy+7`YY&|#hD&Ir)}TkDkUvFH};a%Hm233
zrI+`&W%4F8`K{9xTrlxZfrU=`{Mv6UhyC}IUUU^d`T4wk{xY5HUk1F4_S_+o{|z<x
zrkqH~aj0V7z4UlRh)BEo{7swLv?bR}uD%Exm=GwKdEjBM=%*vU#EL_5N}g^ynrOkH
z@IZ?3tl!mNtBeDaOV@a2348)w;^EpYHq+7FSK`XD_?_3+AI=U4c)kABKSwDE&=Ip|
zdCnc}7Qg-Xi}Wqf6!w|f=I8IYyn3;?U+izx-`ekY)9bdzCCA?0o<AM5u6Ht<X{qy%
zwb9#WUAHSx*yy;8Eo<wum24HJ1*_j4xBs{C=KDRL&rLSJS8=#zM!v-V3p-y#m~gE6
zYwEUq{?)TPw=8Mccdg+=ifPE&*Dp7pb7x)ynlb&p|Nq}}+mG3XY3uG?P?~V{BdC>S
zsb-#6^7IzN>pod)7w(5ySL!w`<Cf=OapArvlrYz)`}<zK1^*wd<v%;!cJA%7D^1GZ
zPwKk0-N#NBT==PdU&Ibi9!8AmY_HACb`{-xWgx>Ma3Y-X?7J%pug}f3e!6US-X_Vg
zH4%x^ST9(ul9Ji;?N;{L?<RFm@2rWP%xzlup^;r~!s~Ur&)xCxVqPO2Q_#3&%a)Ej
zj-`xIcSByiTD{(^dEKtUYZbo6$)?6vZ+?lsf9ss>_n4n2-0hO&URP|j{d7Y4+2+sk
zQOe&A%m3T3)A9QB{eMzFOF#RiTf90nENs?w%f~&&Yl1b;Te;_6+bkzve8%vZ3>zEU
zlOw|ZSAxqf|BRTqrz*%>E8}ty*R3zLw#yCedCysy|1+}Q@j#yS*t>W)R{4pkr>E^q
zusErh!I<!TS=h;PH~FKF3wMGJ{d}8Wzq{sD@O-Je2h-E9t&7b*r!m**klk#n%a$4+
zx=a6uo4u*LRP*)!nm<i*N^V3>zRe@Gf9J2?b6oZ-JvI+hSFf9F`jh=7Y&@Pr;Q?FY
zw|9;|FO>ez=3BaDN5H?=|NlMSA-!Zr;+`HxP;X8_bHP*Ht>0FpZR-<NxU&9DcG!x2
z?|Bxy3jg?Zk7&u2>%aDG_Wz`3T)t#>^wzCgJu54BW;B#;TK3odT(EIqd#}@@a|x^B
z)WeHs<?y}SlRv%6V|lUOuZ*x&d_m32C;z<ws{8I7^|?GfljBMAfhlIYiqbX&DJjU;
z`OJV0%y9hhS)dl9WBO1j^S#`pe+PHG$$YupeBY;=Au~bc`~z!7UN1k98CPuE)|_2C
zXY%!gC89A`KPxv+KDW=fa?Qa@mc@K(xl0QdPdpg<x5Iex)ymG8vnMUvoNeXom;VS@
zU(+%F`jv-$eSAN!uCFtFIMw7=?e*C5nYGh&B8?L7m)yG&CF<<#{J89@$L|xzE9RP7
z+_`hd=A~Qg<Jx(jIeOGD2*f4qzbbMwSKhxOAmfcwM8KpMMm8Ek@8@r@&WAVPICl6u
zyxtJi+q+JO6FOpcVr@fq_J(<t&t`7QyKA-iT+6jpp!-r>nO8`?z0R<FS=jzhr?fv^
zaOR)6Rp;MB`G1Zj;+s~Q`5xW(|KD%W5y^|bUz^0NeEYfGcT3|0t51LS|9idvl%Tsz
z;{0p3q_^Lz0$m6hxMf?*Kek6xg8e3**4v$PDJSN)l8k~uqeF9G^VKZhyP0eeUzuke
zwYoCp$BML#V$1*ER)1ZGXrXgF@k{6wOsIWl`uKdI+vVPMe)jijtu>$fwOd14@e`yO
zud_vL)j1Fv9;<5q`{sGj(S3`o=VfYZY8o0l&5c~PtNW&Cc#L7{LC_%>dHesC8He6H
z<tO_(N$Sc~*-O*(<L7<)_UGrxgz0tv+NAR)?5+Mji!t=B=(|?&ID>A1Y^^U#r^n6u
z6d9*rAj+8D*)Z)yTqpnWB^wk1U8)YfUdj?-&AGv^<0yPlZo_Yu6A7jFXBj9##yeu9
z6Rs{@xoVZr-L*NFm-&9WzW-k+=yom85F+!MsQl3KfatwdUsp7wFFU;|mE()mEY;r|
z`)hL!^=B`8<ucn_a(3HE(7e9!{GUB@s$Q*pwpC0gLIHHr`to^IUjJUs|Cbpu@jhq%
ziP;=IiUC48lTTfWyma-x+Qx?~wtSVDuq)uPgsuA=t}u0fmtF?s@z`LdSqHO_J46$r
z8N=BlbfwlFU)4V|>w0|s-z}n?b<bv|pP6eDzAk2_(H&tw3rFyR35GX?$7QE~lG7KM
z(bX`G^8&+av$cn3g*BKaOyK~{4nzteqHvyIL_oZnYa^3n7q55l@dYlw771y6J`(@h
zCi#p5WN`6BNW*_2>7<!&!j{GVt^fD)xvC7`?A^<I?=Y@gy3{o*JA3JxH9D!fCbz?)
z)1QAy<;}afN%g7Ro)h|wk0Nf&`>^c#b?*(QC(g~<Ke@_ayS>7-<=@^_xhm;)2U&lB
zEejNIIPjIJIE!i1YSpa1&+A{uO;wiaj<ru?>tJBIDH^dYC$cR6#9e_C#f(gAB>ymo
zh>M>FEw%tHh>u*hV8H?hKkK(9o3E|9)^>Fn<CTdALv8ctzJB-a+H?~ZzQ_f;mK@yY
zcKiV2?}|mu6^){CqM9<#(hHTe??J}+7#LaZXc^>(86DWQ+%%0P;;vQDF-Tv+p^if!
z;cUX({GCt5jBkfBug=ZQ{q*55|LIw#*-N%;xpHrhmR!HLj+k_5=-n;ev%lJ`IxOP%
zL3*X;f}byxH=gqQdHWyxSxH_NrAgP$AO6;=v|E^?ILkZr98=xumy6{&m%%#pl}aD3
z{jGjFQ`h>;O}8Y`WAmA(KRbD5CUm*pI}s0;zjrLnuJ?KwN0>USVhqz|ULc+HGA%kP
z`f65`)q?HYuUBQ-fB*V*=J8#H;=GM71y=B%->!c-=SqU_>WwEuqkKx>+YRsNY)Hx5
zX}jlbb@iKMKJf67fP;cL6H5gD#oB9YB8?0T65?H%S46Qb*uVe2-Ewx&F828ASFbLe
z^PH6_Sae3HT{Kgx>$Bsfn^*r^c(L(s;Ptf0s{>W$z^C)~sBK8eYqfo1{_VTe)6;El
zugictWeN=r-&i>|$TjUuTLroTR!lc4B_1?xVBpOHI=b0zIs5BtYlV5&fkv1$pI0^>
z2w~;o=32T>DY9U-=3JdHqlo3F&OV2_n1S&+M@Vbel5IvCH(osu5c6%@61DOjX$yE*
zKvfb$qmAGKw$&RifHLB`b$Zn&qobpr9u<!_In5|j{bpmDXM?+3rHhr7)swaPwW~9x
zWd#RM1`qOhs3^(*dBFbm{JMyZPFY!5pl*(ly?OPw9MDz2F3jtu$5pMYJooMlBU8J^
zf>fq&<@*!kmaeScuCr$5l4V&J0v9P=E9@wL{unwG+`z!JQz#;53TMV!DU<yDwekID
z@-<Fh4cGyl8miQHXt?@AaL4C!)~Ub0z5T}D%;x-c;nuMH-EYlSu2^A^z4qVF^Yvo9
zTcUi8!`JV8CT00*#o{%=i%O&R|2&)DmDln0u>8M(w)S?{(;P8HCsm8CMW)~UYvGV!
z#UkY-c`dP&En@N9%Z4oL5Ec3a=0??C(NA}>JL6~U&%2UXd;H@RrPBwE3cMjjq7Ng}
z8n(mR_y2wCSubN!{Pq6-zxU7jT%R{j&Nw3~D9Gs9b15mQGuc_PVR!F%8AoMuoM~}z
zu9#OFc{XA0mO!P1ASEkkgflS32^8d&Y)y`r+WKR!f#$Ie@H|n2J1fVAv>gRgr%qke
zUlNs>x$;GG+W{X=lNPZX)APFCZ0bL5n=pBGVP*xq;rn4yL)wNYU*m{OXt++WW;EM*
zYOZa$+k*+LQaw^@!m|6`n0g0AtUq3()?Df%<_E7@<Afs;uEg-Nah*w&&yb%m@862+
z%MMgPinb5E42)s-byS5<x;K7$v>`-9-Dp*N67!{t*NqIFFHEeJH8v|V&SJR?PjxJN
z)CG7%y4WJuy3J(pZc2v)*(QC52Gifq?g%z!ie_+FpJFNT4^ms8pdiE{zo$M%<(lo<
z<cF}0)eQ_xH-#gN%p=tj*i)G{v7d*I_e&@`G?cP%=nH<B<>0IlskT6K(lNJi&C&?#
zy=JlSLv1+}3IY;5lXvEBOtzPfy(t0BTN6?lnbt(IJul<%+3t`fd(DJt&B0Yq1QyAj
zOzuOt-9~l8jfn?OxrNV*vSI@tll#D!k!g)xbilI7^-P+QYwo^eiC8_^!_X*VvV@Ex
zY`FQJP{gGd8iE_vmw)2*-)m~?2G-ipkj}!fp(<^qga%VGw}o-U>`Po5CLOferjiZ`
zTL%Wle9kLjV&18)7i3D_JNWQz;jhSM>JbCyP{#S7o7zu08TI}VU9onCb}MV=f9>tx
zO;0A|OtOz)mz7)-XcY1JyL$UfNK2xjL7rufbZns70e<aMGGIUL(Qs(E+P(VN48Z~p
z7OrNa)ir&!%TzZVx0Cza;JfZv%0uYP6X-0%#-qiu(y@}M;L#9JDx6T;c;vh1ruz7I
z9SlsDH4LoxI7C%_n-zY=h_N@+``G>}FE;JjF}?gpVdt(kH2h|rBe}-<+t(fS2YLh;
zSp;SzHZIJFk^A|(uJTW7+RdHzAG?>k7N2^0M)YgZz1z<{0x#U&*#<hUe@@M(lb_~&
z-;?fia^F6?moHvSxOFQ^Q%`T+hW8cu+qP}<a&&AA2@m&9e3-HQ;lsq=i*M=Amu9?H
z6Ic7}opj@`3pUkyz7svoc5zu{ZP;{j>f2+C@Q#ja<I&!eJlC$DO!)dp$S93PV1`@c
zv~!F*zx9Qu{JwW3-eT{sG?y<QUu^dMG`C+~w=`7sa>aG${UPb;%R|D#W*t0pa^1H4
z`*xYx+0xr@gStnc5f0zkW;18YXFd3wn_oRUrtqk!5MTT8zjMAG11)L<^)7R7Z}ar`
zKeTbro;!PvwcCABT)A?k;cmPCe?EhbZ;6%{etY@C1%>DHs@H+qMBjeaSSlQtrLTR~
zrdIbtLdu4y+)KUd<}hB<kX$oO`aCp8H#CT|nrM4ZZZql3@GqXv!*_J)j*OCN6UCn&
zn<41H(CEWrQv5YO@4k-k-%Xy(>!lj@J}o{SJNe|Q#xwafkEK6>MvTJN#mqc8<@lT5
zyYK%!XY+sN`5HH;g%fN(9ufZZX7hP31Bof1aqi^0V^%xM-bU>N6}s2fM1H#WeP6hk
zZj{Q!j1bWFf%>1P<H5()p4Qua=FPo(_wwxGt6nY*ijUX7d-v|My`V`a4^Pid$q8H6
z&E`MP67e~4>deLOS)~qrerxGB@8Bu5a5FLJq@O}V!*N!xE+(V(>wL<j4_@6Nm~wUf
zVZCU9Pe0a3*fDV^OxW2ljdg~`j;z?g<~6sz?_F*hwLIqIn?Jk$F64P3JpV^aNT}-m
zomFQHkDmawp<iELKmWrfc0QR2yWj2d?z4ErVSHn?<jOGXe?J~S{qy<!^l8(?UQhX3
z^W~!Z=_c0BCF_O#Z36ASuJk`?eBQ>n;i}jp21XVe<qHBuED^m@YlOE=@m+T!VeW-4
zb9koZ=Xl{3E|qX~S!o34hN^^%5=u-QKD!&P#rST|y#JDGLsr}K>-+zeb{>DMxqbhG
zChj-uPh}^3n!f+f(mkI}X{WiZU{hVc=aUzBi*Le`x)1Mmzn=!0J1TlI(f!oZ>G64S
zuXjG5XS~^Mt4>4O<hn15<$ZS^kI<iUFtj$_INVgZ^!mEk<kIcu|2{L{KQTflZJJO4
zTliYOs=1cMlcaN^pU*x2Yv-axN|I7iMf1*eCmTh4PMSG$$$i#COHG5Mbf*8ySkEKT
zzwV#eN}ai;-?jvs?R+J(n;%govDhdtkdC$8y78(^zSYg>c{3%LT^Snp2=DmJpMN6%
z`n!o4Iy);b`6y)AUMsKt_);_0N<w1-|GHV~)8|*u_*uzoGq3K~%d&t#=9!?8O35`_
z@(NDtZuh9K-#^oHm1&^q;b8LxR^M(UrzRvgTw4>VJS)?x{$EXIj!(+9ygNGr_x=C-
z{&b+btg3i?&BmO&yFx*0(Tp9kW6kHL?|nbdwmRkGqocxQ*I#EBT;KJ-W$y9H&l``+
z89%Q)rMbN4^5Ol<IXC<&&z%`Lk27OtgZb_4Gd5qdTJxAaVsgBwK-Pw5H~l#wOPw4T
z811=q3Uf-9O0EG-9UoZD#BaB?{8;nq_N>JR<7JnNCR}~J_xIiRX8Nlo7l0Pa$&}ql
zEc>=9ZClpdtEgk(%&V3zU7FSq`g;AV@HcC}{l5SI-kpF~v$EGseDo*@G@5aS;RR?(
zcd6&=pZ@i~CiC#|o!Wix>$<|<-@kpEC7r(a>)QOSzh9)AtiBq#%i;L)#)S0W2l?v~
z($;42hVe>e7lfK$J+<BK>*t#2!e_6e8`~x%FJ66uC6#H8<QhYxh}z%G2akYDd;tfA
zd=@cj$u(iswMWj~yjBVBD(iFX`F>^RBFRO0c~<+nkFC7_tKI&O<Gq^Cz89@lG&&rZ
z<Cd7XP$za*h+OTLz{*c2)i0lOxVqp?m#Frc2dkcL1YP+&BXjS(H<8CdXONxx^z`)G
zhW8QkH}1Rio@ZHBLWFU=sdBjdtkl)BQ+soyB(Cwq@iJsLgl#T2{d}!*?Zo*XA7>jy
z{N1tYjHW(oklC(TEBLY}@Lb#ThcWRIv}}72-DtVlYsr=!0l(NEU%Dwg_1ingm7L<g
z%l7&3FtYs7E;w4*?IItX$uAkX)V?mmJxczs{rgy(T+@iP((mr?kFWc_`~J+EYrLoF
zZ1kIbe*XVI&%q~c+^KrKwg|MPy;VF;<N2K8zKop>8)v08XI<F5>()lkuMx897T0gy
z)V%-u-uETjwuRaKzIop7Lhu>ijaph-Dev#?Ewewn<}YZnV&Aod*Y0+o1b^E;Z)6K!
z>$~pDAJ9=7*Lv@6NNk={aESBVx_x$P%~!9VKK<mA=Yo41FNS`0kzB)gw!q@Y?x{OA
zN;=v6@A7|s`8;bec%hvG1LJ@07uQ2qYjyQ>^39fXmj8LKxaeyA9u27+iLPaNyB^i^
zrgbnd{nRSBcl-H?hrK6z{(Y3$(*JGlyE3G)Xua6rVCDE<m!>~?Hap*Jf6{vCxW8Z5
z*UMf#Z?*8CZ?3Ivu=ejo^MAi9-=Cd!y6&lV{KNo_l-Q~}>33bcH>Z_4uXWB03kcnu
z{&}Tf!rA3l)7I@1%iuV_`T26w2=$zljeaK%BL)V-S)#1idlFu`SzfS9;MsZLOq)~>
zUw7VvMKfc5&HJ_x)EcT2*WeO6Rc=@JrNuFfcU_kJTkE-RK|8uYD|e3D|0~qg)Rg>w
zsrdOhQ}bPy8lF$n?X(RknXHpLYirilMT?X&GcpX;XU@I+JUqU(^pX(su9a7N&F^Wv
zef##)*7dc%uU@~NJ6+=Y5Ad*|;dHjHt!l4BW{XCwUA=ntD^;7HmR>9sMK>i(m=?3X
zayrS79sRzp^XOtB4VmZvAA#3eWQLuwTJ!QRclnoCOV}Z-910V(8PEFtoqpT=^y}Zp
z{&#;UTdekaYxy3f?KOEnx3G&8ndZOiW?<szQ4a_YP5Sry-NgOxryq~cm^Syf@c+6P
zljSkzVgmEi*7=neY+b+JA9OatMV<>8CR(qruQzXB9)C7|N5R6#$)T^;gC>|oc&+yR
z`E)uh?bV~B-EZrnv>aY<J~!L^JWr8a?U#$2s=j9JgfAeTlZRM9e3ct??cB7r(c4c|
zKA)=&+U)<+AV1}g^YInmC01w7jkw$Kx{+N@;B1xc>ouFttpE3VPF&SX)z8YwQ%x@X
z%&26!`@p+-b^V{m@=G^vG<<KiOG^Ehk(lXo0fz%;nT|FJt<=n(@NJ)3C;#!KOVj6{
z;Zrx?=OtO~#ilJCyY$8f$Oc<R7SN$fYyxUr>!L1SP+0w~_PxdIO%Z=9K+7lpC@f$M
z`TIR~+rPQuoh~lTYe46-%+A|&Qtb-wsx3MV*8;B|c)ay`T=u@@v*R;2d_7})-Xy;L
zaN^Dvi@MJocvgBnR$YB=$)t>iuT9)~6Q)fQt9-NZ_!-_!Y3JwZf)>O{mR#-Kd@S3F
zFBf!$($6=4+OO4J^||`-7Q5XC#?38_*8;De-Dn~m77aR{u;`R#+TDoPo1?xt%${a_
zVOjE};;6}A|GuxUKlLmojeY+A#SgY#kCVP;sTaNN%=6%{=f8jkg8kge`xh%d5ZUpy
zexKTU)4d7vcKwmxuXx;a-kTch%0G`Jm1O-@;`Hl%mZ*Ky|CYku2Q70!<0E<tO2f8_
zI9R=1(W<Dt`t^^JU6<HF?f3*XmR-AcojDVFHb+-aZm-}%Hsh^64WRMgEVh;NwlmH8
z6?MP-+swv?vrP9!M@OH%WV|`;tW>%4x|ut+PhXcgz3RiI1(MoK96mZ11m@+lN6c2c
z^}@@WB|_JWZM7?GX)uSv169V?tJlBmv7Ef`WlX;vxLBRZ84?!OWp^xl*T$(^cTU~h
ze=TEc)9R{wt8Tt}V=R0;icjJGs}*uxkAGMmZ7&M7>t<lG6kNf7cKdtlhi>7GTD#}F
zSWh~R=;eUTgb*nz4h^QtdREF0@)*x1Y>g^T=`XeTb#vyyth^%AUEJwN;i9`>_O>Or
zjb6@vXZo@o)URk@VB%zCTJuLm;em2vTZwVRT*fe?h}tj02ST9Q6y~#(xW6fhR;#_d
zSM4uMP|=}b>U<WK8kK<9Fn!lXp<*}N=DC-wZ`gi&({xUV@k)ZMbmwM>^As8ycC((V
z{w-s<XJgVO$1M4`-q3-p#+iZ&2ds?O#fUb};m8nt^($a;?fb&l8<w#|tUQ?2TnOvY
zaa4FL(1_5u|MSO1VekRWwOjOI>nzjU8vdU;*P|Wos*ujayO8zU-q}jK-#(tw>`?kC
zbqdcl6*hOcGq$t5TIKa*+IijS|3BY5T6E>m1j`=}A0|GojIi5NHSZ_1*aU6xIm0QC
zFxN7AU5|qw%cWZ{x_GY5S;K1%t1DR2oE$a>->;5ZEa+n!=Vw<o?Zx(4E?g;{6Zd*O
zd*#zn><j5<2eEQ&SXT9ci}5`7mG);hi!)x`OO;<PV`09tYvRFKNr$;1$^;w^9A@f%
zHs$u>`y1CEw|fR!4*?pUO7m-Aczxz(Q7TK3(glH8`S;832r;H?xa9`zMK>@o)d^YT
zlo=iPl@>gI{<32+kk~0$%fJ|RU5}U9IU$SboDie##JxiDef|3;7&lLqTC=#;0$$iw
zgd{jR&$Rt?mn9;X8#=l+!;_I|jq%FUTLn)vI%Ed6ws>cqv37s#eCgtClPVES$u(0r
zBzTWV!ks>w>GSK!jMw(A{VUY{x-A^kcmsI=$(V@_Ub5Ftyt}wqgQH6%OvXlDxYO0`
z`$OoaSkQF;bCy$HOhM6+Ieper($ko8|IVAu%nT~V1RM@zgZ3tGOX?ACG+~*O$~0@2
zJ4?jlW~J&pK}k6yxnoDaZ2b4-h-Ga*cu5{O#XQJlOc#5-F74HZswzWC8&K!7K^@fj
zPns#A!Zef9q(%IOd`91!js2+yEb1Q0yKMWr-!0)P$1*XA{FjT<YafA@&ViO8Kr_fZ
z(FJ^~)2H`A?$4+QX<%6GF5Z`@Y%tNmtCK;yIdpSyyw!P*WqA_+7yr8F{k(g^NvnN=
z@8P3Ldg3$Q-+8fWrVyiEyj~kP+dW_g4P->PENeL60ov~HJ0v(I{87dI^F0q<b$|O=
z$Zv9DRV{4rsDXiLp2&>&_^kfwaA8%Z93EIqDS~2(<#ejxiKPy?M`JW~JpSC@y?DJV
z+hVt8hZ?Id$p@*`Uf!=|3-2qjY*N^;VBeX2r}MHl+!BK(BZFWjmWXt(X|I(gI5#>h
z+*rLvFa=bIte?1d*U2i&pT%mm>ieZ^A!!SgE;nfyREMn;k^3_{F8lfd9-gC{D$4Vq
zBhddi1rpBgH%&iQsbr8gv%zMj^<@`OascW36sZspp-`MPDV6ElR=y|3?8T6yh!T#m
za%?zfVQ3B-*yVkgB75!G3Au?~$(Q6kFx;<lA!0huhIhFO`Ld_o*a^N#++iM<K*HI}
zt?9S^iLWTnE4jKiI_2BZm;P3h_q~jtIuDln8JHr43fLmPZ;|-=0~WFd$sn)yOygFb
z5Z!o%CrtT()%RdGvDeY+@>9ND+y_g`4h)RvxlFF98Ap8IDwOc`jgt}NR4sqdn9va;
zLk|`s@fG}MH``xXBDtpZsM2v;o5Bg9&8u&@|GtC>HXCh&>w*b)@4Gcz-OPRR060=?
z6df9_3ZFirAb28X!KRXFQ&>))<^Sehy>$0}=OsrtcCCw0-}I$j>1n>8q}jb|?ui<O
ze)liiA-T(+`^?OzXA)8;Yy0b~HG{*mU@s{9>kBfwB)nqcJ*RW+#JVG`Cf23*LY4A=
zuJvdv^pao7E%f|E%v>w8`S8ezQ87pl>$IK4?8f%`!-juhb7A?(7&OqQ7P3=~Nl(yY
z?crVOr6C7bJ$b!i;$5T_{U3TADl-GLw40vQv?U$Bbj$R`?45?t(**9QIW%0&)jm`K
z8tnOXq2_m1nrztbsf7Y-{PuN~sr6gJ2m1v+v>uo<D`jQ_bM6$*4@VanK~}nla|tAr
zKHX%X!LrQ#z|M=I#VIaq*$WQs@Kjpu_-L=v$AvF<YK9{=J{Ghd$Vs2sP{y=oU4#f5
zcp&+KHzU)UeKBEbtqx8HB9#`b{GGrXrrx*N$Dv0jOr7^QER8f=XHC0q@oIxm!q;C#
zMvy}n#JL3$N<Tg_Fk#^f1?k<IzW+#j^2+Hxn!*mU*Ft3CKuvA10r$ja*lI^ACG6jL
z5xxx|%?(tB?<fjoi2=>0O<i><s#pgyo8}=q-MD$G)tZ%Nd*C5pqxaxULatKt)yJz(
zegLPCJ30;xSI@3Kd_!Oc8)LfcwPh#XUD2L&aMr7X+VCRSor$+kh|yQ}O2XHRmyATg
z;?p?=5=w728OX3Ki(X)7bAMk-@%N72bwNfEnt}<=h^qC6!-9oYk<C+i!sK-{f<f6-
z0IB|{Vv%w>$?$pw&ozhAPij**JfaHV8&iHbD8$H3x%B8r{7+Cf@vijOgKK6$Z;O8?
ztZ?AfKGQ@O4xiNxn_V0}uMlDkJz4E~GQl?q$pq&HBgTIb?rD%n%41|&^Da)_t^I%^
zw~2)pi;1h-G>(Fl4acnbf5yeYN)Z8v1F=l!j2LyVB$i%(WFQ6h?R`*AJR4*r$Z||<
zMyQ=T7dO+h*>h`kjU?Xsm!(Wzy@VCf3gBmbwW{lF<i?9reGfuMCNFC_G?YeJ?v!A9
zC(I$jwq#q<I@=A;PQ?9=xPiJ--np^rxLdgH+-AEuiouXrQ~1ur5>dRLt%speQapp>
z?B@3qgW641n?Wn~g%HDP{w#ACucdjh{74C%$p)^HZnJP~*p=%l!Ovu@Fk#olsf+ot
z8+_NLHO%&g&jqX#ESScj(0tYO^dSduK~e+COX=LFN(3al7ucmPUVZnZUdjeFT?>d?
z7#LY<K%>m<-KVC2)yJqiG+Zt9KGYyEqYgCRyeu!hVJgqHm)D=cw`ez1gIYyz4o*0j
z6<h$WKN}8g;Sxxg8|J6i)?m&0%K7u##;q<gs!Tyf5!P?)ptS}_<qv023V4+8Xnk!h
zv*F9P{lAiv&OkdS;-K_*G08xLCCzKWsx@I<%uAm=t!`JkWPD-jj?fDe4@w!I<K;hp
zMPP>>C^W!TtwSG6*6Oae*4xW?Zykr(bKnbyK*C%(_jOGTuUUi4cUeV%rYeFYtSr9m
z@K|&E>u2!dTCjcwrkR{q!h{me`t;lb=SYqeHHQXMWBn@S2a$~F4O=^n80W>h!!J?c
zNYR=w>EJC-w(MnfU%+LjLxK?_)0)YgAMKdz1T#3)UvDt$mri*5<zx;d(!ka<s0K*u
zZQ@(HHTwjjv9`>;f#LNRiy~2$7=2J4?vv3GT(G$8T4L{}i&I~VPhx~eswCHvlnp`6
zrp~szAaex<I~f?So$P(l*q{$eB+K5}p0s3LJ^47=yv9F)8BbRnyyez#RlfU_4kUV2
z9U88No<5i$FvAk$zoqHxdHDI&^W4~8pIKO(3eFm!^Ws>UHXl0ayN+YSt^`L3a29QN
z&%&|cSDxog0j6Z`DdO!*7wx!IQ><a8Ft=8>v+o>Fm={Y=@9{{u35S_L^DS2rzJ3TY
zDgld52bIb%4;kpNq&Xd!dGuCFZpl=kgrzPAe0IRvzXA>l)0sBQ%#PVw&i|}P;|}y3
zzj!Wzgs)FG8ELW{6Dwegh+e~xy+G^cOrC4VxzwNK&{IcFHm)-_zkE5KQlRl}@=QZs
zu*EEQK$WKK>jN4BC%PJp4_KA4WxIzRJLn4z5-_nzJs==J!L(23n%Sm^&F#=Rt4~f1
z4B2ry#*<wX6d&+xFmo?c_p|b5IiewW;5_Vv8ifb$jk6{sFV=pw;a6ejOkq&kbl_v<
z*zinXezfw0+{RxQYJN{UJ8^I4V+B>F91&<!%z=S%K9_}Yg!PGpuP?QXbwLhoi~+TU
zrrLaWRbXc-UFi0E-CEn<Dt0o$g=rhyP9|(^v;dd3AfiSk;H`$>1v$x27thRqI%TK0
z!hu=8O%qr+QhXPvL}-OB-TLgW$&OpsiW6KKrb?}ejONLMm&GZ83)DhV?yqeYV%)|G
zEp&X^85pm<40s|1>OSe2oR?c0sn#IGxQ!huuh7sC&zg1Uq|}<XQ#d}nHZs-+yIKb1
zYC)Urt_tByU;B(0&rY;W+3+k&aR+n?m_uQLD`Prum={Zm;Jj#X<@cnOf$`d&h%~iM
zhoA*^s?DX_JrY-XIC?HR{9%E|9{Za!l|d$h`rizU@f;z+N(aPWpHKnE)E!NShO2X5
zA6g+W!?5uR!|QuTYBhunlJCWU?l1xcjX*)OgIB}WcHeb(HmE^Xa2>E`Vu|>>dD<D4
z#x0->Bc?03KsRD;#kG33n=iCFkv2B*H%?*5Zedt$A2u}-+#KKG+Q6_nI;^QsVS;Mo
zt*)Ix34i>fqw^;pd2~^b@!C0^-j>^7bzmaJd%>nf9$Z58EK}ayTk$ddz{8xovwnl6
z6dqKAS`_g~Y8?)%90C_atUCSb?Bv5j)342|Rc2a~vSC@*NBClq5BnSzY;ZXA)UjCU
zuv^a7ZX?Ef@gZrT0u;0ul4;GlNG`S}hi~BCjk23;Sk{I#{`uD6kOf(0DYU|DQ^eY9
zH<N3+J7KM|%SxacOJXMn(><XT+@`mf^DZ)EH%P59<3Pl&KkF)|J_ha5h}vDJe7Hfu
zuOJSps}`QK6+E%gVXyLmTX&LkN~Uf)DQX%~yvOE_97qkQo}D4sxT?#glVNWKyDC%K
zks00K!t2R$2F7cDV#?FzK4&UjSh>xiI3)#?63zG!cJ{NZnxo2eBH`=BQ;>#8V+^-I
z!r8A}1@$aN3IXwki(D8?BZ@b0-2t7M0FK}j>p<NoqlnGj=kJ2kM2)UP19<3GKq7j<
zwxm80iT{_c-Mg)G@le60<Q^eLPaecj&wq{y2Vc$KnxY0S@81b29I#5Vt*Wk0&B(|&
za`Vdcj}<YqX3ut=ub%bt+w2!od)g29aIi2R4T=rRkE@D!bV;oA&uRs)&W4!=&u4*+
z;819ASjRfYG-7wv;+=AQ-yzk)0duC4TF>{*ymUqF(*67T-|yG&2OTVS&gQcZXceP-
z?27g4{qy#I4ZFFca4`=Lk4I+a$~i@+G>dMgPS5IVS^_%@z%wz?$YE;U{y_5wEKHFi
zE6iVQ*!JCYW_gaB%p|tg_gEryVaw?p7#QO@L#(nl1SuT|&pw?34w)ithlZ;k>R&FM
z{^Z;3{OJw~3WpCLewO@X(~F<dc{?0ICxWwui0jAc=<oT^bf^4&?X%~4d%pyIR(|<S
zy0SJ7RDSIWSe%m?mw#_t>H_=9YNj=w+=#%G=Ug&{<Aq}LRd?^xkl~*qoe4g>&wO+!
zs{9@Q_f<G}K=k7=>Ep7;KzEcyZ_k_BU;8Gx=-12Tr<+*0pB&=WpEB9c%5z@TD@{om
z858^2dHW0Vk4ST*csekz3Cn)@dJ~`PqARG4K=%cklxD_Xc4b>#FE(u^D8+L;iD_V1
zy^#fU>r+h0Mc1H^5R-RJHlNQJ2L%KuXos)!d0BjjQ@vvv%Y_50ww3%|8q*@q@x)=l
zx}<fr*Pq=p`yFv2!56uu>TzJ^!CS6utNX*It%O(*rSMbxOiaH@`*(ge_4JI)%!!~m
zZf$LE$(L_#Za#Z`?%d8b`#~nBbm?!)xoLFN|C1q$OVzK*vv<CIeMkB5LnloGvpth4
z`g1CCH+vj>@_+vU*ahAK4hN!{9F>o%W&N3$pP-?qpI_(O)y#Tt7Q<p!hQ=){({!V!
zh1pvvHXQiEG2!5>WsBJY+}XmvF21(&-MhTcUN66Sf8JK&oN$aqtNZnv>~j8XCnvPL
zz217bZxZ9TNJM?ZvPUl<aMmB~1poblnM<Li#Q{a`35%wwCECbMkI*q&Ri2pmh+pGc
z@vgsau^C+IKYFi-T=?P9<#4sn>gAj4iHXX^TeU6RU-4awkFA;^Sfd*~>(X>_ST<l_
zx+lJ3WsLsZy?dXzyn3!PMYUJ--h2^baHe%oIL>r3KK@ySLf-yb3z=#6n(GA$`$Au@
z&sx1|mC^jmZ_~@3$#Xo3Sg`KU#*0@AN{dXcB%(&if=xCvlP_PLtt0t#u_mOfU}V{(
z=g?s4Tg1B{OS0kLzkgHw-`w7Qz9u$&`j1_uyZ#309pYvwQkk&nVyI1|k^^7bre_%u
zcc2S2KsyH7ShTcd7{knV%~DL&1I-dBOvq<qiMSl|QP|JoppM{%#KUb<{MST-uA8X(
z@vwdN^UH6i7YW8GOi*sz6=2l7)ii99467tsrU;oPeslB7SG`DW(krZ!_V1hX%hcxo
zNm=VMkMQuK;Q80Cg;jn$D(?Dvm0b0kjo_3D*^R#Q^}5|>u5V61KMi!czR82CmrJM5
zdM=`Lw{D($GSfbRg0v0WcvxN5NN6*L#jnwy3<+QcMiw`&7FkuMU7Q>Go;)-KwL}=0
zf`t?gWNo-x`F!rC+TUf;0nN*PT{!S6cl%v6QBl#Lm>8Y=f1a5?ofe%pQU2eDb|V`b
zoy}=yCwc4bbUA1BTIcuXm)|zqA7Es%6aibxE1YolVHA7^wu6E+(@OA8ZQkN{kUm*G
zBh#8=QuV)Y-}lR2DlH{-W?xi$sQLCwJ=Zoy?fQG{m(Fv66U!Qmo41x0ocM9HQDT3D
zftv&GwH!U>@9-|kCN+VwDI5yTrrB@qfKDEAIPje5O2XVjOw*@L>ywTtjnlhZckX;a
zkAoSjSGU%ZMLRC-NxjmsuIw29HI4-?4rbFEtD(u8fhkhB0DMZswHrIZ`<ENevvO?s
zRns_Aj%hOIm9R5gcW*g%TKG6iM6NI*tJrf|Ft173@GCQQCioNs2R%@OE@*zW@&hK&
z#*Aq<4l-n~In1h@%z;S!mvsYXf@{X*x2L}b+Yhh*dK+{>X>gBD;XIzO+wF*h<o%gI
zwwOX}X@~}O@KRMJ*qJPaJTwIpQa5Zm8QK@td>dSwg32Ld?Fm8&Z@bUEIlBXTdsU^9
zLxZWm*sM$?gLw|QM`eDm4KqTF&4Opir--mF(FjQJ%hj;bVRkmO_nT}9cAmn7P|&KX
zr_a(jcK9c};R(yyuq%J51UQ&L{T2gTCe6q-ds8<0^=m<fOHQOSGOhW!=hqooM&|{q
zwuCjcx-N4)U$F7Zab~5Bc@rO6KxQt$VPYr3u{5W|wc%>J_Zdjva+8ijgX!r9cla2$
zbBc(FoLDo(i1Fz$fp*swhhJ@5nq&jk1{zG?!qIZN>07DNmBg*O&^B+vDkheQ<yyy|
z3w)U95PLMH+HCE{O-Bl+7%`f0AvY#81RpFunxX|ZYMp?>fmdCr2?88X!a&17-Z91z
zy>1Pr4-eRbM@m37<b2MSAft$zPfn$uK3xJ5U@1~?XfS1eaYu-8JLi>Y{SyyLy)L<J
zAjuEOP9W!*a4bpL5TukK<+76nB<ipa)MEKQpW#`5gCeLa*Bz|XAkPJB!X7ve>I&`6
zDSG;RYg!)IWj6&C4$P8Gf7jHonl;F5XIG%ofvep|AAs!#9sJ`gqR{+RfbpjV$an@O
zWfqPNeGCs(nSQDX^zxrv%|37X!-t8VFQ%|W)L;0>|LMs)ao78cA#n<7CI0Yk;0dc=
ztG*dL#&u$^gTZ&_1QyUtDQNHa&cFHhC+wZO-rLc!(YD7t`Rb=<v)7;4b?*F0b-#bp
zLZ)B6`5rOaqwpZNaSDUBX~f>WGkU<yy#u05DI0brNlLIV-4ws@=F08=-%5>lSlzp8
z`e7Aggi+*i;YZ*RbWjR<VB1&_X>@+sY=+g}#U==Xd#^kE8W>i;p4P&sI6<~?|K5M>
z$~$%?Uz!ct$BZ=g`A1Pe%bzVmnI+=y#ubnu0)^$Ew&<zzX9Z8pJ@9$=ze(TD8o!+V
z&GjW@)g{Qj3Brv5kq7qWFEP)OF9wAKD9;27D;%&gHMeVRc+UE*eDB0>GDeu%u1Kxf
zIH#v^HYBG#P-kRXQy1m?47Pw79BUjtN&!(a6C4tgnlB&Bi233Oo0VG0Es!vGm+X9(
z1DBbKwfMcO|IGa2`+HFde5_R9#7u`9f$dw{t=3pZv*&@26M4YT$g~DLmgR7aNn3o*
z#Bb>s?lNxVa+kf9_iDql9N8V<b8#B%LEZ3V*_o_NlH7ClJc-F%6J_-B`Ii1~uo|6#
ziQ|X6LWtBBb>WxG`BwMBhOB}G6b@Lin%Ffp$g?!Hx_;`Myx%l&!q$r#$_tQY#{?V>
z*fUMx_;5bTNEnoW8}ES9_FpLjCYB<#fY>ng@b&-rcV_&Yx@p5R4^177DWHV7aZ$$l
znA%U%U4O%_K4D;F`J);TIPDB*``-R*({6$yf+Hoqfg$_b*`3Nv>x3@6xpH}WTn1az
z`G{|dni?7g@}&pkIFBi>lhSSmCtGl(Hbbs4AoIXJf!Q%PMWEw52C9rqYl4#=J9GR9
zP6+#%Q=OFi(P&~u``=mcVwHjMKWKA#K=W1m*Qb2IxvEInp~2Mr-5pWJa4rkxHE#`>
z)~t(BVS`LUFfeiWG=oMRm*`vZhCdO4#P*Z*px#Stbz0v6jmBA@*nY=U@0r3A7TpZD
z=RiD@qC4+34}He4`n7t{+_sH@@mfxIu{}$S&I6teWfF|negy39c8A{z!@$V0OzXj#
zgHkWm4_Jk|+kvNd8XC9+5}rP1U}VW@T;#B^rKwXk_3^R&a=U)bdh;Dx1cLfmANm<o
znf`!!vY?(9VkD6<ob$?*DYqYIzRup-ZwU@MF!7<^;gni<t>J&49!Nu3VFG9($<pEZ
zG>#pS31OK_ZTEcp$M<^%+)tpeYw;4kA9YDG5Nr5d=ejcG+@|B#>@FlD@)(E01Np|T
zO%1k^SsQL)iK*}fyVl&B7jryef9)CQ5GrUIub#yzwU6hTo!QP$=TAWsTnuPSLaWtx
zmjg$cOrI9Nxme2cu{~EBDb(GWTn{>FYI^-CHINg3DZPMib^o;KkY;*HWCKI?w1Yck
znexO}tecU~zp?g&-4jsAfrG>0KswVooon;z>NdXH{4~`H9MO>?3I}Gn=H#_Dh_kG6
z?tYV4c4X4loo^;X(;KK5`QdaRvVH6B=?ts&#in|K)AAFS28L|E8#^_b-idOA>r8Pn
z+^3$l<=#Uj$)0aJ%Qy7!fFcNNal$E3`CmJQV}_B6Jh(_W0U8Ua{IATwz_gNywUu$D
zp3D~iGPg2Bdl8a}-`seyYIg6sKbtq40WbSkc+JETvDxn&uVBG`hf;%y2UjWQ_V0Q4
zkI~o(lvlwvHukV;$uM5yV7%7z_Xns<Y+zuT#=sZ`Udz3KbyYL#w?g;xa_BLBdeYZ#
z)f^jsr6<nh1XVf?*FbC7=gyH<dQjK+YLQa)1lhg6-@-RkfbzHU190xHzcv+;w2*SQ
z_zFGEt;cU%yq<)bL>SX~uX*HOu@_E;biX+e@f9bqLX-36;WsbdZ$L}HD{M0S)h@|z
zh6^{IVd2=2_RKY(<&)EbRZDKoOF!<g9X(z3`L5e_GU4m_L(pWk22_q&S(>{X_{(IP
zy7imFZT8=Y4I*IwObAkH@Wm0@E7rs{P5Ln_qFzUhIk0KXyLeMKc(s$F2GYrM?aYT4
zkaMFOoEsQcGdDZ42v}$cteLjz5aaB{o7Z1OjQt8Y9FS)^$8#;u2&sBg2UTx}&iM)!
z>}(KBSX;spvHKV2hFvvBCFDRc0*cEC8y!~YB-E=pHC)~H0GzlO8ht<!rR7%7^2t#l
zA~|Klx7)^V6`JAlphZ93pt&|K{(rq2>J9WRM%>X4PL=~FeU6mS28QggojWC&<OC%G
zl^S@$`qxMw1}9QbhA|T1n9BOrza+RFZeF7g%cTFNXP*Rrab;kv=kC!Eyx`f%P`}=M
zGpII<(GxH>i@CEcclMh*JA<vPt<PQz3k^NF$hAA=<)x)U94h;tz4^4#z=kD8T|kfD
zE8PEz%=BrTD>%h>=k@S_oB9ll+d=bZzqt(USc()4l$xjdt}EKeaR+?Bj{_@cq~`6d
zt(PudoXB+P)-A1HH}=);UK6#|>(uGf!S|lCGI1<XpRnnosN|ZL3on9)uoxNznWk_^
zFdp(|5inq3n(D@T&2jdk)$5PKqN6c~GvnE-h=ZZe|C)YS1*r>-#62_x54eRR4$tBN
zEqakqXgHA3*u=C_OKa2la-jrR^Yp~LhH0!4Gk02DySo)!6FWR(nhH7)F0lFPqz96a
zjClqeaBqr1=km<w4iQt|pLNsn!n@BmjcmcW*PJWk?A4On%Y0|2BqTU^d3n8YFD%?x
z8}sDH(ZpTXm&h~yR9IjdvDU2tmyuIM!aXw&PWZwv?x`a;bzY<1N{y9Yey*7bPCgB@
zS=R8by(Af2U%!9PpHHVBm+2bpo4b(l`bjydj;+65Z2Y=w!vy`h-tN=V^Tar&tM3OL
zLvz{tB;@k-A`OQI)Ak>Cq!`1wS+bXGDscFf+-YA@{%yNZLh08gLko}(8ar9q+S||a
zgr6;%>&4B&RJP$N*RCkWh}V(Ko3DM0sQn^k!g5FL!I^}&Nt3m=>+(Ma*Yh7b7#PF)
zbwm!kD7<Dmn6*-?B6yZc%Dr8uIX0Mu>7M&#utSjvG{*LiD<m}3Gdnvwia}IVbW_Sn
zA?uD+jUlfMEi5!HW|*vf-E-a3{Nkndv{QatGsV`3Hpoi$l(MC){k|ssc{NMs@>S=b
z9}_NMi#VAe>)-hqlKg#i92!cK<nOsE)U%o#kh-B%^x^&DxwS9<vYOW)oM8#F_dp4^
zPSh5Sw+ydAi<;f#Dxd6dzVKiLTh#Gt9$wz1dzP<XTl{N{<c9WJk3Q~@{WAB});Tk`
zgfWE8SFg^<y_GP*{+IvNyXWV7-+hvG;(Tx_r2WrvW(Gt3sab|mdOZ!tS<moXdvaZ4
zs|y2UiBe+@7icl>w*32gva+(m_qOfY6}9EPi!bx!)YQ~x$&2b9?_DmrL26DZTdX@<
z;_>R-xz`z9FWlyQa>-SmDBdGk8?IKB<#9c;(bLrxtreJJdquSP|MQaxrT?W2A=Sip
zPzD3@ij)gBu&plr{O(`b>j|*EK1vH5FNUrTJ9%qs_Hpom$G^{f34d;Sp<=~BH|_3g
zTsxx9hdl_3k3N3w^NHg2NuH}2<8%urc+O-l-P*KPYC)OY>(`$?6&Yu&eO{`(@nu%l
z*4*1>H+L2<kC;6-^CZXFtZNCseAa(2IeVD<`pS}=qN`VnGnSg{F^Grmo;u(In!e)<
zUDw$l&(gzlZNtWsQ?Ks&b$g97cri4Kz=>H6Y#+|q{mzMJxox6Rp%J;ID=+m@6k|lK
z-}i-%r+sGEEnB|)c#Y4ONZxg??rafTw{E6gbbo+GirjK(k+*N(${Md&_qF2d!pO5y
zA=iIj;EQeGx#n#CgbR`+1QMR6Gcd9o6Ek31Gqtt(TXhP&L6Z{cz+4;^U%E(Yb);O-
zxxDn$OMa?5UhtfYl5Xhzo|C$3S@bmr<7`udRsA1lvBeyIxZ&rDHETp_Gs0FC>q%Xh
ztC1YJeyytVmVUN-mw9jXnX8@aZaFo%UbW|oyQ-Z0v_pqpo_0G1nZ{_W5%BnT-9$d^
zw2YvGLT%$j$u-PVI6UP0p{rAN_$O!`jMNRhaQ%Avbg>HuR_~MhdBNdr%GpybclX!V
zdtG0&Na<n_|E~+LeZq>v?bp<9X<=~uE^<n9FNegzD*=%XO0|Z`#^#3e76(NJnk>!!
zs0hlyj4Yo(^})V%HlN)Rj2PD*jGFN0bdb3!lbZ13T8M%g^#uq0YcsaJbn!LzU&|Aw
zJz>@Pi5@AJgqWp{<mTm>$qV02eo`GZe=5UkkEtv7Ub9*Q+iBr<cA`JHi;C2)KEmY2
zmYtdC)1{*3EHvTZjRqd@`F~~~pI5*x;r-<2uzyv4?ce$}C$kyCn%Dk%@#>Y4`MOK#
zwHdrOSDIvhUcItr+W941Az>`3`Pq+R!rxCQJTU)zP-_LGZGYeh6HA2pw}-JTpTZBE
zNVvL8I(F+(;n^M~U$=YLcGwp@f6vcq3>mXe$YPRexLURP*9`OgxKpkspF{V5x_|GU
zp0s(M$-ZTIHU74}%S=<vb8aZ~_Vxyaho@iR)%AHCTq5bc;8dW{g3BioV0|!$G$xh^
zW6<$_Ka~?wHe_*2OUFhshUp3i$Y-6AXHElMJPB$=8tW~X9rMzedFk%*_tUOjYhF1e
z^G@aGXJ;4nKYElDxgnuZCuT=L+WC3D8%%kv)2DApUcCC8+*yP*Y9MPaF4AZEsUl#o
zDU7>I<;{x2s~{U9z|Dh%Wh`R4QB%qqLXBg&xrBD#&7Rr#_V)JK{gWmMS%MDz`*4_l
z`m9+;%!|^p_SEgn3)R@Ua_TjN1qgqrE|89ulw1?`T2A3WRwVprvdj7#N?ryTd#qAr
zR?CXYO8EKd>8ASsbvHMs_wPJ7?P`5Og2T3)n@M(QXJ@Ha`SRXjYyNZfxRKP)IZ;Xt
zJl7`L?SU-XOE6;mH^p$Kz<cEh=b7AQGORtAwN-C1tVCpF5tyOLxc2I<tgBj)yUW%_
zPA^^aJ0v`OcI}om4bxaHJ{}QXx^$^4Xh+1&t=ZvT8@8@p>kHZ`zB%l*pu3FX>1n!?
zHyOP;*<W(icikGdPQ=E>OX42?rkngde?gd$<&*0HjtyaA@3yAj_U&Z2-303r&5&f|
zoinfY+s#eTf~=&hY?k?@HKAu+uJ(lR9*Ocj&2r`X_1XQR+F_ux`p)P?@NPTyxN!6A
zX#zL4WKIU}8hY7~+-G@g&F`#O<@@tj%gzQJaCN_4YKA?yjtODm*x={ddtPCJK9gH#
zL%~D8>TOdvHfX|nevOhM7Z_embeGGtGuqk97XAFp%w#*06~BJHUO#&&lhVYFN=e=w
zd3SeR<vEbG;M<Ml{;8KPUGm9$czWMCAx2q2FP0xg6K9Hmt?B`-)Ci2z>uWg9YSMgl
z<4IA;HFEL((5n<3<Tycl&ja0MQ`s`h-`~qkTc4%Lm@AcW)oQJE*&BoAHBnXvW{S>s
z_jwkw+Ueweu`;2Av)iAh?*kW}mlY=b(SK<Y)8nns&~TpR3{RLlZ<yK6PdAy2Wg*4K
zAN>W9Yok_&%K!fMcJlPNs*`JOt}>RFlA84O_4V0LIsB|%s?4;l-uB<|*o?%`6({Vx
zdBbMIBI1&mhR<$wSwRPd|Dbvy;Nb$>_a__{vCXQ5sSt2D;LHTNi)r&YEAM+B`^r61
zQ<vI)diO4`^3TWPsdsmkE?Ua^X>IH2rl5)s`E9m;4JEtOvaUay&HNd%QWr7Gc!Hf#
zxq0gj1-+v}rs>k%{GRs%{O!)nv4o5dH8k|IK07;G9kc^*P0Y@quC7TpXM@g@ahIz+
za!2Fz@yqh2re{BuUQ1N%E)@|3Ukb`1Fe9LW;dP76o=%5(+!B&&ZXN2=3468S+0XMV
zmmvkv0d=NUw^PgVmX!Yc`F!?M<~5mLzkZ#0bB(lFjzRX;sONwG#k|!JzHsrZTX<c3
z{xk5%fx%wT!07eKs}&#UH!hMYwp*FXWcA0?J*^qkVQ64rs?-e#3sYM@w`|r=4Nc9B
zx@P(Ja@e9wAI#!kt2XD%lic*ht7{^Po`HKa2E8D|1SfkdKCo^)aFFL((-XJwyUZ*R
zwcF46K%3_*XLQ1Jr5BV&t-W^Vj!wVbuN7OiZjD@C^E*aZYuoc{er&6AVM9(YIRp}X
z-8=0#o~%A_kS8p?vw?&0TFu|g1n6R$A8`(wBg5B5sUDZF-;)s=lsoI-ujlsvBg@|2
zdiwh3@{|o_&+og%?~993gLw5ZXz}Ho8PW<55*wRMBZ9qIN~$WHctE#&f_f_gGa?+A
zS09%t?pYJJH>#^!ICAdB2p`bY;>}H|r;o^g`><P+G0cmlqC!;?JbLb+$HKAUnbX{A
zr3a#o4-QJLVLhqCW)!h^Q$-KByTQQ7!snWBZjL2r*SV*K%r^bccZ$!SJgvV!XaBd$
zj=nR580(_^A%lbyVi}p%-2D11kE6m{AtJT!`pkn~ykYseii;shi=lBPH)uzy<F#A2
zqJArZ&YTmEuen(Fb~<x9TXuB#r|GZjX3BpC`@<nY4Ya^@iQaX$1FxA_9Va?O%wfEC
zf<cvO&%QN1^5E_SBg-Xm4Nc97#^-H<O%`9xnr)T~x)UlwzxHEH^vp8}ss~<mtENJR
zvJfL2>a0CRjEbOrHZLW>hx3AlzWN;uB&L+_c`OUMJ@$9gZ1a4vvuR(wXFt^tyl_k{
zye={fa(w*+(8yb4(=#*B`R6xYbn%3pUnj>5NxBS;nL->aOhvacmoH_B+$y)4E$Z(D
zE$t>D4IP8!LNB{dJ_xwOe>sT{TuyMLxPrQ!Gj?(^$%z>lMQC%i^>Fgcp8P`g&7>a&
z^$)&%=z^{pViB0J$RROtA!wVeQTe-=-&|2z3AeZ9e#>4jCn6%^;UyckDPr%gDLvqo
zLJI7lE_A~=UBM4i8YUi;(vX-|WPD;(;<dz=vTwd!5s}aV6@j39VGzqS>txlhm&?7K
zottY<f{w!k)gHgMhV#!Ujfl3o`Qp^-*C%#>rwKOcC%j1jpB1boU|<xnHB&76eL>Ra
zX1V0Ws{=f*vdBLIuigR0%7Oh%QYlwwt?9S_w`0rJtuuvdf4yA3bmdCVsOadWn~gVW
zW`u@L1zl4-O)pmKm*n>Czg{I(=7uLtVTriAFRBN8Y5f6T(D-_$sRTDuo`{7+g73=1
zRx^HhH%qslo&g@p1Wgd+aEOSCo?I2WT1AF$_V(`Mk2j^B7BfB|)$8UeFO^gK@8|Q>
zv$ISu-M&4$H&OPIZPse9H|MvP@!dcyl7lyk1Pr`bGQ2rANFg;F6z;Qnd3&Gr30oV#
zs{dn@yL<bZ*xg}C8*fy^#uV;br}Z&cRo2H?l__SU8V`8+-T`UQqWg`0JwlClI7K2=
znI@I)P-2$dDa~IFso)tHSz=T+<lncGl=I7Bv%0v!<ix9QXE)4Yyf%%`C_+8TA9_~F
z0nqZEm4+ub{yUiYBzaMPNolF4iqOmz-0u}1)G_XMIWWQY+Ps5$NW)hO^I6N@-I@9A
z3wSbM`Nm}D(oHT7!S0`?zrI|-tp{lZHt4h7c%pSSwf56Vb<okdvRA8retKGT*7W+4
zIq}=`=KcZg#bsvaoAF#)TKehb`Tw>=-ud@G|GnRX#jD=2_WhsiBeY3CXxjvrZyZXS
zI5aw>!$ib$8gD%fjlcTsW>lrk{Ht|a)~;WB?bfQTQES$VZjFk%bt}x3^{Cy-4y8p6
zI-6Q$nHn7$T2v;K-uvUf$9!_iq%#M6p4~h7zQ*qGot@v$?0jD1zhmal=XZ){r95F}
z$`kmJ)77wL$1(n!PkjU*w9Q-G2gx`J7Z{nYHH96VqcvsE!71YJZ1!&c!?ea-@}N{+
z{3*}?j6esd9CG~j_T%H@uIiiiKb;mmYmc(E_3o3eO|!3^cyn_z=pH?_6{|k$oSkbO
zE?4zJvGT{m_NC$L<9t7TW@0?feM31ynt6>VON8wG+z`+)0N^5tBh+Cz$Ay(CrN^3;
zkFTyRK31iwxbW-FRA=4!e;`gfvWkK6nn2aH#~)`*b-G=3x`~xrMP1!JZ~x!2i+^UN
zotvZi{Z4T|=%VOlzO%1gyKULl@R`Mqd&9D$rhb9}ac7mn&%M^jY60cW1_q{!0xzzu
zojqmB6qeGgv#*~#@$8uXE_U*gC2MZ6MDkA!^PK-Kc1}#{t2VIm24$8R&89tf7Zk4p
zZ9zWPBbm$|zV!#_{-X2qY+c>APZB7Y>u^AD&6$I*cGWF81aYu}fM6pdGaE~6o<?P}
zp2-=>&AZM0gbO}!TxMyRIsFkhuO)>v2(D2q$*HZ~%Q@-T&v&ygHe}AXtF767M&*WT
zME%Zlr%!MG9w}`#^}s^s_BGQJEA=!qIJ_-InjE5;3h!xIUY>rip6^=nRMkW0<D;`=
zz%k^&(0ER1LHC1YOO~AI6jr~Lv&qkVS>@b+l3HgkTj*Yy)w^4D={&(Txn(-+f(0uM
zOi*-|i85Z*>X5@Fkifes{ws4}Xy{a%Z#R<n?d*7UW_O9*RnYkWMp;)hKHr+PCC)y<
z)PL9dJ$v^2%!^ZgP{EiVv+0WWq9sSo{R9g(O`D&3yj(^UI>6V+C)m;7KOIzsY|FcQ
zD{De1^Xgv(&aduW&1X3IvF*KW-U{<lh+2hNOe_)2SN1>Z(mwNNwWp_NP;9Jj^tPOd
zpcM-9DjsoGKAGr#=27Uib~V|Tw`^Xr>({mze-vL?kQEd*o2k9pqv$N-M~}Hzyqd05
zW-tA}pl;HeL>K4Tc`^{=85;eR4RUT6+yspr-rDNDrcqo{QgYGdj;mL$c;x1;{b~2$
z%lQw7`{kx=x4W74Yi-n}BQL+cHL*`H5doLG7eTIjBR5yfp?USJFO^3+1i?E_L7NXj
zr!bzceOEkb-n_iN@UXC1>Hq6X=GPriQheamctl4qz9H0o<Fsq$Jy|P0=z`{}r|$J!
z3NH8s92A(CtV(ZOSm=EA@cs(f8KAAyo4v1RpE!S>|Mvmz|DWf+E6eLYX20OQ{he=H
z*q2x9-RlP@NQX5XE#)4mYgVw_?0a{2_v|_9{_{-E&zw2)+0Gq1cDQn~^T`-|-nPx+
z03XX8g#_Ia(d!oK;jW_Gu{#&OUI9Dx%_ThH!-Ip9=G@s(Fokc|js5lYCE8cc-7Ky)
zV~hAc)uiTp=5t*cNa?!ZGPgj2ZLd7zU+yhx*`@(=C!3m^hlj0?yPMLtRMxue#KXhw
zsfSuPmlvAd>v9lb1!ue8tP!=!5uVV@(7?cy%Uxk3XPkBQ)Y8iw7M5S%OjGfk*S5Yh
zRdj1m;i79NuP%iSURi*a#R`CO+rKyI_LG--PoHHu6*OG6e$S^a(Ac6;(G!o0Kc}r(
zQoL16OzhMg%VL+$Ya=(i)qS3Q-{bwgy`Ul}%xs=u!Sn{vgx>6!7pwMkF|6KgHSrd-
zdF`-;r9@=))Do8L1)4|KJib_WZRN$HDwCcaS9ggR`8sUb-SQbSm+a7B8PWVg<?rg^
zsHj;s-|rNsHC5Gi-+Na4bZYpi9!X;t`<95zQ&TjbF<)Nf+Wq8i`F+va^?p3|#m{^^
zJv}#W`q<O3n`MnA(;xQ@My?IJe@%e9;0jC0+O{`uax5!8ELeFM6p1{SI--t7Sr*>E
zr@85O!r?!wtGoSAT-X;Ieez@;q<13_z{s@5@sG@r<Ht|e|NmY;d#b&+mzRp6Vc@1s
zn`W_u{q3G<SG((l^XIbH*Uqv;{_Wq~+whvDWTJMw*XP;ITjyvp#a!<Vfs6n#vMf?x
zaJegz@tSS*Hw&8svtBh@C2cS{;00YJ)3}XwhSGxE`D*T^CaeBEjTGPhNq*}smC5(J
z<!q}2V!nP(xO|l98^^U{noL@&BA=W(YU_0snyMExv;O+_HoLz4LZgJ=JT(XR4N;lr
z)0HFFUWXl<<^bCMqU(F3nStpn>l@1mY4M#&eAk|NKzr*9j4V;&9$sEX&8BN)cI7n(
z2k(D#jN$dW=Ba*b)xJU;c)*Z}B|`SHXb1}<J9h-*wTk_Mpi3_w@GZ`Qrnm<#jmGCJ
z4zIhmulDzw+~v7n&ij4s-IlxJs@;91@T*(D`mI*_>IfdiI1mUj>#A%B8)G|HL@>*b
zvj<O!F!H_CUInS$8JPM+Pn<rz`Sr5T8?Rlvc5D6IEf-Za9gB9A8-}j>el%=m`&G}q
z&avPUeGX{5L+4(nxdH{V8n&JYt$8fMD5_KRbW7YK*y5E31&v#_m~7@)7q<DH_)Z-?
zy|SEM_9ri#!g({(16#MAgdIl9BA{?UilH@@L*apXz<cgha`W^biF!_67R*xddetAJ
zO`YJf07P7v=iukpH#hbFzrWwMO*YG_31+%-<;50;xQ|tPKb_v6H#Ks9oc8DYxAm)f
zU=^S*E5`=2uMb3-IDT-4{Cvh1Z5x+z{eQ=gXAiwPzI#pI(WbCk|DM)VZGC}@HY(8M
z=fKdofCY4$Sq(d%%!ciAHx=&Ka!TAMR$V^d^4aR3Ir)0mELMI#8e;xlbNcdU?@f-I
z@N<HSPtaA6AnT$wv@$ULW3nnL{kv63H2cqYuU-Fb)`&*eR4)7Vt}uI!)dJ5n#NEpr
zCW0@nuAYA6xOok)wzl@<Q>RX;9bf#@$$k014>Nl=)z-fbW_q#l_q@ADJg#Mwi981v
zRRwbx7{iX2a*8?~P-JrT|J}4YJ32&7cVFSGhEKniv@xuCrV1V;1dWbyY|)-DVS>Wm
z>hIe=TV{&9KJ=75#XayhV?6JstT-WPQ{IF_AmOPxBO?nFx6B;zg8IpVYvSS?LW8v{
zrTIR=SD-gE?01-NSNmqVAJ+!GxY`rz!mFhhKFM9L(+4g`6dsf@GOfvb@A#_UVF`<t
z8H<jk?!H2+hEKnawArkE!W+S04b3|YjedF$t}wh_$NaWGZtE_+DSNI}SAc!ypb*B&
zvEf+O`Ad2%N-7in-Bb#Xs%iBTbb#asP(tSLRM6J;o-}##*=oOeHk$7Ja=b79ra*Kv
zFs6exz=YKYNVCjQo?vE^5PRvb`-Z4smMxRa6Byq>>q$lytDO!pF>`+OC+TWw6}6mb
zuv_VPU3tnLM{zGVNHU1ga%i}^RMvf~V8;%JZ@i5D5AE4kM?Uc?-im6Fz=S(@Vxkl8
z@2mY*W@4@<e_8v*<@QPDFPu(-#{wD}yjeLm?Ar2pg&C8e_=%s}JZ`-ZTb^my6#6*>
z9{LIm4i}jIF<v{|&hH%>8hYV<Z^*H1{TIs3#g}jC#vv(0il!sKpM}eAT;Muk>q({X
zOKTPTk)xbNcR}%nZ*Oj1e)7F)@22|y{}$YrUfI(*ucGpUecM*al&cR`J-fIEmf$l4
z9&A^#=j2ehu*;!n-iaBaN<TNd?&1;p*i|w$%eubOX<NrLMMQdP(U~y)`VY&j^Yd&K
z_uC8QzqqLzId4z$k~4G60?xgft`|G$QLQ{<tvu7$hukdpe{VH*{X9Vc-28P|5ZJ(w
zy_hwcLqWj9!F~C&vqF-8W_Zl;sA`ID*t$yRg7ppX5Cv$lfPz4a!~VLzZ(?>`2rVsr
z{9Na^gNRv4$*V2h#kGys0zdsauRo#N{mX}|hrT;r*luxslYhU<Lbo~4<?ZR9$(geM
z0oE*YlpmZlDfR4GJ^hJ=>`{fF=WC}5UwxW3yB_K!21XVq;TN~It}c0h@9v(J`}W0g
zadSIsFK8}`H(Hgb#cX@`($;qC7i;FQLGt)_4uOPH|M<XQmPOhRxHnv@dYtmIvu<Dd
z{obVcw)0|s*+%Yq8@h7s`p&$+7S_<*rSQP1@!#Lyx3}KgnB2bi?UG*3^z!LT&OeK}
z8yKS5+U{quvg!&e*!ad3+yV)`RpJ4REO!(O)?Cx>pYAsyT&vx4?vdZ`1iFp;7j2sR
z>C~?Kryjq*qj=oUV9`O@y`H+zTy;Q`Nh;y$`OsNi-Q7#qoT&^pSgN9aqB7m|&e<hj
zV?J@t|9PbmQZP1vHZXywRHH;MTwHm6&7ZYz)}PKWJ^$~L?58vA_DL$)tDR&ZaR#cU
zxRxwi*7ZLr{Pwoo?3pJStJUV-KE3X!v^JkdZ0+GGf#3YhAffpJ)E~Ake15rvrAhQh
z!g1+M`*Zwv-!wh3suHP%bddYW^XIo`md<LJCH35QZ^=W;yQ;>v7q5K2urVugU*pkr
zZ~T&(LBRoTkiGq4&%~f`Vc&sOd;e$IUrx7lIw@VUFa@5IlOhz<)!j=DYWrTjdNn8@
z;K7b-YQLT(>`imp7Q6oXG|`*4bHK%*!iAfx92?5M&1bmP?;ya$eyWUp;%Y^2P_Jc5
z5419EaNyy7A+siZe(koqhtAG6_s-2-`}dZnbg=#l<&V6VkDgMG_D(&2&}(@}ZxzH)
z0np;lz^Bijz)S#DR1FO$4m2{mK2N?H5*n&1ZJt*m<Gub&%FGwDwGMdIN5*92egZFE
zYj9XDrf}fa%H8viDGSVTnBVj7VCt8rT&npOS|`DmwRaRYf-cT9OlrA%%6GPzr>ko#
z$Vu1ZXQhWfjbF`w@?MhL#;WY>Cr{ezCtk9QpRUXwmm#-n?e8xV;A%<X8>m37lfUf5
z;uoEebN@VRtQ(rA)deI>GA5*?rp}yp?dsK&r>1JlUVrtF**N9S1)t#cRqId4-@EmC
zhgDfh>#NgUOLNZc_kJqf?-l!S`99AQ{~7IhukCD?ReFF!V56=>gXy;4)2}HCh&6UL
zubX%$ulbg)H&Pj<(BSZb$x8h7j>5-p%-`MK?!PVne%}7FQ^(GRf8V_N)4N%RHzn`?
z>~`yxXwQSTK0n)k$0LKv7kqU+`Q^q(`@iDKk;*stML;V=EF2XQudRu+zu5KV#l^#%
zUl;N@a=f{<_4E@dg9HbGohO?PyyQM|T=m3<IUhG|{ZMKd7cIZRfp^_KtB;JHzF85B
z<_T(L(3Ua-6UP?K3Dc&jsr%2HqU_!`161`3$e!I*_BJYVZ`IbE8yg(CxVg{T$-Z3`
z%w1CQ>ZWeww%<*ws=I3!o7S#e@nngQ-1XgyR||gq99sLud}Z9{s@-2dOq=de6E&^k
zT*e%xMR(07GJ=xy0Z}GZRn=wlWdGm3A!-vM#K<y>J7w9IDc0@tR4)gcd+u*ZR@xVR
zXiwbwN*~MDY&$=1itk1)eCNzNu=DvmZAnSVWuW5$g+s3D7wlTge>ZMx*3>;;uSEw%
zO3t+m$lteW{*mLRTZ%&u8dg4^?7aMXhWNhSS$AhUUbmWpsN{}=$}*qu06~^H`VT&)
zoKn@Sesb=N=%wr1Pp!RoY*~L|?Kxrpnnj<b9eANd3<IM$M}>{tOoPOxl`HG6W$DUV
zm-$T7iA-|aylt9#&~Nr<OHOX-E_(B*{`V`tl@@{7``__MmmWRne_z1s-nj&KY0w#c
z5yA=wq_S<jss%chG%TMTTea)>y(y1F_X)0r)kqEujT<;4w##e_U%(c*J@@vtxNRLW
z`%jv8ZFP5>r1|^BN2#BGXYW=nlH-C53m<sN#1b+0p7RxcMs-dVlRK-Hg?jbp&*|Pe
zhhg>Ps?J@IyxQQv!x8aXkLB`|fKP0}aT_Xwc2}f4`_fqU?Yg~%LiYBlx7H`uDlh#0
zV8Lt&uX_u)Rl$A8hGZ6w4OYvvS8y=t34AbNi`aea`VCRF16jcv8o`;Jfr+EVb-@;s
z9}cM+m4|~Y_dDsy-3&g)f7+<J=JMy$=bwvuM7lnH?y`T4;r5v}pI$AvErQE*>4USx
z!c)U{ELwHuUK+Rv1T}aZ78G;Vd_Vnj(#(4X^7WpPTWx+_Uptpcq4LhxNf**RcIRHT
znKd0;unX*FVu?uJo}Ven^icc*$h7M_l5$;58Lxdv4pxHJMkQ&Dd3U9r@5?{0IAzb<
zsij)ScmIBt`1fA;`7QT<Jv_G9=>Oio-(E-D?f9(XbzM4rJ4$n*@rJ0v0jb@!-lqjP
z_BZ_J2+MDcwPOsM-NXxNHVHT==rA#}@o?;#bL5E2%Junk<n3RWw;4YExi6C`EoM^o
z^dDbd?@syK_h7l@hWjrz_5SF&H|gVAd#_if_b0a)pA+=-GUUH|t+vVs+Gt3MK9Dc_
z;YOauT4#nv1C9zQ_n;*w3*#Ftmjy7bN!+lM17`05e+7H{cu)uWc%SU&+qa7@zn=YL
z%Ze2q_v(J<&a^08v}F16?PsnyR{wi^>z~?+U0XLeWxd|>X|lN4>HK#Rs+P99N&<Kn
z6-&v^y_I@s|4jFitOJqYRKG~~0LQhA?+nk~5BM_uQ;v8oZU4rYef4asiMyc1M}str
zkdRQyr6rz|X3o5sRcb5Of8^-Vna3X<ZhzWqes99s=<Qu>v5O}P*?#;qd3L*J*!8yC
z4^L}lJ>B=*%<JgMTNxqk#So(|Br>r?Soh2lRuo`n;@lTKZ%N{V>a3WZcNd(Jl06IS
zwKB2@a4dJo%39?!)5!H$pRBfR)fWNY6|bDPm)`G@G)}p)B2ewXs^@FhuASO%|1UyJ
zKTan#_2NwB{pDesY(DfRPI}R4EK<!kZvy-CypO#Zz3)WW9=;Jj1!-b0*vSygVj>RO
z`LacK0e9?GxrtMD9Gl3YzDoOy2dAu~BSaY}VRFoG=u45cDp^s<qE-6i!^2C<{pBO~
z)$EiF(bdy4TO4`b?sv|`cD7V&qq$etua5lkYN5U8jLYlp6#3MBe7^QmvviwBjm>;<
z>rMI=;-JLoaGb-SX>0NvOKzr(${%jptl=z-^ZaIVX8F^pRhE&Lcf1IFV=`?TG&3_W
zofE$xxE6FO7LT;q8M(8oy5m3-1)CBMGTq#q?%!_yXj5_Z$?MC%Y(4+`-K@i(e%#;g
zn){1sw-U5HAi&7Tv_{ZjsRv6^)Pa1tYa#u9k{2du%}_hA2)fvekwxG|0i*28s&_k|
zp9&3+O<g9iK`S6KQuF=(|NH)Yp8sED?((h5m-olt^j{W#XM@J7dF2<~kAAuxUS5_W
z3h@#HldO_M!&c`RmYht6Dhq;HYNiF*dR|*LXGPwe$ye{4WCQsdT#PuhbETxFo}3yU
zr}=z-{XP|S_1n*{Jy^vSdB6I-t){N-*6;3BkFDb+G=k5)&z=8l>i4cEH(7VTxeoIU
zH<PTjq`ywbMK%_z-40IX(F#}d?exWVZHl}BZ^$juTJZVN^XJdK_t*VR`TOhZrqb78
z7d4qp-rn6E&c)50dZ2;PDCr1?r@w!HM(kF-`+tM>%~`W*a{2XXGm7{AIA^zV)ynC&
zm-B8}ZqkvVsv!fa&=?vyxDA?24;>KccR0iOqc_3#<K3<_)z}wZ;1UVklz$-8xMYcn
zq;=UEpSf07S)$j@s@xj~TFkWP->=u79=6MSRaU0Fce&KM_T5+Ag3^N@-i3*#{QK?t
z=|=bMCF|~GzlSsj85p;NHos?|56ov-r24>|J-h3^=o1&;6#E(Ot9Q<Ut#uJ7*xk?<
zv=?-u+MhL+mc7M`vKEvc?~_%#u&d^0k*2nGcSNu)=f_WvXP=wo?f!ks`H$C*AN};;
z&e@>g+XlO?*&Tq!iJtHW?*1KXo`r}rvMf@5@Nu@1!oI>IjEvV_l(45m>Kz6~mL|~`
z_xA3NDZ80!RQW08<hgU(?x*!;#BNAvj1+i%Vxsc5jRkosDo0N8*C<D>|1^8@*S}xg
zpR}LPn<BhVlLgXd;@A<|z_2>Hy01!EK$mepL$+7U+SqO{v7MWA5m7fs=fdvte9*4f
zXqKq0=Rnt^fUX;}e!oYVonMZp+PGv_!|r`W%VO#?*TsHQkM@3Az5j2>DXpwGwa^su
zKn>J8f2I4Xt3jCMkJ!#vLgBgBI|SF5u}XuRZlI;)+AM1vUW0D)+qtus(SL1CVBkcZ
zxIH&mqD^09=}r<|*H-)cGxO7FtAF1-ntL-^uiS2H9N+Y?o4=v%JfO?O5^?uZ@D*Xk
z<s218Z)Ytz<yrmPg||EArUcX#4Gc_rLZA^3pIIiJ>-PQ1+AI+k6Ei2adamAszu)hR
z&$U~yV1Ywcw)FdiO~!K{9lNgfeX8|3d7W!7zscArmfP%%<LdUGlhnBfy3Fqdhd@Ga
zpLM$HfxS$=%Q#kSxqXlWxjH&9l_@eZGR<(!%HZW*b#?oW95=6v)zR0VK2<yX)SsW9
zQ{Ud&TJ*@JqG<uBk#E1Fa79JU=gnDKc2TKroAR_%7(>JV2?S=c2skX5%w_WL*qbE`
zCen;7P9mV{^-=Dh2i^^)F7BHk10W3yOnjoC&LrqEZll~=CZJ0^RWvnEuFEVf1-ByO
zYQKhpibxsTsw;M7tE4BpeV;PFu6Ra?XV#CZsx^Du-u=4opZfOOrC{Aj-ywbO3kyMY
z!j##QL3M&J)0$rSD*p{9LU~H`eBl{eigj1XOC@FZK9k04g^!PUR#ok)4S1e%cW3c(
z&{ce&zTM9EPE1@_u{Z8_#R}=iZD}VDZ=b6i8*KAz?bOiHPk$|?pB(0Ochc>GPD7RK
zU|_t)r~bT!V@J$^$*JZFOV<@1VJhBmO9v5+hN=%fR-~MmpjdRb^!mx8;_*6G>8tCt
z^z^1J^`3s}_4@sKpqY(Xv!wnXcFdoDcmL`?uk77D`g__0H=Aya`}vW3_LI5(e5|o-
zlHh7qprg&<@O<{gg=yzH8JOOQeBj@3ZTgMegf0f;#)TSd$;Z|EYJbmi_w?+{xwj|s
z+nbxo{V`W7qr%rlr9R7$wW-*^BWtzg<cjMF0c>A9ryj3$yjDH$o`S2Y`cd<MusXx_
z4zFIlTKdOju1;L7N11F!1iQoMIJ;%jV_wfbZhG<XjfDv{C&8;e1SA_R?#D}<t(EyD
z?m5Yt1=P&dTBTh(NuZ<az$HDUds@Y>cK5|7f4yh5`R@zyxX-!)7cAVvLtY*8gm?%P
zJ61jmHf;*x;^IoVy)Adq=gnsRm6es?g%D+BWuKjM_t^!7<u<M1Js9%$)U6F1VGGQ8
z&-qSf|DQbL%bRI3FARP|I@TRC8vgNJIWqsJlAF&#jw2f!lK6KQuIya-&FnJE4G~0~
z%ym*QH4Sy^m&<*YY5RW9XBB1T#h$yrzrC&AEv`SUm0SGOx3{-zl>?>!8QfP1ZV<m)
zdzt0WC+p`P|KEt*m;c6`^5OQ@+WOWz-`}XMT=|u^96F3Bz{<$9CeY#e6pkHn2QJ^u
zbLu*7KI`k|kjUUXSXUNQhh6AoDVcW-G!eFL@3*L(Z#JD)QCDB?`P$ptJN0Ons8RjD
z8spZ6zM5S9Qg8n$=YK9^5V(JZ<*h33CcT)t1$%R3+(E4h2L&ajGY6#v!?;`(j<No6
z-%us=_E=b${PyiPK_LnWkQX&fR{pEm!oLQFg{6t@y|uG=`IT$eq<U7Z(z>}Ju{r0?
zj=*2v-{&vme{pZ`$Ns;vX6y_MdQP4$jv?RA9-WqNaj7PJ_4?AfYnkHDw^hwyh7^D<
zUJVS{OHwq&8zaO#-ehjqGhJAyV8a+TyA|HLU2vKEMG2!-?tvA7i_d&vu=0;}b!{#D
zShaUk_I16_pmL3K%e=y4lKT#>@^xPw#T~`kEa`PG;gm8zq@q6vntlxHs^L($pz%OH
zA-88e7vnWIrEL&jf&3@MGHKGJlp7lojY?hwT(pcd&%dYB&L_L6vLssm<;$097pyWa
zC|uNJht(af4fmt+UTVJTY?#a<R9l=_JMGdV>Adfkri)%py_N@E?F%wkAVWz&US7ZU
z_czmiP#@Rf^}D;fUEMclX+cZFU8S$j)U1=5AbUYQ)a*TH-n{y=-jK$gf)o==#NvhL
zECma8I|SwLW?fkr`ppcb+0W2u#!_<cYNxRJsTUU)yDsOuu`PEtXmw%vi_PaQ@5;Qa
zX1Vz}Lwv*5-lji%vFo^#CPKX2(bRDN?A|~N>*X#CjOAP^X}7=nO>e8*QsV9!x^nM)
zc)&9-vfL8(@bxuyyq0-+*~uFllh2wkUaNlf`nBrm-Ojs~o3O;K{o6RNdg=9(sf&%6
zWRv6}0WK)6a6qas$*;kIhfC$_M(L?~y^dEOhaP|P7m;f?6a>~ZoZGo7m?@_GZfVg)
zSMkoif~!kjuk<@-e<N)|DD#H-(jh9R@5O7CmX;ozXSC*L$(6U0{p~b`)qEzbi`_j7
zGz5~Jk{99ckqAyneL@Lc4DO}uQymYeGM(I6=6d;cNn=ypvr<dOu-k~l#L#$w_0gk8
zOXBy}JuCe1z|lC=Auw>FkL_xYZ8BcdW!*17ebMO>ToC5f%X3O=`og`Zd=<Xk*qEHQ
zijnt9S<0o>-OK#uYGq$rlUa02R6DH0uI~Tu``{G=`ugin7DDD2j`T4wUc2$qJF3ay
zIH!s!TZHke@4wI87D%wI`;>9~YNIivk^!~Tj%;x#E8F%W`Qf3~pr|OV^z`Yo-J^T&
zZOxu8$$2|$UV+@@iz`7#fUk+&z3plec%v%sHZ@h%t+V<e8R(s8LKnmLZ?dND3RO&;
z`$VH`dAH}L9x+|_DynLeN>%BjGvLqx6NZ`rffp^F*H`miamaCBwtRlwuCotTg^KgS
zW+lKg^}T27mWFb;#3}4tZ|PnXGq>cU%Ivqdeo5VT3QwJAZ=McL*AU_WBh%++XSsKY
zEqubeE5Hccp90OXu2$aF=mi>q)nk6+RqpMxaeMz<i=6z;@XotJ!-1DvC9kjPzEA=W
zE#{`&*^uZg?LJ$MOEv#;`6uv!GDsr~%ej{DY|EZD^+tuJWl-gTd*`9;MX<M)Ya1jS
zXjstAfi#HMSjHl?Sm|xb69Xm=g$phRqz=9keHpp+oL$JK|L>K)Uj3F09X<tn#6q_5
z&!3u;XU^no=Qz8#(%Ohu-p=O5<<?2?IfVxtj7)3#Ua)C3Hk@Wz^{rFnoY~ZMQ!OmR
z=4-^QzitzEf3Krl{bQ}jU6t!z%vqxX>mV~QviP|xC@MOt`OdnMHX*cm^(^<#WhuKJ
zwn;bH#Uc#}_6c;{-jv#%|7Yfj35w1#fr?re_Z^s|>g}WUm%-6#!C}^tl2@-jyJ}tg
z#kBh5C!d=VH{+)ZZjjn}m+jPA;d-r^nzqbx>F`S!8yJ`la$UK4_2jnP+bP%A#Rf%1
zW!+m=yzbQ&2CJg2i<?(RHNJY4C23!`XHDehWoOfR<ZPqD)<h_JdV1zQd#nJ;#SObz
zxVX4{T5aF0GTZ9P(71wI#5T8S_11ek%$iq6o&USk`sqymI+gOcZ`mJ@sJrcb6#}kD
zz{G*QOi~WuKB~o1Q7HpZ!`x@C)z+&DtJ%U$`45IJ|04Aj6z+%g4~Q^6G+*k%k`(>m
zfz9Q8{C?kZOP{Q=KL8pNKiFsfr+g!5)DhbIbU4HD<muCy7gughKX0};^77@&uJTr!
zLchN}5qj1cTxfR0GP-RzmUsV>5sQ*?z{Z19cCXS>fAJ~&?ceD!lm53Z_&gat#OuJo
zXwLcK#g)j-X*1hrzw(U*w;v8EAK<w5!6Jx@X|CS`huEqMxpo2DtY7Rw41GgNP>}2I
zs5mrS_1)_lD_GFvaH~N5N)zIC9dNn?6MX^-2VQmLEfC_^;i2%GE%>G#=Tpb<UH)$W
z7kowxID^cCm|QTKficYdt5~V)0Zt~%`(mEby2+Efo7SDZv2Q-Nl|HoHhENaohd@GU
zaDHGo%NzxP`6@<9jXrNK#uf>my0tbiZ@Z&W;RVyT&y<-#u?lK2fQlVRh(2%w^-kWH
zzUpz<!aC{m5#zGfJ61)zo~T{j7ByRMUdYbUN6e2p{c}wD*&&WYwH7qrQ~W-#oMn;b
z1L>2qEI(8iJvYri^=0DyiFGHxPEy(WXrk4}s=fQ#Pjuemiro8sZpO7q#qdTuICQ{-
zpy&seEhSv;42?6yFI-$X{Ykx}p5^11iBlK5yy`o7|8)CF_RzmIx&4!`+t;4!N!Y7W
zA9W`Bf&)?>gShTR4XDu`KmT$Pi<0t%qv8Rw|H>zRy?)}$ma|0*^kU1dl$k%TO1=Aj
z$&Nh%%X)uI(|;zVF8`*&IqdD<=`tF(bNjxZe4)QfVA{E>r%IS6zLfKVcQ_&DJ1{h!
z;5d?dbJNjs<@KO!s#MJ8#k(7vO=nJ4^X00(DbjHulUroJ#-^Y5pQhCAwTU$gE4!L@
z)AgIz``5SEO?Q6!`%UdX>0Jub&fT0f^U~#d^V{GMKp`3)gLB^88O>J<W1U+C3U)fY
zU;o2x(>d|j2d}>MOf|AvdBWs`x%O)P4ZD_KeXuI+R{SpKd6nO-gI>?xJrywm0FUP#
zjtvZ}rK>uvlpdHh%3bg1`57T}`P{VGyVgy9ec8;bX<gOR*^{^K-Ln7Fj+zZ$xF)VT
zusG&+wf%8$j(~X`GVahPqHy5W#9MQ?8_%gsunI|e<2A9)eggMy5l?yl$_s1bOZVI}
zpZ+@Jeh$-B$NlZ_DIP?!b1-4y*x=?ow^->yB+H}8u5AB&Qtqf1?bw%nVeK{6O-qt`
zJuY4*sP!hxrE`Lv{+xTSvOjPACwC92UV&LvvH;YZI`S-pqa>}-PV#SaUfukb^UH)+
z+z|LueF8F13{wlv4KB_N4B0GKPoFxqWRJ~{N_FK3(JnWIS4_#j>-1h&_4w*>Va<Jw
z8C(^MDnCWoe(w_1ezLy)?`j#FiVG%&=H}sfyWg6fJb%9bs@i2emRq7TEM7=OZv3r#
zGk(|NvwL=OrW$QLeXq?X^YHC6ryVg8vxCAdrk(`eVt&x!TcFio%<Ozq<p2LTUUa|q
zd*|`T6WisgJosd-M4oL9lwo=&_~D59skOrL6YgBOCcgX9gI8-MS05FAo|_TzjrU!q
zf+=QF_S1A|Fg<g3U&2AAlP6D3yq&*4wvA6#3p5XRW{zbrXqx}@G+pk`H#PVe%Q?aG
zCF=VXE*qa-5`W0hb5hjj3vXYpoc-inp1fCDO{nwYOK#myYHr8!F4=~Xnn7WF;U&uq
zC54{Yb&yq#%lzhMxvh<I{r>iLc-6NznpV3?Z*9p0wVPi|VUqKo6;t%^{?kccgI%@4
zSj;Xwc-6tG^wG1ie=~fr$pKu;fQW()2F7a!WiFncotnD(`s-a+-n@A;alTT*$w{iZ
z=MM9++))zH@AvB4qjvMtwk0R^g5PpUDzK++5}8^b_iB3n*SDA1Il(C#PAG^pdQMhr
zoiuk3he82p>7c*xh5v7tE?xR8)yu2ve_nNbWo2de-{qT}^{23e`@8mixA0sLXS2ya
zZASa#SFVtyI;fc@fQ4g2+oG#}aqG7yCeHiy>zA12<HwI(<sW+eG1ZEhGzHxAh38gq
zVpM22u#&q)|55p?(vF$s%a$*ny)7gxY+J_Ucc)LB$k;ev79)(o`X9tGGObB`v-`{$
zpWvv%!ouz#ei@4dv0Yh(4Y+hffpzSP+gs(Cm$weI{b0>YrY%2Y5lin9ZKPch4OXc0
zK+)RZu!WUlL)%XFbvqt$Y3k@qu`GUe;@jKXpatBYX5atgR`vaz?&IVA{NOZ%nZg+u
zSr%y?Pzq1HHs2_<>qX7#ZZX|S<@amDZRGlSB#m4^D{nP5H52WmkK(Z3g!R$3oSToX
za%Bii5Q%G?G)d^?wY9T3H??g~K{~M+kz5=Y8Z)>=L_}s>Hf}O)+IwNKdq2lCzl+!d
zQy`b|Swe3ae*xrhWDNHgfX|*UlNE*Zph3wI)h5ugg5j)Pyeu{{a^{rj(|2!p7Gf#G
z6t_Nnmi?hXy;O_n1^f2dt@!^vMt;uS{^ilTzt!>0ikJRks#(Ue#hzc*O2xfTCUbk>
zug!}pzs?kiW>WW?GhxvprIqW}<!w!j;f`9`*~xtE|NBXkgg(#Qu+}ZIa;MmqrBBW!
zPn|mTSyaKNCnv+C4{Ti!I%|gY0(<t{zxL0g1d3z*nq@Q|6ei4F5v0we9kyn|{(oQB
z7kzl(I9VA{7Uw^eebZ;!X#H--;hMy}d+UC`-yeU@=JT0nyDMdtnLt}xKpQIfWGoc+
z|9zXkG<tiUZq%`_3t2tSyv=z3JmKY~rJr`+|GUn0w|k$A=J$Km`Q3lt6!bULY0k2*
zhs;j=Rqj&T%Xg>bvaeC%p%yjXiw|c1lK~yWwrbU?CEnBZiXOI#pVHlaN9p6oKe2l`
zr=5;_b8D;jzdz6IPq*<(`vmCf>G_?resA;hnfZRr*xhAYqYrOAu&iSz?_RMzUoLrr
zMiozge0<#Z_m=k{56=Go{2%YLs0Zr>qi<W6znfzJ_oe@)%*$%K6O)hiOw6zUeLIFb
zXX3f7AFl-apWKuR8XR&5o!O?=`#kDGOS3qKOGpDlwoB#V@E@~Gvs1pkxoK4Qr$RVn
z?dsK&cNRZC<;-uZ!f*d)!<ScAwQJNDs~qQgA)fu$Xf31g|B_>p=|A?TSi7-&(ZBeM
z@z>n)dlTo`R?iA!m6~|stD>9Lo~dapzl#^dZxa?4_Ek8$f5n?OIsd2U><&oy{_gIl
zXS4H9P0<WKBY(Lh<yE)-K8;_kUhDr~d(W`f?$0Cf{S*HF{yuwtb0ahRsaIE5``&A5
zVcGff+3eUGRjYD1|2&reZ!mlN{kq*tmM@=upI5&2%ft#Bxu56%|MAzJ&AF#gcY|e8
zR`U6Iwu>0Q=+}MhHcB}mU|IELh0XszpP%(>HM8?iv#b3z<6Dt#$I86?i!;LGDqS~i
z+Vtf2{r~$oSG+oZWRYuk%Dp|6&#D)FWwR5H5Zd^6O?}Db2U+j$?OnQT*)q@Monj^r
zAFwh(hB_X7n3Hg@iS?O&(65D2_8!@@EQ^=jDL!xetjQ|()|L-*I)Y^M7bu6S`_6ju
zqblg&W$}oeMN8k@-5oAh^T9C^w2a`-r_+qwPk#waP)#di`(3<%_u75_82O}Suiv(P
zd3!rtuKrJ<aLDGeSMpK+KeXGQxV1I=EyL?+y3r}GudQ7)UsP|`3#G}S_g62Td$0Pv
z?ay1+_o;b$dWH$w?DlzZEjmB9i2d+~hlf)^SL&TqpT8x8^Lmq*is44*|Mst6n7sb~
zv4N3!$(Ai4&(6$LW@Tk9YnYnt=u=X@y7xl%o_li>RR3CDIM4M@IcjZk47X0_jhbuc
znLx*G##Fsrx=1;+{LPJvOBTj(&no!9)Y!pYus-5Qr~iKztE|9$-mB5}YaXncwn~0e
zNyzNJIAz5Khc}!t1qWFdUABLrvE`c3_4aEiN$K?l_Us!kM@0#FIMjcC-QoH_<?ha)
z=;-YC|2`b%cg>fUw=P?=*WVm;o%`pb-up8q-qF5LQzh|t=ZkxLtGflg-{mTr=KDLi
zFN!`Gs=dB6-P_BnYpeGTu^S?WJ0Hr&Y?WGZ+5N|Vo`~O-eYuQttvsHm{(lv|Uuwg`
z7;dIb8-yD>I1QRileRq6j!@rleaiId*B1rs{TiGvs!}S)xc6(YyYZ_z(N)?JZf<VR
zGi%hdSJq9;(l4yd@IUeQc=J!o4N)uOH+<>OlS;X4f8eF5(v<JfPd~h=Va%S=^<O@L
zPu@<)w(3j9N7dW2)STRRO-yokSk8ZQdw%=@`$L7g9dqmQR;%vPJDk0KZ`v|0Y16DJ
zbEjrE`U-xQ{#74a&t`JMtoGLzvA0j7E;Om6mA!ahGS}+auh;AIi^`kpnRkl)$llQF
z@Pw6PgWJ6yTh1rcDsp`Z_q-b(7gu-d`2vP=ju$Ihk9LdCuDt$*c`{p|-o776#@FMD
ziZ)qGIqDwPI`CC-&75_5KF?#Wxb}Ye7PvRnXL4WBpJV3x6#vEViM{KgmCsW0G~;jV
zg6`OP#pf)yb;a>V{a&+R<{H<+H|852W--d{42g}^4UZ{wom^I+n{i06SbtmY?X+d=
z7jHL~e)OJe<@Nl*SNWT#wkkZ^wb!+IUga~%i>>cX8kX(<U8;EawEq4*o_6b4eJzsS
zwdz%^s1Mou>6CVKuJrY$uuO{v2NzIxp~ZAhYt;6C84hbJFNroritgCy^=4n)r<3Yu
zO$4PPuI>+ceP?$5-mlYUws#)&PTGF|c9!Jz_H89r*A00$z4){GmuhsgUX}HZI>zcp
zo$5~}y2~XR9+CJ}cwuLFY1IVlcRLoJOlSBzCxP|)-`Ux<ejDcf?cey;k1_U*hxo3G
zuKH_#maUyupu0gO>2svG`K3$;lNHN8Z+R`V2egCqPU-d7Z>96H9do|ztzTWjm$o<f
z>5Yxa&(a<0^<S*`_Ilm!bLWmh3h=qbk<Y{Szu))!)}G+bY{xUDw!B3<7>YMo?P=ap
zb!|_!RnpSROSN~D?!~B<#b-Zo*{_h@5c)r<^0Ke_%$3R|qKQGzMIQXRVENlNVD;Bs
z3B3uIo(n3w&2a7g;{D^-*VoK@TWj@1D!yI~KRaD(@4xw_*CKtR76cz>`L$+&@?8_t
z`G+^3oL%`)icxmrm(%h8F4gc|nAm+*_<GYbrHx;s?Ek-fv@QPUsqiQ7cE6ui{eEw_
z$%B7?KA*qM`!p&c_{f`MM>>ViPGPVr`Wn9f*VLc2AExjB<66?PdFl?a2%(MN*D#jO
zjo%9zQ_Tz8yEycD%Jqg-Ti33A79~(!>)$;`_W(y&`uF~ov1w_`D)sdA@&cpxntJ35
zs+7ht#y)Uz-#p1`Im7k#b2r}~+!nQ-e^yBd_sPFZ-qUm@ipSRk+Wr4|o_&vM0P_kf
z-iB}6|0`*@y1Fj=XmzXeNnT@D7uV09=j-$KdHg^B|4;v4_aEP)j&5CGtN2~+y8W`R
z@9su#%e$Lp-jv<wdr{M@<e+t|Yn-_2y?wR2pFDrQ{Z`&O*0q;*JZreObW8Dbzu^1%
zwXdUfU#<Q9rMOA2=IGW1to+sj9V-}=Ba}}`&pTAgXUn^2UEJQNHMbkLro=vQdVY7N
zL84QIpNr-?;R_SJto~nWU}TO7FV~WhV_e7ou(0Q9(3jKG)Yb{Ud!HD~8L_<PLbP3U
zv~Gm^<`*K2yDrSEkJ^~jx^rsDhX)7$?Y>zyvw`hg>8}38?)|6u>pn35F8h!$>)=)e
z3DxJ%FJ8<%JNaMCiz$jyDO-iEGkGhS&1e2A6VWaA`uU-4Lf4zNmE0-xc^|av|G(d^
z|4%&oFJYE5gLB2JeXG~)I%U$9-Dv%5O4PAF2IYv@OVfX~dgZguFi!9DnP+peCt#*^
z`MRG5rgeWRrf+G=n%8&WP%HOY8}G&L{bu`ZN?kVJ(^|E?vF4?Byw%)AmFt~ZO&aog
zJuXgdGJVPZc*_=(lP6DZ-0xFZTadxtwleDAADI^!Y;&9a#rIymebnT{w!FJm)qQS%
zFZdR%Z@BmA=apdpnGLh_GB)SjG}>**$;tUmKI(Xnq_UO$;(J<awzs9Fr+2fZnLb$c
zx#YFoq-xeL=??YkG1YIkZmRyC_jyCq;(C{pr%xMy)-TrG5R&vhGMwl7zU$e0`Sx9S
zsq|&@0=CHIJ~NZdXMjr3V(BXBAN7B)*Uw~KTQbo(_DR|0Wxk(oWv`!^-LUn8;(YF;
zb+2cec-V8B_*=;~=;b{7KeIpEu~;=uSs=2};=YnZobAyGiq1;aYF_rajIn1DE-rFa
z+p%hUQ^x$Wb1W~{%(QxYNb|r)reCZ-TgBr9{;yQ}!hLoB-`o3V?i7=~&!8o-so~qs
zzA&yS>vleq+WGOA^jqf``JAp9w>h3YcW~c)W}fYBosz)d;AEaJ-qY7<*d!n0@$~iW
zwVZzLio#qehyMqpG+yqxbKds*oS&1{9{*b2qSvvaeCLZ;{VMAhS5^kUy{OZ8Dq+4g
z3+RXnRaI3+?cc5XH3!d}Jh@dt!T-#gD-TxHiCtmMTeJJtm;XP$UXRZgv;2~;ah<8Y
z_r|S%x9|T`>lW8HyU)2b^;dPmogIbGiWi!S@?3Aa@#=Fz)Z+QfU(5IF<-MA}15(AL
zuzdNxNsVdE#E-ohD}OzVdLDdHL3`zA&KJ1}R_wFu7F=WC;$*C6T*v=UYHohC`?eS7
z8~PG1Ozi22cvEA~9M)axGFvZisXhCWbLt1SDs1~5^S}Oeh@e%{*{C<0wu%+&X80bv
z``h%uI(z0{?xDP^Uftzs6uREzptW(QfAgzf8M<x<wknwYo*QNfI-<<@S7Q`%Pm}>Z
zxY@wXx`si!J7(vG&nt}Jq6m2gCJqaNCU9)nwc+xpc9c*92ltQ)y1A|kAX^Kb{{4P`
zI%t8!y}i}e-j@$wItLownE(Gzx@F0WfQVDYQHmSy*)6XOmWOxp8xJteJFxp^H!KKT
z!V?a+@qPmJqBbTUpB0jFVS!`O@3-5%^YZd0|J{?JxuEf-Yqyx>YR}1PThBb0WINkD
zf7+TgIw#Ma%L{rOkr_YP?IRO>km*1v6X)i%v%fm8?Q-vzTesRq6uOnB@rFpn_q*j!
zJJsh2^dDC?zf;g$^L2H+D6c?PK<V3CTZ5vbwUyobdd?ne-x!)cr?8Dj#v<TYue5q+
zXJ?|$&c|J=R<4|A{eDldm$!H7pC2E6{bab`W?xc(%u9l!aEI4|B}<N6nJ&0y-77OK
zhzA|saEFA2o!V3RS;f>ewC>mC`DT(^S1b-Uy-@Y##l;)#9M0Td`Co{~mIO+8b=3*R
zt>5mdnzXW3SL!$)Jj58UgH|^Ch6e^hgsj>R%+BAZ`Sj^iqvT^fY6nACf0e4Z+CKHw
zt5+!x54CQp`&)H$d;a{LQ)@mvI9T-e>veB8x3;OiVe4Wv*YEu{>rVCiy`K)U%Xjom
zvMqYj!6R=Mv+v*6^|OucSH0H#x&Qxf`-=(pET7Lwb~|78^3qYg$B+B%r?GO2o#3zk
z;cTq_=63%6+*hj_@4vjfeD=jfVQH^x%J0{12X~=Ci{Ikn=KXo$Zf_J>BJ%Ff&(FSl
zOZ!4>%O19h&tljV+V(7vf9?8fq0C+3ag|HwF5mljb=X>?=RdA(-=|vp``gy8slkT7
zUo7tLnfY&O-0kYez2;u$=h?nBV$R)?8W0<syT;T%FmU3E&DR2dudV<8Z<)p0aNBj6
zkB{}LJy>@;{@<tRsV^=pEZX(<@+Rnl0&v94S;xS5?Xu{TztG_*fiUoaN1se?+=#n$
z`?!3~2gjScN>}$tnR<b4IuKqHy{BShhC@Jqq~n3Z?fj>=<=%esa`}8S$FrZ$S)ccD
zT=2Q#)!XM%TduxjFWJv#vz6!W|GV$&uCHrj6aO0HZ})Ra&99fsjS3&RSXO>o!pZb%
z&PLE(4=-|G&sy{O@4NE-lR=lwJFJ_w+>?2+{lAa>XBWjzR`;KFak2aC2T$i%7C$-A
z$eiZIa`yZ7{eRE0l&s(NN=vxms_VWIzfjqu(q{^D+pDHcojUW+uk$NsWbVDTCQ>>1
zc%P|b_SUOK^7VfTlQYEc<t)}^&Ydl_`uoo3^Rn0c|GK_@ro*afs}Fu$7rWalEp3^m
zsix-1dw!mthQIx`*PdN<+8dI#1V96Aex3~suQfM*RD+6jOle?~F#Y=K>gv0}FEWC8
zD_+U0o&W#O^S6JbO#a^g|2O{U@B9Dt?*BYj{^swlg+Jx1UMRl2yuAO)_3N`8miN_N
zb(ps`-hIO>k6>BFl?OflPuvi7?A%;y-+OcB$kb|{o~CQeU9|V(G3iB%UH?wjyRfA3
zdfne&H+PpVSu?HhdTja31xw{-nB~s0`EY<a&179)(A#@^cT0Y?%DG`+eCS%$=4&^-
zthBbReH>=@|9P;XwuZ)p`G4P}tDRV#dUme$b(X5|^>MnOHK_F;8MiY_#uS}YU3UIY
zZYj%Zw&JUQH=WiKK3jZ{Rs2MksJ4o|eSA$eJB!Z!`sXXRod5qf2Wd`CV3kA7ihKp|
z;Y^^iOTd#+_Unvk)2=-`;qm&<`#qogmMmX>+Vpx%@>`?xR_`<3-`o54_UXU;pbgF@
z2Se|Q%gg7x?R&ND|GynOEH=k8uRVJ7Xw?qST~DV)AK_Z}ijkKo%eG`n`sXDF<NrTc
zC3l@+L*JUKf(yeg757ORAG@<JzxUBqqwjBSCNHzw@F{cd+AH@8wdeo;ymHn{5w@^R
zuVhagJN5X#%n1kIKh3LW#V?n;kfJM=5ZChK{K_r*M}jB755#d`XjEhBNyt5P5O#BD
z$F_z(m8%M?&s|)(y><Jv5|!r%o7sH>&OOfjIngcu>UF_sXWbY4I=^yNYW9Sn;Lm@r
z*{lx@4Slxbzx~<ISr>xck7Ol;JU93C@Yt~VH@n)}xl#GND_)r}{#&_d(V;zC#6Dg+
z@Fcn4R_*(p;{G0a`?zI3GnJg%csAa@bg$6*ak}(Fqs!6XO<y*p99-hS_G{nc<Nc>U
zJv|ND7n|0_u=;OSh1ScE+vQr%AK5~)FK9qMf=PFOZ-jdVv~*`=S){O_(TjIOmcXU@
z#AVMyFIM_|oj7C0jXx7AWi?(%86?jr%L)i>UiK?PJ5wN_`M4EpgQ?IJ`~CakpQ~Oq
zDSF}oI;+5Cx!i@o^-?{19(8HExL;r^zLWCl_i@iOtM<2x`|Y%>=C3+8e>Hc7DSyoG
zP}>#0>Ra_!a7{+caww>=aBMi{Vtxs_ia*KS;rXpA4`%B%lzcvGzWtVg?A=w{XS{ZD
zZ=A%IVOnwhkJ%T8%EKG|&o6fj{vZ8=dFtxprBw{POMab~meyGR?)15HW{g+$>wlj9
zbVS&{<DB8D;>mn+HaGSx-TV08Q>&A2zVH9PSJHM3W6E41r_1|lf1gQ;|5wVFdfW3Y
z_tJY$T;ap!1=}4StHiy_W8VrLPj8eEyzn#R>$jS@-o_W^EZb#qg<ZZTA<DYsMS!vU
zt2SQgSzF@7H{IG>U4B4tk+0FbN8O-Nyg$qNBDUwvm9Z}KIcN2H%>u703Y*wcK>JzJ
z>gF<E^O9=W^W#zXS?{^u9D=Kl`z}lS?{fOgeyM9~|42>P*0j3nPSk@l_Urpxu3bEM
z@Z9%TE#H1#pPvgYVH_A5Z-^(bWWV`ts0-N(cOaC>O8u3u`Q4PT$=9P#9PgD*e-?Rl
z!5lWf>+52(pDE3?C|m^UI2mc50}VJ$%DlX6=Fufw+}y6r3#_U_``wjtZ*Fp}`!sp}
zi6<u~FI~3m*c|`nhJ!sGSAS*fwfpr#xw!j}`2HWRk_HJ4Gv7HhAD6HHv+>V|c6-o{
zsS}6!?Q_IFTsk_xWZ$J$Zt+=VFJFZ6Uf5Q;XKR`J=`;K7th&k{9B52C7nOT?L*ikV
z<|q1lzXWw_ij^!`f9~O`?%KV7KAlecvcAeR-r|hbea^R=UmY@rH<=xt3n(18W%+An
z7<gHa!UHWv*_A6lumAV4zg|REc9o;MZ&mi+9!cXTyI!v|USF!X8Z?*=I=k-Y>G*$1
z-!c~jyBprCdcF42>Tvzd{{Jujoi*$Jq5Qqu`eys=t6y{d+UBkC^S8cH^`3U3_`Gd;
zS@zy{J0A00{1tJsYJTXxt?~1}Zu`eBS8-s^fByO(&9*|J&4+f)nA&&i%&Ak8?%au~
z{P*+u+sD6tfrjH}esg%Po%?#nJoNzCLy2iqvu$7RWKw-yq0oFgZ@2HfnopiH&GY9~
zX1~9;_vyRc@6CR%`5u{iui|m<r`PfSqd*>-5qtmtzwc)^Pd&f?Pr$A8spk>lz`(Rz
zS>U;JW8yp8&+!w#m2f@T3(MgS7OY>)eoUGq<mu-pmi_gY!_(KgzpY*cH?LZ&TTuGx
z$;k$8P1fD@7Z<sLPJl8#RPy7)!?b_l+7ePL{MJr=JwIH0&!x(gt+l%@1b=qj<TuA6
z@z#3fYGY&LzxT7Y-L}3LChK?H=l<&Ad1mYLKXYv>tvg%&<wc;d!?l-8CM(-#{bKhm
zt&feJ8~Mj)xkv!F_SVokgSVScJ%pUv3vO&S2C#B*ah-{lI4HGB<|lMQe*vfmzg*en
zwzt%RGbc}G8b@cZzS6$yzE$Ucj>zo!|BJJq{(62<Vd*`l`%#wy*ZxyZp8Y)geMNMs
zg{*OHzQM}1pI`qjU9zq|sNccUef6so_n)m?`>8oI{`02_<kdPWm~@InS4qHZg=ch7
z-3>Yk>O2d_hEIz@#iRm=V9{JqJg-m2(&)k3UyfpqX7D`6$Rf~T$heH7V<X>EOK8vw
zSTgdid)17(*dc<cCt<4!qOb+G5)g!wh{6FWC5fBRP(XJNqjv+tYSn|t5f8Nt<T?d`
zMW9214xZ=()v90-R3d_j1?5I7Wam3DGzx%bN;%xhP=&#91R@RyDICc1gr7}`Y%$21
z7SJKaE(VAd?`R6($D~8U7GxyCe+n*)OluUICL&d?C<->PaBPSYf}Nm&;Xg&t@>#*2
zH)wXkxQKnth@eJdae%g;cO;~^Biw_+(qUv;GmYgu%rrFH9Xgm;BAi*2;k&v)p#e@V
z5F&w7U^L26A`_AV1~|$OBtO;H(AZ#B32*oyr3kPKIh+*kz5c4ltt20bE(Mkc5r0@}
eHeUVyU%pi`Ik>4MaxMb{1B0ilpUXO@geCyW=Oq{b

literal 0
HcmV?d00001

diff --git a/doc/images/linux-4.7-12-decompress.png b/doc/images/linux-4.7-12-decompress.png
new file mode 100644
index 0000000000000000000000000000000000000000..c99ff9809d540440e09e1a88a9bbb75bfb52af7e
GIT binary patch
literal 56215
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
Qz`(%Z>FVdQ&MBb@04^K78~^|S

literal 0
HcmV?d00001

diff --git a/doc/images/linux-git-compress.png b/doc/images/linux-git-compress.png
new file mode 100644
index 0000000000000000000000000000000000000000..3fa0e88f4f169b1f23c43c189097af7be1d08729
GIT binary patch
literal 105620
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%0DoN<HgZkjERd*g?^uX?{@S(
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

literal 0
HcmV?d00001

diff --git a/doc/images/linux-git-decompress.png b/doc/images/linux-git-decompress.png
new file mode 100644
index 0000000000000000000000000000000000000000..279ba7cf289f084c44721499825fac351a45d5d9
GIT binary patch
literal 54333
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

literal 0
HcmV?d00001


From a9e5705077604130f2b77142190978928a0b2bc4 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 13 Oct 2017 02:36:16 -0700
Subject: [PATCH 002/145] minor code formatting

added a trace during sequence encoding
---
 lib/compress/zstd_compress.c | 169 +++++++++++++++++++----------------
 lib/compress/zstd_compress.h |   2 +-
 2 files changed, 93 insertions(+), 78 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 2c46c79f1..e072fe30e 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -1238,7 +1238,7 @@ static size_t ZSTD_compressLiterals (ZSTD_entropyCTables_t * entropy,
             ostart[4] = (BYTE)(cLitSize >> 10);
             break;
         }
-    default:   /* not possible : lhSize is {3,4,5} */
+    default:  /* not possible : lhSize is {3,4,5} */
         assert(0);
     }
     return lhSize+cLitSize;
@@ -1273,7 +1273,8 @@ typedef enum {
     ZSTD_defaultAllowed = 1
 } ZSTD_defaultPolicy_e;
 
-MEM_STATIC symbolEncodingType_e ZSTD_selectEncodingType(
+MEM_STATIC
+symbolEncodingType_e ZSTD_selectEncodingType(
         FSE_repeat* repeatMode, size_t const mostFrequent, size_t nbSeq,
         U32 defaultNormLog, ZSTD_defaultPolicy_e const isDefaultAllowed)
 {
@@ -1288,10 +1289,12 @@ MEM_STATIC symbolEncodingType_e ZSTD_selectEncodingType(
         *repeatMode = FSE_repeat_check;
         return set_rle;
     }
-    if (isDefaultAllowed && (*repeatMode == FSE_repeat_valid) && (nbSeq < MAX_SEQ_FOR_STATIC_FSE)) {
+    if ( isDefaultAllowed
+      && (*repeatMode == FSE_repeat_valid) && (nbSeq < MAX_SEQ_FOR_STATIC_FSE)) {
         return set_repeat;
     }
-    if (isDefaultAllowed && ((nbSeq < MIN_SEQ_FOR_DYNAMIC_FSE) || (mostFrequent < (nbSeq >> (defaultNormLog-1))))) {
+    if ( isDefaultAllowed
+      && ((nbSeq < MIN_SEQ_FOR_DYNAMIC_FSE) || (mostFrequent < (nbSeq >> (defaultNormLog-1)))) ) {
         *repeatMode = FSE_repeat_valid;
         return set_basic;
     }
@@ -1299,7 +1302,8 @@ MEM_STATIC symbolEncodingType_e ZSTD_selectEncodingType(
     return set_compressed;
 }
 
-MEM_STATIC size_t ZSTD_buildCTable(void* dst, size_t dstCapacity,
+MEM_STATIC
+size_t ZSTD_buildCTable(void* dst, size_t dstCapacity,
         FSE_CTable* CTable, U32 FSELog, symbolEncodingType_e type,
         U32* count, U32 max,
         BYTE const* codeTable, size_t nbSeq,
@@ -1317,7 +1321,7 @@ MEM_STATIC size_t ZSTD_buildCTable(void* dst, size_t dstCapacity,
     case set_repeat:
         return 0;
     case set_basic:
-        CHECK_F(FSE_buildCTable_wksp(CTable, defaultNorm, defaultMax, defaultNormLog, workspace, workspaceSize));
+        CHECK_F(FSE_buildCTable_wksp(CTable, defaultNorm, defaultMax, defaultNormLog, workspace, workspaceSize));  /* note : could be pre-calculated */
         return 0;
     case set_compressed: {
         S16 norm[MaxSeq + 1];
@@ -1339,11 +1343,13 @@ MEM_STATIC size_t ZSTD_buildCTable(void* dst, size_t dstCapacity,
     }
 }
 
-MEM_STATIC size_t ZSTD_encodeSequences(void* dst, size_t dstCapacity,
-    FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
-    FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
-    FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
-    seqDef const* sequences, size_t nbSeq, int longOffsets)
+MEM_STATIC
+size_t ZSTD_encodeSequences(
+            void* dst, size_t dstCapacity,
+            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
+            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
+            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
+            seqDef const* sequences, size_t nbSeq, int longOffsets)
 {
     BIT_CStream_t blockStream;
     FSE_CState_t  stateMatchLength;
@@ -1380,8 +1386,12 @@ MEM_STATIC size_t ZSTD_encodeSequences(void* dst, size_t dstCapacity,
             BYTE const ofCode = ofCodeTable[n];
             BYTE const mlCode = mlCodeTable[n];
             U32  const llBits = LL_bits[llCode];
-            U32  const ofBits = ofCode;                                     /* 32b*/  /* 64b*/
+            U32  const ofBits = ofCode;
             U32  const mlBits = ML_bits[mlCode];
+            DEBUGLOG(6, "encoding: litlen:%u - matchlen:%u - offCode:%u",
+                        sequences[n].litLength,
+                        sequences[n].matchLength + MINMATCH,
+                        sequences[n].offset);                               /* 32b*/  /* 64b*/
                                                                             /* (7)*/  /* (7)*/
             FSE_encodeSymbol(&blockStream, &stateOffsetBits, ofCode);       /* 15 */  /* 15 */
             FSE_encodeSymbol(&blockStream, &stateMatchLength, mlCode);      /* 24 */  /* 24 */
@@ -1462,7 +1472,7 @@ MEM_STATIC size_t ZSTD_compressSequences_internal(seqStore_t* seqStorePtr,
 
     /* convert length/distances into codes */
     ZSTD_seqToCodes(seqStorePtr);
-    /* CTable for Literal Lengths */
+    /* build CTable for Literal Lengths */
     {   U32 max = MaxLL;
         size_t const mostFrequent = FSE_countFast_wksp(count, &max, llCodeTable, nbSeq, entropy->workspace);
         LLtype = ZSTD_selectEncodingType(&entropy->litlength_repeatMode, mostFrequent, nbSeq, LL_defaultNormLog, ZSTD_defaultAllowed);
@@ -1472,11 +1482,11 @@ MEM_STATIC size_t ZSTD_compressSequences_internal(seqStore_t* seqStorePtr,
             if (ZSTD_isError(countSize)) return countSize;
             op += countSize;
     }   }
-    /* CTable for Offsets */
+    /* build CTable for Offsets */
     {   U32 max = MaxOff;
         size_t const mostFrequent = FSE_countFast_wksp(count, &max, ofCodeTable, nbSeq, entropy->workspace);
         /* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */
-        ZSTD_defaultPolicy_e const defaultPolicy = max <= DefaultMaxOff ? ZSTD_defaultAllowed : ZSTD_defaultDisallowed;
+        ZSTD_defaultPolicy_e const defaultPolicy = (max <= DefaultMaxOff) ? ZSTD_defaultAllowed : ZSTD_defaultDisallowed;
         Offtype = ZSTD_selectEncodingType(&entropy->offcode_repeatMode, mostFrequent, nbSeq, OF_defaultNormLog, defaultPolicy);
         {   size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_OffsetBits, OffFSELog, (symbolEncodingType_e)Offtype,
                     count, max, ofCodeTable, nbSeq, OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,
@@ -1484,7 +1494,7 @@ MEM_STATIC size_t ZSTD_compressSequences_internal(seqStore_t* seqStorePtr,
             if (ZSTD_isError(countSize)) return countSize;
             op += countSize;
     }   }
-    /* CTable for MatchLengths */
+    /* build CTable for MatchLengths */
     {   U32 max = MaxML;
         size_t const mostFrequent = FSE_countFast_wksp(count, &max, mlCodeTable, nbSeq, entropy->workspace);
         MLtype = ZSTD_selectEncodingType(&entropy->matchlength_repeatMode, mostFrequent, nbSeq, ML_defaultNormLog, ZSTD_defaultAllowed);
@@ -1497,13 +1507,15 @@ MEM_STATIC size_t ZSTD_compressSequences_internal(seqStore_t* seqStorePtr,
 
     *seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2));
 
-    {   size_t const streamSize = ZSTD_encodeSequences(op, oend - op,
-                CTable_MatchLength, mlCodeTable,
-                CTable_OffsetBits, ofCodeTable,
-                CTable_LitLength, llCodeTable,
-                sequences, nbSeq, longOffsets);
-        if (ZSTD_isError(streamSize)) return streamSize;
-        op += streamSize;
+    {   size_t const bitstreamSize = ZSTD_encodeSequences(
+                                        op, oend - op,
+                                        CTable_MatchLength, mlCodeTable,
+                                        CTable_OffsetBits, ofCodeTable,
+                                        CTable_LitLength, llCodeTable,
+                                        sequences, nbSeq,
+                                        longOffsets);
+        if (ZSTD_isError(bitstreamSize)) return bitstreamSize;
+        op += bitstreamSize;
     }
 
     return op - ostart;
@@ -1517,27 +1529,27 @@ MEM_STATIC size_t ZSTD_compressSequences(seqStore_t* seqStorePtr,
 {
     size_t const cSize = ZSTD_compressSequences_internal(seqStorePtr, entropy, cParams,
                                                          dst, dstCapacity);
-    size_t const minGain = ZSTD_minGain(srcSize);
-    size_t const maxCSize = srcSize - minGain;
     /* If the srcSize <= dstCapacity, then there is enough space to write a
      * raw uncompressed block. Since we ran out of space, the block must not
      * be compressible, so fall back to a raw uncompressed block.
      */
-    int const uncompressibleError = cSize == ERROR(dstSize_tooSmall) && srcSize <= dstCapacity;
-
+    int const uncompressibleError = (cSize == ERROR(dstSize_tooSmall)) && (srcSize <= dstCapacity);
     if (ZSTD_isError(cSize) && !uncompressibleError)
         return cSize;
+
     /* Check compressibility */
-    if (cSize >= maxCSize || uncompressibleError) {
-        entropy->hufCTable_repeatMode = HUF_repeat_none;
-        entropy->offcode_repeatMode = FSE_repeat_none;
-        entropy->matchlength_repeatMode = FSE_repeat_none;
-        entropy->litlength_repeatMode = FSE_repeat_none;
-        return 0;
-    }
+    {   size_t const minGain = ZSTD_minGain(srcSize);  /* note : fixed formula, maybe should depend on compression level, or strategy */
+        size_t const maxCSize = srcSize - minGain;
+        if (cSize >= maxCSize || uncompressibleError) {
+            entropy->hufCTable_repeatMode = HUF_repeat_none;
+            entropy->offcode_repeatMode = FSE_repeat_none;
+            entropy->matchlength_repeatMode = FSE_repeat_none;
+            entropy->litlength_repeatMode = FSE_repeat_none;
+            return 0;  /* block not compressed */
+    }   }
     assert(!ZSTD_isError(cSize));
 
-    /* confirm repcodes */
+    /* block is compressed => confirm repcodes in history */
     { int i; for (i=0; i<ZSTD_REP_NUM; i++) seqStorePtr->rep[i] = seqStorePtr->repToConfirm[i]; }
     return cSize;
 }
@@ -1559,9 +1571,9 @@ ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, int extDict
           ZSTD_compressBlock_btopt_extDict, ZSTD_compressBlock_btultra_extDict }
     };
     ZSTD_STATIC_ASSERT((unsigned)ZSTD_fast == 1);
+
     assert((U32)strat >= (U32)ZSTD_fast);
     assert((U32)strat <= (U32)ZSTD_btultra);
-
     return blockCompressor[extDict!=0][(U32)strat];
 }
 
@@ -1574,28 +1586,28 @@ static void ZSTD_storeLastLiterals(seqStore_t* seqStorePtr,
 
 static size_t ZSTD_compressBlock_internal(ZSTD_CCtx* zc, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
 {
-    const BYTE* const base = zc->base;
-    const BYTE* const istart = (const BYTE*)src;
-    const U32 current = (U32)(istart-base);
-    size_t lastLLSize;
-    const BYTE* anchor;
-    U32 const extDict = zc->lowLimit < zc->dictLimit;
-    const ZSTD_blockCompressor blockCompressor =
-        zc->appliedParams.ldmParams.enableLdm
-            ? (extDict ? ZSTD_compressBlock_ldm_extDict : ZSTD_compressBlock_ldm)
-            : ZSTD_selectBlockCompressor(zc->appliedParams.cParams.strategy, extDict);
-
-    if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1) return 0;   /* don't even attempt compression below a certain srcSize */
+    if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1)
+        return 0;   /* don't even attempt compression below a certain srcSize */
     ZSTD_resetSeqStore(&(zc->seqStore));
-    if (current > zc->nextToUpdate + 384)
-        zc->nextToUpdate = current - MIN(192, (U32)(current - zc->nextToUpdate - 384));   /* limited update after finding a very long match */
-
-    lastLLSize = blockCompressor(zc, src, srcSize);
-
-    /* Last literals */
-    anchor = (const BYTE*)src + srcSize - lastLLSize;
-    ZSTD_storeLastLiterals(&zc->seqStore, anchor, lastLLSize);
 
+    /* limited update after a very long match */
+    {   const BYTE* const base = zc->base;
+        const BYTE* const istart = (const BYTE*)src;
+        const U32 current = (U32)(istart-base);
+        if (current > zc->nextToUpdate + 384)
+            zc->nextToUpdate = current - MIN(192, (U32)(current - zc->nextToUpdate - 384));
+    }
+    /* find and store sequences */
+    {   U32 const extDict = zc->lowLimit < zc->dictLimit;
+        const ZSTD_blockCompressor blockCompressor =
+            zc->appliedParams.ldmParams.enableLdm
+                ? (extDict ? ZSTD_compressBlock_ldm_extDict : ZSTD_compressBlock_ldm)
+                : ZSTD_selectBlockCompressor(zc->appliedParams.cParams.strategy, extDict);
+        size_t const lastLLSize = blockCompressor(zc, src, srcSize);
+        const BYTE* const anchor = (const BYTE*)src + srcSize - lastLLSize;
+        ZSTD_storeLastLiterals(&zc->seqStore, anchor, lastLLSize);
+    }
+    /* encode */
     return ZSTD_compressSequences(&zc->seqStore, zc->entropy, &zc->appliedParams.cParams, dst, dstCapacity, srcSize);
 }
 
@@ -1618,13 +1630,13 @@ static size_t ZSTD_compress_frameChunk (ZSTD_CCtx* cctx,
     BYTE* const ostart = (BYTE*)dst;
     BYTE* op = ostart;
     U32 const maxDist = (U32)1 << cctx->appliedParams.cParams.windowLog;
+    assert(cctx->appliedParams.cParams.windowLog <= 31);
 
     if (cctx->appliedParams.fParams.checksumFlag && srcSize)
         XXH64_update(&cctx->xxhState, src, srcSize);
 
     while (remaining) {
         U32 const lastBlock = lastFrameChunk & (blockSize >= remaining);
-        size_t cSize;
 
         if (dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE)
             return ERROR(dstSize_tooSmall);   /* not enough space to store compressed block */
@@ -1666,34 +1678,37 @@ static size_t ZSTD_compress_frameChunk (ZSTD_CCtx* cctx,
             else cctx->nextToUpdate -= correction;
             DEBUGLOG(4, "Correction of 0x%x bytes to lowLimit=0x%x\n", correction, cctx->lowLimit);
         }
-
+        /* enforce maxDist */
         if ((U32)(ip+blockSize - cctx->base) > cctx->loadedDictEnd + maxDist) {
-            /* enforce maxDist */
             U32 const newLowLimit = (U32)(ip+blockSize - cctx->base) - maxDist;
             if (cctx->lowLimit < newLowLimit) cctx->lowLimit = newLowLimit;
             if (cctx->dictLimit < cctx->lowLimit) cctx->dictLimit = cctx->lowLimit;
         }
 
-        cSize = ZSTD_compressBlock_internal(cctx, op+ZSTD_blockHeaderSize, dstCapacity-ZSTD_blockHeaderSize, ip, blockSize);
-        if (ZSTD_isError(cSize)) return cSize;
+        {   size_t cSize = ZSTD_compressBlock_internal(cctx,
+                                op+ZSTD_blockHeaderSize, dstCapacity-ZSTD_blockHeaderSize,
+                                ip, blockSize);
+            if (ZSTD_isError(cSize)) return cSize;
 
-        if (cSize == 0) {  /* block is not compressible */
-            U32 const cBlockHeader24 = lastBlock + (((U32)bt_raw)<<1) + (U32)(blockSize << 3);
-            if (blockSize + ZSTD_blockHeaderSize > dstCapacity) return ERROR(dstSize_tooSmall);
-            MEM_writeLE32(op, cBlockHeader24);   /* no pb, 4th byte will be overwritten */
-            memcpy(op + ZSTD_blockHeaderSize, ip, blockSize);
-            cSize = ZSTD_blockHeaderSize+blockSize;
-        } else {
-            U32 const cBlockHeader24 = lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
-            MEM_writeLE24(op, cBlockHeader24);
-            cSize += ZSTD_blockHeaderSize;
-        }
+            if (cSize == 0) {  /* block is not compressible */
+                U32 const cBlockHeader24 = lastBlock + (((U32)bt_raw)<<1) + (U32)(blockSize << 3);
+                if (blockSize + ZSTD_blockHeaderSize > dstCapacity) return ERROR(dstSize_tooSmall);
+                MEM_writeLE32(op, cBlockHeader24);   /* 4th byte will be overwritten */
+                memcpy(op + ZSTD_blockHeaderSize, ip, blockSize);
+                cSize = ZSTD_blockHeaderSize + blockSize;
+            } else {
+                U32 const cBlockHeader24 = lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
+                MEM_writeLE24(op, cBlockHeader24);
+                cSize += ZSTD_blockHeaderSize;
+            }
 
-        remaining -= blockSize;
-        dstCapacity -= cSize;
-        ip += blockSize;
-        op += cSize;
-    }
+            ip += blockSize;
+            assert(remaining >= blockSize);
+            remaining -= blockSize;
+            op += cSize;
+            assert(dstCapacity >= cSize);
+            dstCapacity -= cSize;
+    }   }
 
     if (lastFrameChunk && (op>ostart)) cctx->stage = ZSTDcs_ending;
     return op-ostart;
diff --git a/lib/compress/zstd_compress.h b/lib/compress/zstd_compress.h
index 94606edc9..fe98da78d 100644
--- a/lib/compress/zstd_compress.h
+++ b/lib/compress/zstd_compress.h
@@ -127,7 +127,7 @@ MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const v
 #if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 6)
     static const BYTE* g_start = NULL;
     U32 const pos = (U32)((const BYTE*)literals - g_start);
-    if (g_start==NULL) g_start = (const BYTE*)literals;
+    if (g_start==NULL) g_start = (const BYTE*)literals;  /* note : index only works for compression within a single segment */
     if ((pos > 0) && (pos < 1000000000))
         DEBUGLOG(6, "Cpos %6u :%5u literals & match %3u bytes at distance %6u",
                pos, (U32)litLength, (U32)matchCode+MINMATCH, (U32)offsetCode);

From 24ac2dbd2a56dccbfe52293ac98c3cdd8eb0c0c0 Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Fri, 13 Oct 2017 12:47:00 -0700
Subject: [PATCH 003/145] Fix invalid use of dictionary offcode table

Fixes #888.
---
 lib/compress/zstd_compress.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index e072fe30e..3f1a7cdba 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -1536,6 +1536,12 @@ MEM_STATIC size_t ZSTD_compressSequences(seqStore_t* seqStorePtr,
     int const uncompressibleError = (cSize == ERROR(dstSize_tooSmall)) && (srcSize <= dstCapacity);
     if (ZSTD_isError(cSize) && !uncompressibleError)
         return cSize;
+    /* We check that dictionaries have offset codes available for the first
+     * block. After the first block, the offcode table might not have large
+     * enough codes to represent the offsets in the data.
+     */
+    if (entropy->offcode_repeatMode == FSE_repeat_valid)
+        entropy->offcode_repeatMode = FSE_repeat_check;
 
     /* Check compressibility */
     {   size_t const minGain = ZSTD_minGain(srcSize);  /* note : fixed formula, maybe should depend on compression level, or strategy */

From ced6e6189cf02b2de9bfcd7191f77cf9ff07f345 Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Fri, 13 Oct 2017 14:09:17 -0700
Subject: [PATCH 004/145] Add DEBUGLOG() that prints FSE encoding types

---
 lib/compress/zstd_compress.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 3f1a7cdba..188b8e717 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -1282,6 +1282,7 @@ symbolEncodingType_e ZSTD_selectEncodingType(
 #define MAX_SEQ_FOR_STATIC_FSE  1000
     ZSTD_STATIC_ASSERT(ZSTD_defaultDisallowed == 0 && ZSTD_defaultAllowed != 0);
     if ((mostFrequent == nbSeq) && (!isDefaultAllowed || nbSeq > 2)) {
+        DEBUGLOG(5, "Selected set_rle");
         /* Prefer set_basic over set_rle when there are 2 or less symbols,
          * since RLE uses 1 byte, but set_basic uses 5-6 bits per symbol.
          * If basic encoding isn't possible, always choose RLE.
@@ -1291,13 +1292,16 @@ symbolEncodingType_e ZSTD_selectEncodingType(
     }
     if ( isDefaultAllowed
       && (*repeatMode == FSE_repeat_valid) && (nbSeq < MAX_SEQ_FOR_STATIC_FSE)) {
+        DEBUGLOG(5, "Selected set_repeat");
         return set_repeat;
     }
     if ( isDefaultAllowed
       && ((nbSeq < MIN_SEQ_FOR_DYNAMIC_FSE) || (mostFrequent < (nbSeq >> (defaultNormLog-1)))) ) {
+        DEBUGLOG(5, "Selected set_basic");
         *repeatMode = FSE_repeat_valid;
         return set_basic;
     }
+    DEBUGLOG(5, "Selected set_compressed");
     *repeatMode = FSE_repeat_check;
     return set_compressed;
 }
@@ -1475,6 +1479,7 @@ MEM_STATIC size_t ZSTD_compressSequences_internal(seqStore_t* seqStorePtr,
     /* build CTable for Literal Lengths */
     {   U32 max = MaxLL;
         size_t const mostFrequent = FSE_countFast_wksp(count, &max, llCodeTable, nbSeq, entropy->workspace);
+        DEBUGLOG(5, "Building LL table");
         LLtype = ZSTD_selectEncodingType(&entropy->litlength_repeatMode, mostFrequent, nbSeq, LL_defaultNormLog, ZSTD_defaultAllowed);
         {   size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_LitLength, LLFSELog, (symbolEncodingType_e)LLtype,
                     count, max, llCodeTable, nbSeq, LL_defaultNorm, LL_defaultNormLog, MaxLL,
@@ -1487,6 +1492,7 @@ MEM_STATIC size_t ZSTD_compressSequences_internal(seqStore_t* seqStorePtr,
         size_t const mostFrequent = FSE_countFast_wksp(count, &max, ofCodeTable, nbSeq, entropy->workspace);
         /* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */
         ZSTD_defaultPolicy_e const defaultPolicy = (max <= DefaultMaxOff) ? ZSTD_defaultAllowed : ZSTD_defaultDisallowed;
+        DEBUGLOG(5, "Building OF table");
         Offtype = ZSTD_selectEncodingType(&entropy->offcode_repeatMode, mostFrequent, nbSeq, OF_defaultNormLog, defaultPolicy);
         {   size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_OffsetBits, OffFSELog, (symbolEncodingType_e)Offtype,
                     count, max, ofCodeTable, nbSeq, OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,
@@ -1497,6 +1503,7 @@ MEM_STATIC size_t ZSTD_compressSequences_internal(seqStore_t* seqStorePtr,
     /* build CTable for MatchLengths */
     {   U32 max = MaxML;
         size_t const mostFrequent = FSE_countFast_wksp(count, &max, mlCodeTable, nbSeq, entropy->workspace);
+        DEBUGLOG(5, "Building ML table");
         MLtype = ZSTD_selectEncodingType(&entropy->matchlength_repeatMode, mostFrequent, nbSeq, ML_defaultNormLog, ZSTD_defaultAllowed);
         {   size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_MatchLength, MLFSELog, (symbolEncodingType_e)MLtype,
                     count, max, mlCodeTable, nbSeq, ML_defaultNorm, ML_defaultNormLog, MaxML,

From dd18d73e7ef1b204bf514095fa8db7f9d6dfdc7b Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 13 Oct 2017 16:32:18 -0700
Subject: [PATCH 005/145] fileio: content size is enabled by default

---
 lib/compress/zstd_compress.c | 4 ++--
 programs/fileio.c            | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index e072fe30e..eb6f43d8c 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -391,7 +391,7 @@ size_t ZSTD_CCtxParam_setParameter(
 
     case ZSTD_p_contentSizeFlag :
         /* Content size written in frame header _when known_ (default:1) */
-        DEBUGLOG(5, "set content size flag = %u", (value>0));
+        DEBUGLOG(4, "set content size flag = %u", (value>0));
         params->fParams.contentSizeFlag = value > 0;
         return 0;
 
@@ -401,7 +401,7 @@ size_t ZSTD_CCtxParam_setParameter(
         return 0;
 
     case ZSTD_p_dictIDFlag : /* When applicable, dictionary's dictID is provided in frame header (default:1) */
-        DEBUGLOG(5, "set dictIDFlag = %u", (value>0));
+        DEBUGLOG(4, "set dictIDFlag = %u", (value>0));
         params->fParams.noDictIDFlag = (value == 0);
         return 0;
 
diff --git a/programs/fileio.c b/programs/fileio.c
index 70158f930..427f251b9 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -439,6 +439,7 @@ static cRess_t FIO_createCResources(const char* dictFileName, int cLevel,
 
 #ifdef ZSTD_NEWAPI
         {   /* frame parameters */
+            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_contentSizeFlag, 1) );
             CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_dictIDFlag, g_dictIDFlag) );
             CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_checksumFlag, g_checksumFlag) );
             (void)srcSize;

From fb4451664125919e0870b256797f826bad576efc Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 13 Oct 2017 17:39:13 -0700
Subject: [PATCH 006/145] ensure fParams.contentSizeFlag starts at 1

such default was failing for ZSTD_compressBegin/ZSTD_compressContinue
fixed too
---
 lib/compress/zstd_compress.c | 19 +++++++++++--------
 lib/zstd.h                   |  8 ++++----
 tests/fullbench.c            |  2 +-
 3 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index eb6f43d8c..b42e6996f 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -78,6 +78,7 @@ ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem)
     if (!cctx) return NULL;
     cctx->customMem = customMem;
     cctx->requestedParams.compressionLevel = ZSTD_CLEVEL_DEFAULT;
+    cctx->requestedParams.fParams.contentSizeFlag = 1;
     ZSTD_STATIC_ASSERT(zcss_init==0);
     ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN==(0ULL - 1));
     return cctx;
@@ -1002,7 +1003,7 @@ void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx) {
  *  The "context", in this case, refers to the hash and chain tables, entropy
  *  tables, and dictionary offsets.
  *  Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()).
- *  pledgedSrcSize=0 means "empty" if fParams.contentSizeFlag=1
+ *  pledgedSrcSize=0 means "empty".
  *  @return : 0, or an error code */
 static size_t ZSTD_copyCCtx_internal(ZSTD_CCtx* dstCCtx,
                             const ZSTD_CCtx* srcCCtx,
@@ -1059,7 +1060,8 @@ size_t ZSTD_copyCCtx(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx, unsigned long
     ZSTD_frameParameters fParams = { 1 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };
     ZSTD_buffered_policy_e const zbuff = (ZSTD_buffered_policy_e)(srcCCtx->inBuffSize>0);
     ZSTD_STATIC_ASSERT((U32)ZSTDb_buffered==1);
-    fParams.contentSizeFlag = pledgedSrcSize>0;
+    if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;
+    fParams.contentSizeFlag = (pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN);
 
     return ZSTD_copyCCtx_internal(dstCCtx, srcCCtx, fParams, pledgedSrcSize, zbuff);
 }
@@ -2077,7 +2079,7 @@ size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t di
     ZSTD_CCtx_params const cctxParams =
             ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params);
     return ZSTD_compressBegin_internal(cctx, dict, dictSize, ZSTD_dm_auto, NULL,
-                                       cctxParams, 0, ZSTDb_not_buffered);
+                                       cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, ZSTDb_not_buffered);
 }
 
 size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel)
@@ -2797,18 +2799,18 @@ size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
             }
             DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbThreads=%u", params.nbThreads);
             CHECK_F( ZSTDMT_initCStream_internal(
-                             cctx->mtctx,
-                             prefixDict.dict, prefixDict.dictSize, ZSTD_dm_rawContent,
-                             cctx->cdict, params, cctx->pledgedSrcSizePlusOne-1) );
+                        cctx->mtctx,
+                        prefixDict.dict, prefixDict.dictSize, ZSTD_dm_rawContent,
+                        cctx->cdict, params, cctx->pledgedSrcSizePlusOne-1) );
             cctx->streamStage = zcss_load;
             cctx->appliedParams.nbThreads = params.nbThreads;
         } else
 #endif
-        {
-            CHECK_F( ZSTD_resetCStream_internal(
+        {   CHECK_F( ZSTD_resetCStream_internal(
                              cctx, prefixDict.dict, prefixDict.dictSize,
                              prefixDict.dictMode, cctx->cdict, params,
                              cctx->pledgedSrcSizePlusOne-1) );
+            assert(cctx->streamStage == zcss_load);
     }   }
 
     /* compression stage */
@@ -3034,5 +3036,6 @@ ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long srcSizeH
     ZSTD_compressionParameters const cParams = ZSTD_getCParams(compressionLevel, srcSizeHint, dictSize);
     memset(&params, 0, sizeof(params));
     params.cParams = cParams;
+    params.fParams.contentSizeFlag = 1;
     return params;
 }
diff --git a/lib/zstd.h b/lib/zstd.h
index 2194a3b23..7fafdbfc3 100644
--- a/lib/zstd.h
+++ b/lib/zstd.h
@@ -1000,11 +1000,11 @@ typedef enum {
                               * Special: value 0 means "do not change strategy". */
 
     /* frame parameters */
-    ZSTD_p_contentSizeFlag=200, /* Content size is written into frame header _whenever known_ (default:1)
-                              * note that content size must be known at the beginning,
-                              * it is sent using ZSTD_CCtx_setPledgedSrcSize() */
+    ZSTD_p_contentSizeFlag=200, /* Content size will be written into frame header _whenever known_ (default:1)
+                              * Content size must be known at the beginning of compression,
+                              * it is provided using ZSTD_CCtx_setPledgedSrcSize() */
     ZSTD_p_checksumFlag,     /* A 32-bits checksum of content is written at end of frame (default:0) */
-    ZSTD_p_dictIDFlag,       /* When applicable, dictID of dictionary is provided in frame header (default:1) */
+    ZSTD_p_dictIDFlag,       /* When applicable, dictionary's ID is written into frame header (default:1) */
 
     /* multi-threading parameters */
     ZSTD_p_nbThreads=400,    /* Select how many threads a compression job can spawn (default:1)
diff --git a/tests/fullbench.c b/tests/fullbench.c
index db00ce217..3f497b034 100644
--- a/tests/fullbench.c
+++ b/tests/fullbench.c
@@ -233,7 +233,7 @@ static ZSTD_CCtx* g_zcc = NULL;
 size_t local_ZSTD_compressContinue(void* dst, size_t dstCapacity, void* buff2, const void* src, size_t srcSize)
 {
     (void)buff2;
-    ZSTD_compressBegin(g_zcc, 1);
+    ZSTD_compressBegin(g_zcc, 1 /* compressionLevel */);
     return ZSTD_compressEnd(g_zcc, dst, dstCapacity, src, srcSize);
 }
 

From 3c1e3f8ec90a09558bda9b860fc1cbfdd322919c Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 13 Oct 2017 18:32:06 -0700
Subject: [PATCH 007/145] contentSizeFlag enabled by default would also fail
 for streaming and MT operations

fixed
---
 lib/compress/zstd_compress.c   | 14 ++++++++------
 lib/compress/zstdmt_compress.c | 34 +++++++++++++++++-----------------
 tests/zstreamtest.c            |  5 +++--
 3 files changed, 28 insertions(+), 25 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index b42e6996f..49b532b94 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -2053,6 +2053,8 @@ size_t ZSTD_compressBegin_advanced_internal(
                                     ZSTD_CCtx_params params,
                                     unsigned long long pledgedSrcSize)
 {
+    DEBUGLOG(4, "ZSTD_compressBegin_advanced_internal");
+    DEBUGLOG(4, "contentSizeFlag : %u", params.fParams.contentSizeFlag);
     /* compression parameters verification and optimization */
     CHECK_F( ZSTD_checkCParams(params.cParams) );
     return ZSTD_compressBegin_internal(cctx, dict, dictSize, dictMode, NULL,
@@ -2281,7 +2283,7 @@ ZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize,
                                       ZSTD_dictMode_e dictMode,
                                       ZSTD_compressionParameters cParams, ZSTD_customMem customMem)
 {
-    DEBUGLOG(5, "ZSTD_createCDict_advanced, mode %u", (U32)dictMode);
+    DEBUGLOG(4, "ZSTD_createCDict_advanced, mode %u", (U32)dictMode);
     if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
 
     {   ZSTD_CDict* const cdict = (ZSTD_CDict*)ZSTD_malloc(sizeof(ZSTD_CDict), customMem);
@@ -2356,9 +2358,9 @@ ZSTD_CDict* ZSTD_initStaticCDict(void* workspace, size_t workspaceSize,
                             + cctxSize;
     ZSTD_CDict* const cdict = (ZSTD_CDict*) workspace;
     void* ptr;
-    DEBUGLOG(5, "(size_t)workspace & 7 : %u", (U32)(size_t)workspace & 7);
+    DEBUGLOG(4, "(size_t)workspace & 7 : %u", (U32)(size_t)workspace & 7);
     if ((size_t)workspace & 7) return NULL;  /* 8-aligned */
-    DEBUGLOG(5, "(workspaceSize < neededSize) : (%u < %u) => %u",
+    DEBUGLOG(4, "(workspaceSize < neededSize) : (%u < %u) => %u",
         (U32)workspaceSize, (U32)neededSize, (U32)(workspaceSize < neededSize));
     if (workspaceSize < neededSize) return NULL;
 
@@ -2394,7 +2396,7 @@ size_t ZSTD_compressBegin_usingCDict_advanced(
     {   ZSTD_CCtx_params params = cctx->requestedParams;
         params.cParams = ZSTD_getCParamsFromCDict(cdict);
         params.fParams = fParams;
-        DEBUGLOG(5, "ZSTD_compressBegin_usingCDict_advanced");
+        DEBUGLOG(4, "ZSTD_compressBegin_usingCDict_advanced");
         return ZSTD_compressBegin_internal(cctx,
                                            NULL, 0, ZSTD_dm_auto,
                                            cdict,
@@ -2409,7 +2411,7 @@ size_t ZSTD_compressBegin_usingCDict_advanced(
 size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)
 {
     ZSTD_frameParameters const fParams = { 0 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };
-    DEBUGLOG(5, "ZSTD_compressBegin_usingCDict : dictIDFlag == %u", !fParams.noDictIDFlag);
+    DEBUGLOG(4, "ZSTD_compressBegin_usingCDict : dictIDFlag == %u", !fParams.noDictIDFlag);
     return ZSTD_compressBegin_usingCDict_advanced(cctx, cdict, fParams, 0);
 }
 
@@ -2585,7 +2587,7 @@ size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t di
     ZSTD_parameters const params = ZSTD_getParams(compressionLevel, 0, dictSize);
     ZSTD_CCtx_params const cctxParams =
             ZSTD_assignParamsToCCtxParams(zcs->requestedParams, params);
-    return ZSTD_initCStream_internal(zcs, dict, dictSize, NULL, cctxParams, 0);
+    return ZSTD_initCStream_internal(zcs, dict, dictSize, NULL, cctxParams, ZSTD_CONTENTSIZE_UNKNOWN);
 }
 
 size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize)
diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c
index 7831cd3bd..17c69c9df 100644
--- a/lib/compress/zstdmt_compress.c
+++ b/lib/compress/zstdmt_compress.c
@@ -327,6 +327,7 @@ void ZSTDMT_compressChunk(void* jobDescription)
     ZSTD_CCtx* cctx = ZSTDMT_getCCtx(job->cctxPool);
     const void* const src = (const char*)job->srcStart + job->dictSize;
     buffer_t dstBuff = job->dstBuff;
+    DEBUGLOG(5, "ZSTDMT_compressChunk")
     DEBUGLOG(5, "job (first:%u) (last:%u) : dictSize %u, srcSize %u",
                  job->firstChunk, job->lastChunk, (U32)job->dictSize, (U32)job->srcSize);
 
@@ -344,22 +345,22 @@ void ZSTDMT_compressChunk(void* jobDescription)
         job->dstBuff = dstBuff;
     }
 
-    if (job->cdict) {  /* should only happen for first segment */
+    if (job->cdict) {
         size_t const initError = ZSTD_compressBegin_usingCDict_advanced(cctx, job->cdict, job->params.fParams, job->fullFrameSize);
-        DEBUGLOG(5, "using CDict");
+        DEBUGLOG(4, "ZSTDMT_compressChunk, using CDict");
+        assert(job->firstChunk); /* should only happen for first segment */
         if (ZSTD_isError(initError)) { job->cSize = initError; goto _endJob; }
     } else {  /* srcStart points at reloaded section */
-        if (!job->firstChunk) job->params.fParams.contentSizeFlag = 0;  /* ensure no srcSize control */
-        { ZSTD_CCtx_params jobParams = job->params;
-          size_t const forceWindowError =
-              ZSTD_CCtxParam_setParameter(&jobParams, ZSTD_p_forceMaxWindow, !job->firstChunk);
-          /* Force loading dictionary in "content-only" mode (no header analysis) */
-          size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, job->srcStart, job->dictSize, ZSTD_dm_rawContent, jobParams, job->fullFrameSize);
-            if (ZSTD_isError(initError) || ZSTD_isError(forceWindowError)) {
-                job->cSize = initError;
-                goto _endJob;
-            }
-    }   }
+        ZSTD_CCtx_params jobParams = job->params;
+        size_t const forceWindowError = ZSTD_CCtxParam_setParameter(&jobParams, ZSTD_p_forceMaxWindow, !job->firstChunk);
+        U64 const pledgedSrcSize = job->firstChunk ? job->fullFrameSize : ZSTD_CONTENTSIZE_UNKNOWN;
+        /* load dictionary in "content-only" mode (no header analysis) */
+        size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, job->srcStart, job->dictSize, ZSTD_dm_rawContent, jobParams, pledgedSrcSize);
+        if (ZSTD_isError(initError) || ZSTD_isError(forceWindowError)) {
+            job->cSize = initError;
+            goto _endJob;
+        }
+    }
     if (!job->firstChunk) {  /* flush and overwrite frame header when it's not first segment */
         size_t const hSize = ZSTD_compressContinue(cctx, dstBuff.start, dstBuff.size, src, 0);
         if (ZSTD_isError(hSize)) { job->cSize = hSize; goto _endJob; }
@@ -367,7 +368,7 @@ void ZSTDMT_compressChunk(void* jobDescription)
     }
 
     DEBUGLOG(5, "Compressing : ");
-    DEBUG_PRINTHEX(4, job->srcStart, 12);
+    DEBUG_PRINTHEX(6, job->srcStart, 12);
     job->cSize = (job->lastChunk) ?
                  ZSTD_compressEnd     (cctx, dstBuff.start, dstBuff.size, src, job->srcSize) :
                  ZSTD_compressContinue(cctx, dstBuff.start, dstBuff.size, src, job->srcSize);
@@ -610,6 +611,7 @@ static size_t ZSTDMT_compress_advanced_internal(
     assert(jobParams.nbThreads == 0);
     assert(mtctx->cctxPool->totalCCtx == params.nbThreads);
 
+    DEBUGLOG(4, "ZSTDMT_compress_advanced_internal");
     DEBUGLOG(4, "nbChunks  : %2u   (chunkSize : %u bytes)   ", nbChunks, (U32)avgChunkSize);
     if (nbChunks==1) {   /* fallback to single-thread mode */
         ZSTD_CCtx* const cctx = mtctx->cctxPool->cctx[0];
@@ -641,7 +643,7 @@ static size_t ZSTDMT_compress_advanced_internal(
             mtctx->jobs[u].srcStart = srcStart + frameStartPos - dictSize;
             mtctx->jobs[u].dictSize = dictSize;
             mtctx->jobs[u].srcSize = chunkSize;
-            mtctx->jobs[u].cdict = mtctx->nextJobID==0 ? cdict : NULL;
+            mtctx->jobs[u].cdict = (u==0) ? cdict : NULL;
             mtctx->jobs[u].fullFrameSize = srcSize;
             mtctx->jobs[u].params = jobParams;
             /* do not calculate checksum within sections, but write it in header for first section */
@@ -777,7 +779,6 @@ size_t ZSTDMT_initCStream_internal(
     zcs->params = params;
     zcs->frameContentSize = pledgedSrcSize;
     if (dict) {
-        DEBUGLOG(4,"cdictLocal: %08X", (U32)(size_t)zcs->cdictLocal);
         ZSTD_freeCDict(zcs->cdictLocal);
         zcs->cdictLocal = ZSTD_createCDict_advanced(dict, dictSize,
                                                     ZSTD_dlm_byCopy, dictMode, /* note : a loadPrefix becomes an internal CDict */
@@ -785,7 +786,6 @@ size_t ZSTDMT_initCStream_internal(
         zcs->cdict = zcs->cdictLocal;
         if (zcs->cdictLocal == NULL) return ERROR(memory_allocation);
     } else {
-        DEBUGLOG(4,"cdictLocal: %08X", (U32)(size_t)zcs->cdictLocal);
         ZSTD_freeCDict(zcs->cdictLocal);
         zcs->cdictLocal = NULL;
         zcs->cdict = cdict;
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index 8b4c83694..36eede293 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -190,9 +190,10 @@ static int basicUnitTests(U32 seed, double compressibility, ZSTD_customMem custo
 
     /* Basic compression test */
     DISPLAYLEVEL(3, "test%3i : compress %u bytes : ", testNb++, COMPRESSIBLE_NOISE_LENGTH);
-    CHECK_Z( ZSTD_initCStream_usingDict(zc, CNBuffer, dictSize, 1) );
+    CHECK_Z( ZSTD_initCStream_usingDict(zc, CNBuffer, dictSize, 1 /* cLevel */) );
     outBuff.dst = (char*)(compressedBuffer)+cSize;
-    outBuff.size = compressedBufferSize;
+    assert(compressedBufferSize > cSize);
+    outBuff.size = compressedBufferSize - cSize;
     outBuff.pos = 0;
     inBuff.src = CNBuffer;
     inBuff.size = CNBufferSize;

From 213ef3b510b909b7dd95dc472e680ebea25bc450 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 13 Oct 2017 19:01:58 -0700
Subject: [PATCH 008/145] fixed ZSTD_initCStream_advanced() behavior, which
 depends on contentSizeFlag,

and a stream fuzzer test, which was incorrect
(relied on 0 being unconditionnally transformed into `ZSTD_CONTENTSIZE_UNKNOWN`)
---
 lib/compress/zstd_compress.c | 16 ++++++++++++----
 lib/zstd.h                   |  2 +-
 tests/zstreamtest.c          |  5 +++--
 3 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 49b532b94..4ceba415c 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -822,9 +822,8 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
                                       ZSTD_compResetPolicy_e const crp,
                                       ZSTD_buffered_policy_e const zbuff)
 {
-    DEBUGLOG(4, "ZSTD_resetCCtx_internal");
+    DEBUGLOG(4, "ZSTD_resetCCtx_internal: pledgedSrcSize=%u", (U32)pledgedSrcSize);
     assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
-    DEBUGLOG(4, "pledgedSrcSize: %u", (U32)pledgedSrcSize);
 
     if (crp == ZSTDcrp_continue) {
         if (ZSTD_equivalentParams(params, zc->appliedParams)) {
@@ -2500,12 +2499,15 @@ static size_t ZSTD_resetCStream_internal(ZSTD_CStream* zcs,
     return 0;   /* ready to go */
 }
 
+/* ZSTD_resetCStream():
+ * pledgedSrcSize == 0 means "unknown" */
 size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize)
 {
     ZSTD_CCtx_params params = zcs->requestedParams;
-    params.fParams.contentSizeFlag = (pledgedSrcSize > 0);
+    DEBUGLOG(4, "ZSTD_resetCStream: pledgedSrcSize = %u", (U32)pledgedSrcSize);
+    if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;
+    params.fParams.contentSizeFlag = 1;
     params.cParams = ZSTD_getCParamsFromCCtxParams(params, pledgedSrcSize, 0);
-    DEBUGLOG(4, "ZSTD_resetCStream");
     return ZSTD_resetCStream_internal(zcs, NULL, 0, ZSTD_dm_auto, zcs->cdict, params, pledgedSrcSize);
 }
 
@@ -2572,13 +2574,19 @@ size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)
     return ZSTD_initCStream_usingCDict_advanced(zcs, cdict, fParams, 0);  /* note : will check that cdict != NULL */
 }
 
+/* ZSTD_initCStream_advanced() :
+ * pledgedSrcSize is optional: it can be 0, which means "unknown" if contentSizeFlag is set, or "unknown" if contentSizeFlag is not set. */
 size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
                                  const void* dict, size_t dictSize,
                                  ZSTD_parameters params, unsigned long long pledgedSrcSize)
 {
     ZSTD_CCtx_params const cctxParams =
             ZSTD_assignParamsToCCtxParams(zcs->requestedParams, params);
+    DEBUGLOG(4, "ZSTD_initCStream_advanced: pledgedSrcSize=%u, flag=%u",
+            (U32)pledgedSrcSize, params.fParams.contentSizeFlag);
     CHECK_F( ZSTD_checkCParams(params.cParams) );
+    if ((pledgedSrcSize==0) && (params.fParams.contentSizeFlag==0))
+        pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;
     return ZSTD_initCStream_internal(zcs, dict, dictSize, NULL, cctxParams, pledgedSrcSize);
 }
 
diff --git a/lib/zstd.h b/lib/zstd.h
index 7fafdbfc3..2866866be 100644
--- a/lib/zstd.h
+++ b/lib/zstd.h
@@ -734,7 +734,7 @@ ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspa
 ZSTDLIB_API size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize);   /**< pledgedSrcSize must be correct, a size of 0 means unknown.  for a frame size of 0 use initCStream_advanced */
 ZSTDLIB_API size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel); /**< creates of an internal CDict (incompatible with static CCtx), except if dict == NULL or dictSize < 8, in which case no dict is used. Note: dict is loaded with ZSTD_dm_auto (treated as a full zstd dictionary if it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.*/
 ZSTDLIB_API size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, const void* dict, size_t dictSize,
-                                             ZSTD_parameters params, unsigned long long pledgedSrcSize);  /**< pledgedSrcSize is optional and can be 0 (meaning unknown). note: if the contentSizeFlag is set, pledgedSrcSize == 0 means the source size is actually 0. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */
+                                             ZSTD_parameters params, unsigned long long pledgedSrcSize);  /**< pledgedSrcSize is optional: it can be 0, which means "unknown" if contentSizeFlag is set, or "unknown" if contentSizeFlag is not set. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */
 ZSTDLIB_API size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);  /**< note : cdict will just be referenced, and must outlive compression session */
 ZSTDLIB_API size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize);  /**< same as ZSTD_initCStream_usingCDict(), with control over frame parameters */
 
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index 36eede293..3aea22709 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -559,7 +559,7 @@ static int basicUnitTests(U32 seed, double compressibility, ZSTD_customMem custo
     DISPLAYLEVEL(3, "test%3i : ZSTD_initCStream_advanced with pledgedSrcSize=0 and dict : ", testNb++);
     {   ZSTD_parameters params = ZSTD_getParams(5, 0, 0);
         params.fParams.contentSizeFlag = 1;
-        CHECK_Z( ZSTD_initCStream_advanced(zc, dictionary.start, dictionary.filled, params, 0) );
+        CHECK_Z( ZSTD_initCStream_advanced(zc, dictionary.start, dictionary.filled, params, 0 /* pledgedSrcSize==0 means "empty" when params.fParams.contentSizeFlag is set */) );
     } /* cstream advanced shall write content size = 0 */
     inBuff.src = CNBuffer;
     inBuff.size = 0;
@@ -833,10 +833,11 @@ static int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compres
             {   size_t const dictStart = FUZ_rand(&lseed) % (srcBufferSize - dictSize);
                 dict = srcBuffer + dictStart;
             }
-            {   U64 const pledgedSrcSize = (FUZ_rand(&lseed) & 3) ? 0 : maxTestSize;
+            {   U64 const pledgedSrcSize = (FUZ_rand(&lseed) & 3) ? ZSTD_CONTENTSIZE_UNKNOWN : maxTestSize;
                 ZSTD_parameters params = ZSTD_getParams(cLevel, pledgedSrcSize, dictSize);
                 params.fParams.checksumFlag = FUZ_rand(&lseed) & 1;
                 params.fParams.noDictIDFlag = FUZ_rand(&lseed) & 1;
+                params.fParams.contentSizeFlag = FUZ_rand(&lseed) & 1;
                 CHECK_Z ( ZSTD_initCStream_advanced(zc, dict, dictSize, params, pledgedSrcSize) );
         }   }
 

From beb9b4b398cb4a9b98f48a49a1c95cfbd030527c Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 13 Oct 2017 19:09:30 -0700
Subject: [PATCH 009/145] fixed ZSTDMT_initCStream() when contentSizeFlag==1 by
 default

and a wrong test in zstreamtest --mt
---
 lib/compress/zstdmt_compress.c | 2 +-
 tests/zstreamtest.c            | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c
index 17c69c9df..197a2c49e 100644
--- a/lib/compress/zstdmt_compress.c
+++ b/lib/compress/zstdmt_compress.c
@@ -852,7 +852,7 @@ size_t ZSTDMT_initCStream(ZSTDMT_CCtx* zcs, int compressionLevel) {
     ZSTD_CCtx_params cctxParams = zcs->params;
     cctxParams.cParams = params.cParams;
     cctxParams.fParams = params.fParams;
-    return ZSTDMT_initCStream_internal(zcs, NULL, 0, ZSTD_dm_auto, NULL, cctxParams, 0);
+    return ZSTDMT_initCStream_internal(zcs, NULL, 0, ZSTD_dm_auto, NULL, cctxParams, ZSTD_CONTENTSIZE_UNKNOWN);
 }
 
 
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index 3aea22709..38320e8c4 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -1088,13 +1088,13 @@ static int fuzzerTests_MT(U32 seed, U32 nbTests, unsigned startTest, double comp
             {   size_t const dictStart = FUZ_rand(&lseed) % (srcBufferSize - dictSize);
                 dict = srcBuffer + dictStart;
             }
-            {   U64 const pledgedSrcSize = (FUZ_rand(&lseed) & 3) ? 0 : maxTestSize;
+            {   U64 const pledgedSrcSize = (FUZ_rand(&lseed) & 3) ? ZSTD_CONTENTSIZE_UNKNOWN : maxTestSize;
                 ZSTD_parameters params = ZSTD_getParams(cLevel, pledgedSrcSize, dictSize);
                 DISPLAYLEVEL(5, "Init with windowLog = %u and pledgedSrcSize = %u \n",
                     params.cParams.windowLog, (U32)pledgedSrcSize);
                 params.fParams.checksumFlag = FUZ_rand(&lseed) & 1;
                 params.fParams.noDictIDFlag = FUZ_rand(&lseed) & 1;
-                params.fParams.contentSizeFlag = pledgedSrcSize>0;
+                params.fParams.contentSizeFlag = FUZ_rand(&lseed) & 1;
                 DISPLAYLEVEL(5, "checksumFlag : %u \n", params.fParams.checksumFlag);
                 CHECK_Z( ZSTDMT_initCStream_advanced(zc, dict, dictSize, params, pledgedSrcSize) );
                 CHECK_Z( ZSTDMT_setMTCtxParameter(zc, ZSTDMT_p_overlapSectionLog, FUZ_rand(&lseed) % 12) );

From 43914f6a206989432d68bb6abe336e1a662e913d Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 13 Oct 2017 23:47:01 -0700
Subject: [PATCH 010/145] add test for presence of decompressed size field in
 header

previous test was "display" only, it wouldn't trigger an error in case of missing header.
---
 tests/playTests.sh | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/tests/playTests.sh b/tests/playTests.sh
index bc021648c..013182aeb 100755
--- a/tests/playTests.sh
+++ b/tests/playTests.sh
@@ -600,7 +600,7 @@ $ECHO "\n**** zstd --list/-l single frame tests ****"
 ./datagen > tmp3
 $ZSTD tmp*
 $ZSTD -l *.zst
-$ZSTD -lv *.zst
+$ZSTD -lv *.zst | grep "Decompressed Size:"  # check that decompressed size is present in header
 $ZSTD --list *.zst
 $ZSTD --list -v *.zst
 
@@ -609,8 +609,6 @@ cat tmp1.zst tmp2.zst > tmp12.zst
 cat tmp12.zst tmp3.zst > tmp123.zst
 $ZSTD -l *.zst
 $ZSTD -lv *.zst
-$ZSTD --list *.zst
-$ZSTD --list -v *.zst
 
 $ECHO "\n**** zstd --list/-l error detection tests ****"
 ! $ZSTD -l tmp1 tmp1.zst
@@ -627,9 +625,9 @@ $ZSTD -lv tmp5.zst
 ! $ZSTD -lv tmp5*
 
 $ECHO "\n**** zstd --list/-l test with no content size field ****"
-./datagen -g1MB | $ZSTD > tmp6.zst
+./datagen -g513K | $ZSTD > tmp6.zst
 $ZSTD -l tmp6.zst
-$ZSTD -lv tmp6.zst
+! $ZSTD -lv tmp6.zst | grep "Decompressed Size:"  # must NOT be present in header
 
 $ECHO "\n**** zstd --list/-l test with no checksum ****"
 $ZSTD -f --no-check tmp1

From 9ef32b3cf1cbf5276f3e6dd0484de1ddd258b4a4 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Sat, 14 Oct 2017 00:02:32 -0700
Subject: [PATCH 011/145] minor : zstd -l -v display each file name

---
 programs/fileio.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/programs/fileio.c b/programs/fileio.c
index 427f251b9..01e901ed8 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -1927,7 +1927,7 @@ static int getFileInfo(fileInfo_t* info, const char* inFileName){
     return detectError;
 }
 
-static void displayInfo(const char* inFileName, fileInfo_t* info, int displayLevel){
+static void displayInfo(const char* inFileName, const fileInfo_t* info, int displayLevel){
     unsigned const unit = info->compressedSize < (1 MB) ? (1 KB) : (1 MB);
     const char* const unitStr = info->compressedSize < (1 MB) ? "KB" : "MB";
     double const windowSizeUnit = (double)info->windowSize / unit;
@@ -1950,8 +1950,10 @@ static void displayInfo(const char* inFileName, fileInfo_t* info, int displayLev
                     checkString, inFileName);
         }
     } else {
+        DISPLAYOUT("%s \n", inFileName);
         DISPLAYOUT("# Zstandard Frames: %d\n", info->numActualFrames);
-        DISPLAYOUT("# Skippable Frames: %d\n", info->numSkippableFrames);
+        if (info->numSkippableFrames)
+            DISPLAYOUT("# Skippable Frames: %d\n", info->numSkippableFrames);
         DISPLAYOUT("Window Size: %.2f %2s (%llu B)\n",
                    windowSizeUnit, unitStr,
                    (unsigned long long)info->windowSize);
@@ -1983,7 +1985,6 @@ static fileInfo_t FIO_addFInfo(fileInfo_t fi1, fileInfo_t fi2)
 }
 
 static int FIO_listFile(fileInfo_t* total, const char* inFileName, int displayLevel){
-    /* initialize info to avoid warnings */
     fileInfo_t info;
     memset(&info, 0, sizeof(info));
     {   int const error = getFileInfo(&info, inFileName);
@@ -2023,7 +2024,7 @@ int FIO_listMultipleFiles(unsigned numFiles, const char** filenameTable, int dis
         for (u=0; u<numFiles;u++) {
             error |= FIO_listFile(&total, filenameTable[u], displayLevel);
         }
-        if (numFiles > 1 && displayLevel <= 2) {
+        if (numFiles > 1 && displayLevel <= 2) {   /* display total */
             unsigned const unit = total.compressedSize < (1 MB) ? (1 KB) : (1 MB);
             const char* const unitStr = total.compressedSize < (1 MB) ? "KB" : "MB";
             double const compressedSizeUnit = (double)total.compressedSize / unit;
@@ -2043,8 +2044,7 @@ int FIO_listMultipleFiles(unsigned numFiles, const char** filenameTable, int dis
                         total.numSkippableFrames,
                         compressedSizeUnit, unitStr, decompressedSizeUnit, unitStr,
                         ratio, checkString, total.nbFiles);
-            }
-        }
+        }   }
         return error;
     }
 }

From 5eed8e7a5538be8fc39ab94d1a61e161bbc348b9 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Sat, 14 Oct 2017 00:32:06 -0700
Subject: [PATCH 012/145] changed API comments to invite using macro
 ZSTD_CONTENTSIZE_UNKNOWN

to mean "pledgedSrcSize is not known at init time" instead of `0`.
Note that, a few prototypes created and documented with `0` to mean "unknown" still interpret "0" as unknown,
to avoid breaking 3rd party applications which depend on this behavior.
But this value is no longer recommended to mean "unknown".

In some future version, it might be possible to switch "0" to mean "empty",
as is already the case for several prototypes.
The advantage is that pledgedSrcSize field would have same behavior accross entire API,
making it easier to reason about.

Note that all concerned prototypes belong to the "experimental" API section.

srcSize is controlled at end of compression,
so if someone uses "0" to mean "unknown" while it effectively means "empty",
this is immediately caught by the compression function, which generates an error code : ZSTD_ERROR_srcSize_wrong
---
 doc/zstd_manual.html | 26 ++++++++++++++------------
 lib/zstd.h           | 18 ++++++++++--------
 2 files changed, 24 insertions(+), 20 deletions(-)

diff --git a/doc/zstd_manual.html b/doc/zstd_manual.html
index b4720adac..7ef86a23d 100644
--- a/doc/zstd_manual.html
+++ b/doc/zstd_manual.html
@@ -631,10 +631,10 @@ size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMet
 
 <h3>Advanced Streaming compression functions</h3><pre></pre><b><pre>ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);
 ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize);    </b>/**< same as ZSTD_initStaticCCtx() */<b>
-size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize);   </b>/**< pledgedSrcSize must be correct, a size of 0 means unknown.  for a frame size of 0 use initCStream_advanced */<b>
+size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize);   </b>/**< pledgedSrcSize must be correct. If it is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs, a size of 0 is interepreted as "unknown". But it may change in some future version to mean "empty". */<b>
 size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel); </b>/**< creates of an internal CDict (incompatible with static CCtx), except if dict == NULL or dictSize < 8, in which case no dict is used. Note: dict is loaded with ZSTD_dm_auto (treated as a full zstd dictionary if it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.*/<b>
 size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, const void* dict, size_t dictSize,
-                                             ZSTD_parameters params, unsigned long long pledgedSrcSize);  </b>/**< pledgedSrcSize is optional and can be 0 (meaning unknown). note: if the contentSizeFlag is set, pledgedSrcSize == 0 means the source size is actually 0. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */<b>
+                                             ZSTD_parameters params, unsigned long long pledgedSrcSize);  </b>/**< pledgedSrcSize : If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */<b>
 size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);  </b>/**< note : cdict will just be referenced, and must outlive compression session */<b>
 size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize);  </b>/**< same as ZSTD_initCStream_usingCDict(), with control over frame parameters */<b>
 </pre></b><BR>
@@ -642,9 +642,11 @@ size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const ZSTD_CDict*
 </b><p>  start a new compression job, using same parameters from previous job.
   This is typically useful to skip dictionary loading stage, since it will re-use it in-place..
   Note that zcs must be init at least once before using ZSTD_resetCStream().
-  pledgedSrcSize==0 means "srcSize unknown".
+  If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN.
   If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end.
-  @return : 0, or an error code (which can be tested using ZSTD_isError()) 
+  For the time being, pledgedSrcSize==0 is interpreted as "srcSize unknown" for compatibility with older programs,
+  but it may change to mean "empty" in some future version, so prefer using macro ZSTD_CONTENTSIZE_UNKNOWN.
+ @return : 0, or an error code (which can be tested using ZSTD_isError()) 
 </p></pre><BR>
 
 <h3>Advanced Streaming decompression functions</h3><pre></pre><b><pre>ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem);
@@ -693,10 +695,10 @@ size_t ZSTD_resetDStream(ZSTD_DStream* zds);  </b>/**< re-use decompression para
 
 <h3>Buffer-less streaming compression functions</h3><pre></pre><b><pre>size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel);
 size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);
-size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); </b>/**< pledgedSrcSize is optional and can be 0 (meaning unknown). note: if the contentSizeFlag is set, pledgedSrcSize == 0 means the source size is actually 0 */<b>
+size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); </b>/**< pledgedSrcSize : If srcSize is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN */<b>
 size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict); </b>/**< note: fails if cdict==NULL */<b>
-size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize);   </b>/* compression parameters are already set within cdict. pledgedSrcSize=0 means null-size */<b>
-size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, unsigned long long pledgedSrcSize); </b>/**<  note: if pledgedSrcSize can be 0, indicating unknown size.  if it is non-zero, it must be accurate.  for 0 size frames, use compressBegin_advanced */<b>
+size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize);   </b>/* compression parameters are already set within cdict. pledgedSrcSize must be correct. If srcSize is not known, use macro ZSTD_CONTENTSIZE_UNKNOWN */<b>
+size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, unsigned long long pledgedSrcSize); </b>/**<  note: if pledgedSrcSize is not known, use ZSTD_CONTENTSIZE_UNKNOWN */<b>
 </pre></b><BR>
 <a name="Chapter19"></a><h2>Buffer-less streaming decompression (synchronous mode)</h2><pre>
   A ZSTD_DCtx object is required to track streaming operations.
@@ -848,11 +850,11 @@ size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long
                               * Special: value 0 means "do not change strategy". */
 
     </b>/* frame parameters */<b>
-    ZSTD_p_contentSizeFlag=200, </b>/* Content size is written into frame header _whenever known_ (default:1)<b>
-                              * note that content size must be known at the beginning,
-                              * it is sent using ZSTD_CCtx_setPledgedSrcSize() */
+    ZSTD_p_contentSizeFlag=200, </b>/* Content size will be written into frame header _whenever known_ (default:1)<b>
+                              * Content size must be known at the beginning of compression,
+                              * it is provided using ZSTD_CCtx_setPledgedSrcSize() */
     ZSTD_p_checksumFlag,     </b>/* A 32-bits checksum of content is written at end of frame (default:0) */<b>
-    ZSTD_p_dictIDFlag,       </b>/* When applicable, dictID of dictionary is provided in frame header (default:1) */<b>
+    ZSTD_p_dictIDFlag,       </b>/* When applicable, dictionary's ID is written into frame header (default:1) */<b>
 
     </b>/* multi-threading parameters */<b>
     ZSTD_p_nbThreads=400,    </b>/* Select how many threads a compression job can spawn (default:1)<b>
@@ -913,7 +915,7 @@ size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long
  @result : 0, or an error code (which can be tested with ZSTD_isError()).
   Note 1 : 0 means zero, empty.
            In order to mean "unknown content size", pass constant ZSTD_CONTENTSIZE_UNKNOWN.
-           Note that ZSTD_CONTENTSIZE_UNKNOWN is default value for new compression jobs.
+           ZSTD_CONTENTSIZE_UNKNOWN is default value for any new compression job.
   Note 2 : If all data is provided and consumed in a single round,
            this value is overriden by srcSize instead. 
 </p></pre><BR>
diff --git a/lib/zstd.h b/lib/zstd.h
index 2866866be..e9c4ff9d4 100644
--- a/lib/zstd.h
+++ b/lib/zstd.h
@@ -731,10 +731,10 @@ ZSTDLIB_API unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize);
 /*=====   Advanced Streaming compression functions  =====*/
 ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);
 ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticCCtx() */
-ZSTDLIB_API size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize);   /**< pledgedSrcSize must be correct, a size of 0 means unknown.  for a frame size of 0 use initCStream_advanced */
+ZSTDLIB_API size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize);   /**< pledgedSrcSize must be correct. If it is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs, a size of 0 is interepreted as "unknown". But it may change in some future version to mean "empty". */
 ZSTDLIB_API size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel); /**< creates of an internal CDict (incompatible with static CCtx), except if dict == NULL or dictSize < 8, in which case no dict is used. Note: dict is loaded with ZSTD_dm_auto (treated as a full zstd dictionary if it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.*/
 ZSTDLIB_API size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, const void* dict, size_t dictSize,
-                                             ZSTD_parameters params, unsigned long long pledgedSrcSize);  /**< pledgedSrcSize is optional: it can be 0, which means "unknown" if contentSizeFlag is set, or "unknown" if contentSizeFlag is not set. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */
+                                             ZSTD_parameters params, unsigned long long pledgedSrcSize);  /**< pledgedSrcSize : If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */
 ZSTDLIB_API size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);  /**< note : cdict will just be referenced, and must outlive compression session */
 ZSTDLIB_API size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize);  /**< same as ZSTD_initCStream_usingCDict(), with control over frame parameters */
 
@@ -742,9 +742,11 @@ ZSTDLIB_API size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const
  *  start a new compression job, using same parameters from previous job.
  *  This is typically useful to skip dictionary loading stage, since it will re-use it in-place..
  *  Note that zcs must be init at least once before using ZSTD_resetCStream().
- *  pledgedSrcSize==0 means "srcSize unknown".
+ *  If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN.
  *  If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end.
- *  @return : 0, or an error code (which can be tested using ZSTD_isError()) */
+ *  For the time being, pledgedSrcSize==0 is interpreted as "srcSize unknown" for compatibility with older programs,
+ *  but it may change to mean "empty" in some future version, so prefer using macro ZSTD_CONTENTSIZE_UNKNOWN.
+ * @return : 0, or an error code (which can be tested using ZSTD_isError()) */
 ZSTDLIB_API size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);
 
 
@@ -800,10 +802,10 @@ ZSTDLIB_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);  /**< re-use decompress
 /*=====   Buffer-less streaming compression functions  =====*/
 ZSTDLIB_API size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel);
 ZSTDLIB_API size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);
-ZSTDLIB_API size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); /**< pledgedSrcSize is optional and can be 0 (meaning unknown). note: if the contentSizeFlag is set, pledgedSrcSize == 0 means the source size is actually 0 */
+ZSTDLIB_API size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); /**< pledgedSrcSize : If srcSize is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN */
 ZSTDLIB_API size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict); /**< note: fails if cdict==NULL */
-ZSTDLIB_API size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize);   /* compression parameters are already set within cdict. pledgedSrcSize=0 means null-size */
-ZSTDLIB_API size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, unsigned long long pledgedSrcSize); /**<  note: if pledgedSrcSize can be 0, indicating unknown size.  if it is non-zero, it must be accurate.  for 0 size frames, use compressBegin_advanced */
+ZSTDLIB_API size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize);   /* compression parameters are already set within cdict. pledgedSrcSize must be correct. If srcSize is not known, use macro ZSTD_CONTENTSIZE_UNKNOWN */
+ZSTDLIB_API size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, unsigned long long pledgedSrcSize); /**<  note: if pledgedSrcSize is not known, use ZSTD_CONTENTSIZE_UNKNOWN */
 
 ZSTDLIB_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
 ZSTDLIB_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
@@ -1066,7 +1068,7 @@ ZSTDLIB_API size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param
  * @result : 0, or an error code (which can be tested with ZSTD_isError()).
  *  Note 1 : 0 means zero, empty.
  *           In order to mean "unknown content size", pass constant ZSTD_CONTENTSIZE_UNKNOWN.
- *           Note that ZSTD_CONTENTSIZE_UNKNOWN is default value for new compression jobs.
+ *           ZSTD_CONTENTSIZE_UNKNOWN is default value for any new compression job.
  *  Note 2 : If all data is provided and consumed in a single round,
  *           this value is overriden by srcSize instead. */
 ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize);

From fc8d293460d6767558843ac8231c249dcc704382 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Sat, 14 Oct 2017 01:21:43 -0700
Subject: [PATCH 013/145] dictionary compression use correct file size
 estimation

when determining compression parameters
to compress one file only.

For multiple files, it still "bets" that files are going to be small.

There was also a bug recently added in ZSTD_CCtx_loadDictionary_advanced()
making it incapable to use pledgedSrcSize to determine compression parameters.
---
 lib/compress/zstd_compress.c | 2 +-
 programs/fileio.c            | 9 +++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 4ceba415c..c7872e7be 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -531,7 +531,7 @@ size_t ZSTD_CCtx_loadDictionary_advanced(
         cctx->cdict = NULL;
     } else {
         ZSTD_compressionParameters const cParams =
-                ZSTD_getCParamsFromCCtxParams(cctx->requestedParams, 0, dictSize);
+                ZSTD_getCParamsFromCCtxParams(cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1, dictSize);
         cctx->cdictLocal = ZSTD_createCDict_advanced(
                                 dict, dictSize,
                                 dictLoadMethod, dictMode,
diff --git a/programs/fileio.c b/programs/fileio.c
index 01e901ed8..17ad31b32 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -442,7 +442,6 @@ static cRess_t FIO_createCResources(const char* dictFileName, int cLevel,
             CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_contentSizeFlag, 1) );
             CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_dictIDFlag, g_dictIDFlag) );
             CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_checksumFlag, g_checksumFlag) );
-            (void)srcSize;
             /* compression level */
             CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_compressionLevel, cLevel) );
             /* long distance matching */
@@ -468,7 +467,9 @@ static cRess_t FIO_createCResources(const char* dictFileName, int cLevel,
             DISPLAYLEVEL(5,"set nb threads = %u \n", g_nbThreads);
             CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_nbThreads, g_nbThreads) );
             /* dictionary */
+            CHECK( ZSTD_CCtx_setPledgedSrcSize(ress.cctx, srcSize) );  /* just to load dictionary with good compression parameters */
             CHECK( ZSTD_CCtx_loadDictionary(ress.cctx, dictBuffer, dictBuffSize) );
+            CHECK( ZSTD_CCtx_setPledgedSrcSize(ress.cctx, ZSTD_CONTENTSIZE_UNKNOWN) );  /* reset */
         }
 #elif defined(ZSTD_MULTITHREAD)
         {   ZSTD_parameters params = ZSTD_getParams(cLevel, srcSize, dictBuffSize);
@@ -1006,7 +1007,7 @@ int FIO_compressMultipleFilenames(const char** inFileNamesTable, unsigned nbFile
     size_t dfnSize = FNSPACE;
     char*  dstFileName = (char*)malloc(FNSPACE);
     size_t const suffixSize = suffix ? strlen(suffix) : 0;
-    U64 const srcSize = (nbFiles != 1) ? 0 : UTIL_getFileSize(inFileNamesTable[0]) ;
+    U64 const srcSize = (nbFiles != 1) ? ZSTD_CONTENTSIZE_UNKNOWN : UTIL_getFileSize(inFileNamesTable[0]) ;
     cRess_t ress = FIO_createCResources(dictFileName, compressionLevel, srcSize, comprParams);
 
     /* init */
@@ -1032,9 +1033,9 @@ int FIO_compressMultipleFilenames(const char** inFileNamesTable, unsigned nbFile
                 free(dstFileName);
                 dfnSize = ifnSize + 20;
                 dstFileName = (char*)malloc(dfnSize);
-                if (!dstFileName)
+                if (!dstFileName) {
                     EXM_THROW(30, "zstd: %s", strerror(errno));
-            }
+            }   }
             strcpy(dstFileName, inFileNamesTable[u]);
             strcat(dstFileName, suffix);
             missed_files += FIO_compressFilename_dstFile(ress, dstFileName, inFileNamesTable[u], compressionLevel);

From 7f961ba6cd592217696cc43c9a133c7ffafada17 Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Fri, 13 Oct 2017 13:23:57 -0700
Subject: [PATCH 014/145] Don't allow default tables to repeat

It isn't useful in any case to repeat default tables.
Saves a few bytes on Silesia, since we don't trigger the dictionary
heuristic.

Before: 211988480 => 73651998 bytes
After:  211988480 => 73651721 bytes
---
 lib/compress/zstd_compress.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 188b8e717..43e5f5461 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -1298,7 +1298,13 @@ symbolEncodingType_e ZSTD_selectEncodingType(
     if ( isDefaultAllowed
       && ((nbSeq < MIN_SEQ_FOR_DYNAMIC_FSE) || (mostFrequent < (nbSeq >> (defaultNormLog-1)))) ) {
         DEBUGLOG(5, "Selected set_basic");
-        *repeatMode = FSE_repeat_valid;
+        /* The format allows default tables to be repeated, but it isn't useful.
+         * When using simple heuristics to select encoding type, we don't want
+         * to confuse these tables with dictionaries. When running more careful
+         * analysis, we don't need to waste time checking both repeating tables
+         * and default tables.
+         */
+        *repeatMode = FSE_repeat_none;
         return set_basic;
     }
     DEBUGLOG(5, "Selected set_compressed");

From 241c57adffe34a8267dd9526cece87b8751468d2 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Mon, 16 Oct 2017 14:01:42 -0700
Subject: [PATCH 015/145] playtest : minor cosmetic changes

---
 tests/playTests.sh | 68 +++++++++++++++++++++++-----------------------
 1 file changed, 34 insertions(+), 34 deletions(-)

diff --git a/tests/playTests.sh b/tests/playTests.sh
index 013182aeb..f008d8998 100755
--- a/tests/playTests.sh
+++ b/tests/playTests.sh
@@ -91,7 +91,7 @@ else
     hasMT="true"
 fi
 
-$ECHO "\n**** simple tests **** "
+$ECHO "\n===>  simple tests "
 
 ./datagen > tmp
 $ECHO "test : basic compression "
@@ -166,7 +166,7 @@ $ZSTD -f tmp && die "tmp not present : should have failed"
 test ! -f tmp.zst  # tmp.zst should not be created
 
 
-$ECHO "\n**** Advanced compression parameters **** "
+$ECHO "\n===>  Advanced compression parameters "
 $ECHO "Hello world!" | $ZSTD --zstd=windowLog=21,      - -o tmp.zst && die "wrong parameters not detected!"
 $ECHO "Hello world!" | $ZSTD --zstd=windowLo=21        - -o tmp.zst && die "wrong parameters not detected!"
 $ECHO "Hello world!" | $ZSTD --zstd=windowLog=21,slog  - -o tmp.zst && die "wrong parameters not detected!"
@@ -180,14 +180,14 @@ roundTripTest -g512K " --long --zstd=ldmhlog=20,ldmslen=64,ldmblog=1,ldmhevery=7
 roundTripTest -g512K 19
 
 
-$ECHO "\n**** Pass-Through mode **** "
+$ECHO "\n===>  Pass-Through mode "
 $ECHO "Hello world 1!" | $ZSTD -df
 $ECHO "Hello world 2!" | $ZSTD -dcf
 $ECHO "Hello world 3!" > tmp1
 $ZSTD -dcf tmp1
 
 
-$ECHO "\n**** frame concatenation **** "
+$ECHO "\n===>  frame concatenation "
 
 $ECHO "hello " > hello.tmp
 $ECHO "world!" > world.tmp
@@ -218,7 +218,7 @@ $ECHO "$ECHO foo | $ZSTD | $ZSTD -d > /dev/full"
 $ECHO foo | $ZSTD | $ZSTD -d > /dev/full && die "write error not detected!"
 
 
-$ECHO "\n**** symbolic link test **** "
+$ECHO "\n===>  symbolic link test "
 
 rm -f hello.tmp world.tmp hello.tmp.zst world.tmp.zst
 $ECHO "hello world" > hello.tmp
@@ -233,7 +233,7 @@ rm -f hello.tmp world.tmp hello.tmp.zst world.tmp.zst
 fi
 
 
-$ECHO "\n**** test sparse file support **** "
+$ECHO "\n===>  test sparse file support "
 
 ./datagen -g5M  -P100 > tmpSparse
 $ZSTD tmpSparse -c | $ZSTD -dv -o tmpSparseRegen
@@ -260,7 +260,7 @@ $DIFF tmpSparse2M tmpSparseRegenerated
 rm tmpSparse*
 
 
-$ECHO "\n**** multiple files tests **** "
+$ECHO "\n===>  multiple files tests "
 
 ./datagen -s1        > tmp1 2> $INTOVOID
 ./datagen -s2 -g100K > tmp2 2> $INTOVOID
@@ -283,7 +283,7 @@ $ECHO "compress multiple files including a missing one (notHere) : "
 $ZSTD -f tmp1 notHere tmp2 && die "missing file not detected!"
 
 
-$ECHO "\n**** dictionary tests **** "
+$ECHO "\n===>  dictionary tests "
 
 $ECHO "- test with raw dict (content only) "
 ./datagen > tmpDict
@@ -339,7 +339,7 @@ $ZSTD --train-legacy -q tmp && die "Dictionary training should fail : source is
 rm tmp*
 
 
-$ECHO "\n**** cover dictionary tests **** "
+$ECHO "\n===>  cover dictionary builder : advanced options "
 
 TESTFILE=../programs/zstdcli.c
 ./datagen > tmpDict
@@ -359,7 +359,7 @@ $ECHO "- Create dictionary with size limit"
 $ZSTD --train-cover=steps=8 *.c ../programs/*.c -o tmpDict2 --maxdict=4K
 rm tmp*
 
-$ECHO "\n**** legacy dictionary tests **** "
+$ECHO "\n===>  legacy dictionary builder "
 
 TESTFILE=../programs/zstdcli.c
 ./datagen > tmpDict
@@ -380,7 +380,7 @@ $ZSTD --train-legacy -s9 *.c ../programs/*.c -o tmpDict2 --maxdict=4K
 rm tmp*
 
 
-$ECHO "\n**** integrity tests **** "
+$ECHO "\n===>  integrity tests "
 
 $ECHO "test one file (tmp1.zst) "
 ./datagen > tmp1
@@ -405,13 +405,13 @@ $ZSTD -t tmpSplit.* && die "bad file not detected !"
 
 
 
-$ECHO "\n**** golden files tests **** "
+$ECHO "\n===>  golden files tests "
 
 $ZSTD -t -r files
 $ZSTD -c -r files | $ZSTD -t
 
 
-$ECHO "\n**** benchmark mode tests **** "
+$ECHO "\n===>  benchmark mode tests "
 
 $ECHO "bench one file"
 ./datagen > tmp1
@@ -422,7 +422,7 @@ $ECHO "with recursive and quiet modes"
 $ZSTD -rqi1b1e2 tmp1
 
 
-$ECHO "\n**** gzip compatibility tests **** "
+$ECHO "\n===>  gzip compatibility tests "
 
 GZIPMODE=1
 $ZSTD --format=gzip -V || GZIPMODE=0
@@ -445,7 +445,7 @@ else
 fi
 
 
-$ECHO "\n**** gzip frame tests **** "
+$ECHO "\n===>  gzip frame tests "
 
 if [ $GZIPMODE -eq 1 ]; then
     ./datagen > tmp
@@ -459,7 +459,7 @@ else
 fi
 
 
-$ECHO "\n**** xz compatibility tests **** "
+$ECHO "\n===>  xz compatibility tests "
 
 LZMAMODE=1
 $ZSTD --format=xz -V || LZMAMODE=0
@@ -505,7 +505,7 @@ else
 fi
 
 
-$ECHO "\n**** xz frame tests **** "
+$ECHO "\n===>  xz frame tests "
 
 if [ $LZMAMODE -eq 1 ]; then
     ./datagen > tmp
@@ -520,7 +520,7 @@ else
     $ECHO "xz mode not supported"
 fi
 
-$ECHO "\n**** lz4 compatibility tests **** "
+$ECHO "\n===>  lz4 compatibility tests "
 
 LZ4MODE=1
 $ZSTD --format=lz4 -V || LZ4MODE=0
@@ -543,7 +543,7 @@ else
 fi
 
 
-$ECHO "\n**** lz4 frame tests **** "
+$ECHO "\n===>  lz4 frame tests "
 
 if [ $LZ4MODE -eq 1 ]; then
     ./datagen > tmp
@@ -556,7 +556,7 @@ else
     $ECHO "lz4 mode not supported"
 fi
 
-$ECHO "\n**** zstd round-trip tests **** "
+$ECHO "\n===>  zstd round-trip tests "
 
 roundTripTest
 roundTripTest -g15K       # TableID==3
@@ -569,7 +569,7 @@ roundTripTest -g516K 19   # btopt
 
 fileRoundTripTest -g500K
 
-$ECHO "\n**** zstd long distance matching round-trip tests **** "
+$ECHO "\n===>  zstd long distance matching round-trip tests "
 roundTripTest -g0 "2 --long"
 roundTripTest -g1000K "1 --long"
 roundTripTest -g517K "6 --long"
@@ -580,21 +580,21 @@ fileRoundTripTest -g5M "3 --long"
 
 if [ -n "$hasMT" ]
 then
-    $ECHO "\n**** zstdmt round-trip tests **** "
+    $ECHO "\n===>  zstdmt round-trip tests "
     roundTripTest -g4M "1 -T0"
     roundTripTest -g8M "3 -T2"
     roundTripTest -g8000K "2 --threads=2"
     fileRoundTripTest -g4M "19 -T2 -B1M"
 
-    $ECHO "\n**** zstdmt long distance matching round-trip tests **** "
+    $ECHO "\n===>  zstdmt long distance matching round-trip tests "
     roundTripTest -g8M "3 --long -T2"
 else
-    $ECHO "\n**** no multithreading, skipping zstdmt tests **** "
+    $ECHO "\n===>  no multithreading, skipping zstdmt tests "
 fi
 
 rm tmp*
 
-$ECHO "\n**** zstd --list/-l single frame tests ****"
+$ECHO "\n===>  zstd --list/-l single frame tests "
 ./datagen > tmp1
 ./datagen > tmp2
 ./datagen > tmp3
@@ -604,19 +604,19 @@ $ZSTD -lv *.zst | grep "Decompressed Size:"  # check that decompressed size is p
 $ZSTD --list *.zst
 $ZSTD --list -v *.zst
 
-$ECHO "\n**** zstd --list/-l multiple frame tests ****"
+$ECHO "\n===>  zstd --list/-l multiple frame tests "
 cat tmp1.zst tmp2.zst > tmp12.zst
 cat tmp12.zst tmp3.zst > tmp123.zst
 $ZSTD -l *.zst
 $ZSTD -lv *.zst
 
-$ECHO "\n**** zstd --list/-l error detection tests ****"
+$ECHO "\n===>  zstd --list/-l error detection tests "
 ! $ZSTD -l tmp1 tmp1.zst
 ! $ZSTD --list tmp*
 ! $ZSTD -lv tmp1*
 ! $ZSTD --list -v tmp2 tmp12.zst
 
-$ECHO "\n**** zstd --list/-l test with null files ****"
+$ECHO "\n===>  zstd --list/-l test with null files "
 ./datagen -g0 > tmp5
 $ZSTD tmp5
 $ZSTD -l tmp5.zst
@@ -624,12 +624,12 @@ $ZSTD -l tmp5.zst
 $ZSTD -lv tmp5.zst
 ! $ZSTD -lv tmp5*
 
-$ECHO "\n**** zstd --list/-l test with no content size field ****"
+$ECHO "\n===>  zstd --list/-l test with no content size field "
 ./datagen -g513K | $ZSTD > tmp6.zst
 $ZSTD -l tmp6.zst
 ! $ZSTD -lv tmp6.zst | grep "Decompressed Size:"  # must NOT be present in header
 
-$ECHO "\n**** zstd --list/-l test with no checksum ****"
+$ECHO "\n===>   zstd --list/-l test with no checksum "
 $ZSTD -f --no-check tmp1
 $ZSTD -l tmp1.zst
 $ZSTD -lv tmp1.zst
@@ -637,7 +637,7 @@ $ZSTD -lv tmp1.zst
 rm tmp*
 
 
-$ECHO "\n**** zstd long distance matching tests **** "
+$ECHO "\n===>   zstd long distance matching tests "
 roundTripTest -g0 " --long"
 roundTripTest -g9M "2 --long"
 # Test parameter parsing
@@ -652,7 +652,7 @@ if [ "$1" != "--test-large-data" ]; then
     exit 0
 fi
 
-$ECHO "\n**** large files tests **** "
+$ECHO "\n===>   large files tests "
 
 roundTripTest -g270000000 1
 roundTripTest -g250000000 2
@@ -683,7 +683,7 @@ roundTripTest -g5000000000 -P99 1
 fileRoundTripTest -g4193M -P99 1
 
 
-$ECHO "\n**** zstd long, long distance matching round-trip tests **** "
+$ECHO "\n===>   zstd long, long distance matching round-trip tests "
 roundTripTest -g270000000 "1 --long"
 roundTripTest -g130000000 -P60 "5 --long"
 roundTripTest -g35000000 -P70 "8 --long"
@@ -695,7 +695,7 @@ roundTripTest -g600M -P50 "1 --long --zstd=wlog=29,clog=28"
 
 if [ -n "$hasMT" ]
 then
-    $ECHO "\n**** zstdmt long round-trip tests **** "
+    $ECHO "\n===>   zstdmt long round-trip tests "
     roundTripTest -g80000000 -P99 "19 -T2" " "
     roundTripTest -g5000000000 -P99 "1 -T2" " "
     roundTripTest -g500000000 -P97 "1 -T999" " "

From 13bfe885aa72eadbeed15eaa86f36c265fa68c7b Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Mon, 16 Oct 2017 14:06:22 -0700
Subject: [PATCH 016/145] edited ZSTD_initCStream_advanced() comment

---
 lib/compress/zstd_compress.c | 3 ++-
 lib/zstd.h                   | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index c7872e7be..35fa99e6f 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -2575,7 +2575,8 @@ size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)
 }
 
 /* ZSTD_initCStream_advanced() :
- * pledgedSrcSize is optional: it can be 0, which means "unknown" if contentSizeFlag is set, or "unknown" if contentSizeFlag is not set. */
+ * pledgedSrcSize : if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN.
+ * dict is loaded with default parameters ZSTD_dm_auto and ZSTD_dlm_byCopy. */
 size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
                                  const void* dict, size_t dictSize,
                                  ZSTD_parameters params, unsigned long long pledgedSrcSize)
diff --git a/lib/zstd.h b/lib/zstd.h
index e9c4ff9d4..4681d3f2a 100644
--- a/lib/zstd.h
+++ b/lib/zstd.h
@@ -734,7 +734,7 @@ ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspa
 ZSTDLIB_API size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize);   /**< pledgedSrcSize must be correct. If it is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs, a size of 0 is interepreted as "unknown". But it may change in some future version to mean "empty". */
 ZSTDLIB_API size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel); /**< creates of an internal CDict (incompatible with static CCtx), except if dict == NULL or dictSize < 8, in which case no dict is used. Note: dict is loaded with ZSTD_dm_auto (treated as a full zstd dictionary if it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.*/
 ZSTDLIB_API size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, const void* dict, size_t dictSize,
-                                             ZSTD_parameters params, unsigned long long pledgedSrcSize);  /**< pledgedSrcSize : If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */
+                                             ZSTD_parameters params, unsigned long long pledgedSrcSize);  /**< pledgedSrcSize : if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */
 ZSTDLIB_API size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);  /**< note : cdict will just be referenced, and must outlive compression session */
 ZSTDLIB_API size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize);  /**< same as ZSTD_initCStream_usingCDict(), with control over frame parameters */
 

From e600b5d0dab674e480e6538ad7eaffbdbb72f029 Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Mon, 16 Oct 2017 17:18:43 -0700
Subject: [PATCH 017/145] [test] Exercise all codes in dictionary tables

---
 tests/Makefile      |   2 +-
 tests/seqgen.c      | 260 ++++++++++++++++++++++++++++++++++++++++++++
 tests/seqgen.h      |  58 ++++++++++
 tests/zstreamtest.c | 131 +++++++++++++++++++---
 4 files changed, 436 insertions(+), 15 deletions(-)
 create mode 100644 tests/seqgen.c
 create mode 100644 tests/seqgen.h

diff --git a/tests/Makefile b/tests/Makefile
index 651833bbb..eb8bb3dd6 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -130,7 +130,7 @@ zbufftest-dll : $(ZSTDDIR)/common/xxhash.c $(PRGDIR)/datagen.c zbufftest.c
 	$(MAKE) -C $(ZSTDDIR) libzstd
 	$(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@$(EXT)
 
-ZSTREAMFILES := $(ZSTD_FILES) $(ZDICT_FILES) $(PRGDIR)/datagen.c zstreamtest.c
+ZSTREAMFILES := $(ZSTD_FILES) $(ZDICT_FILES) $(PRGDIR)/datagen.c seqgen.c zstreamtest.c
 zstreamtest : CPPFLAGS += $(MULTITHREAD_CPP)
 zstreamtest : LDFLAGS += $(MULTITHREAD_LD)
 zstreamtest : $(ZSTREAMFILES)
diff --git a/tests/seqgen.c b/tests/seqgen.c
new file mode 100644
index 000000000..8233ecee1
--- /dev/null
+++ b/tests/seqgen.c
@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) 2017-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#include "seqgen.h"
+#include "mem.h"
+#include <string.h>
+
+#define MIN(a, b)  ((a) < (b) ? (a) : (b))
+
+static const size_t kMatchBytes = 128;
+
+#define SEQ_rotl32(x,r) ((x << r) | (x >> (32 - r)))
+static BYTE SEQ_randByte(U32* src)
+{
+    static const U32 prime1 = 2654435761U;
+    static const U32 prime2 = 2246822519U;
+    U32 rand32 = *src;
+    rand32 *= prime1;
+    rand32 ^= prime2;
+    rand32  = SEQ_rotl32(rand32, 13);
+    *src = rand32;
+    return (BYTE)(rand32 >> 5);
+}
+
+SEQ_stream SEQ_initStream(unsigned seed)
+{
+    SEQ_stream stream;
+    stream.state = 0;
+    XXH64_reset(&stream.xxh, 0);
+    stream.seed = seed;
+    return stream;
+}
+
+/* Generates a single guard byte, then match length + 1 of a different byte,
+ * then another guard byte.
+ */
+static size_t SEQ_gen_matchLength(SEQ_stream* stream, unsigned value,
+                                  SEQ_outBuffer* out)
+{
+    typedef enum {
+        ml_first_byte = 0,
+        ml_match_bytes,
+        ml_last_byte,
+    } ml_state;
+    BYTE* const ostart = (BYTE*)out->dst;
+    BYTE* const oend = ostart + out->size;
+    BYTE* op = ostart + out->pos;
+
+    switch ((ml_state)stream->state) {
+    case ml_first_byte:
+        /* Generate a single byte and pick a different byte for the match */
+        if (op >= oend) {
+            stream->bytesLeft = 1;
+            break;
+        }
+        *op = SEQ_randByte(&stream->seed) & 0xFF;
+        do {
+            stream->saved = SEQ_randByte(&stream->seed) & 0xFF;
+        } while (*op == stream->saved);
+        ++op;
+        /* State transition */
+        stream->state = ml_match_bytes;
+        stream->bytesLeft = value + 1;
+    /* fall-through */
+    case ml_match_bytes: {
+        /* Copy matchLength + 1 bytes to the output buffer */
+        size_t const setLength = MIN(stream->bytesLeft, (size_t)(oend - op));
+        if (setLength > 0) {
+            memset(op, stream->saved, setLength);
+            op += setLength;
+            stream->bytesLeft -= setLength;
+        }
+        if (stream->bytesLeft > 0)
+            break;
+        /* State transition */
+        stream->state = ml_last_byte;
+    }
+    /* fall-through */
+    case ml_last_byte:
+        /* Generate a single byte and pick a different byte for the match */
+        if (op >= oend) {
+            stream->bytesLeft = 1;
+            break;
+        }
+        do {
+            *op = SEQ_randByte(&stream->seed) & 0xFF;
+        } while (*op == stream->saved);
+        ++op;
+        /* State transition */
+    /* fall-through */
+    default:
+        stream->state = 0;
+        stream->bytesLeft = 0;
+        break;
+    }
+    XXH64_update(&stream->xxh, ostart + out->pos, (op - ostart) - out->pos);
+    out->pos = op - ostart;
+    return stream->bytesLeft;
+}
+
+/* Saves the current seed then generates kMatchBytes random bytes >= 128.
+ * Generates literal length - kMatchBytes random bytes < 128.
+ * Generates another kMatchBytes using the saved seed to generate a match.
+ * This way the match is easy to find for the compressors.
+ */
+static size_t SEQ_gen_litLength(SEQ_stream* stream, unsigned value, SEQ_outBuffer* out)
+{
+    typedef enum {
+        ll_start = 0,
+        ll_run_bytes,
+        ll_literals,
+        ll_run_match,
+    } ll_state;
+    BYTE* const ostart = (BYTE*)out->dst;
+    BYTE* const oend = ostart + out->size;
+    BYTE* op = ostart + out->pos;
+
+    switch ((ll_state)stream->state) {
+    case ll_start:
+        stream->state = ll_run_bytes;
+        stream->saved = stream->seed;
+        stream->bytesLeft = MIN(kMatchBytes, value);
+    /* fall-through */
+    case ll_run_bytes:
+        while (stream->bytesLeft > 0 && op < oend) {
+            *op++ = SEQ_randByte(&stream->seed) | 0x80;
+            --stream->bytesLeft;
+        }
+        if (stream->bytesLeft > 0)
+            break;
+        /* State transition */
+        stream->state = ll_literals;
+        stream->bytesLeft = value - MIN(kMatchBytes, value);
+    /* fall-through */
+    case ll_literals:
+        while (stream->bytesLeft > 0 && op < oend) {
+            *op++ = SEQ_randByte(&stream->seed) & 0x7F;
+            --stream->bytesLeft;
+        }
+        if (stream->bytesLeft > 0)
+            break;
+        /* State transition */
+        stream->state = ll_run_match;
+        stream->bytesLeft = MIN(kMatchBytes, value);
+    /* fall-through */
+    case ll_run_match: {
+        while (stream->bytesLeft > 0 && op < oend) {
+            *op++ = SEQ_randByte(&stream->saved) | 0x80;
+            --stream->bytesLeft;
+        }
+        if (stream->bytesLeft > 0)
+            break;
+    }
+    /* fall-through */
+    default:
+        stream->state = 0;
+        stream->bytesLeft = 0;
+        break;
+    }
+    XXH64_update(&stream->xxh, ostart + out->pos, (op - ostart) - out->pos);
+    out->pos = op - ostart;
+    return stream->bytesLeft;
+}
+
+/* Saves the current seed then generates kMatchBytes random bytes >= 128.
+ * Generates offset - kMatchBytes of zeros to get a large offset without
+ * polluting the hash tables.
+ * Generates another kMatchBytes using the saved seed to generate a with the
+ * required offset.
+ */
+static size_t SEQ_gen_offset(SEQ_stream* stream, unsigned value, SEQ_outBuffer* out)
+{
+    typedef enum {
+        of_start = 0,
+        of_run_bytes,
+        of_offset,
+        of_run_match,
+    } of_state;
+    BYTE* const ostart = (BYTE*)out->dst;
+    BYTE* const oend = ostart + out->size;
+    BYTE* op = ostart + out->pos;
+
+    switch ((of_state)stream->state) {
+    case of_start:
+        stream->state = of_run_bytes;
+        stream->saved = stream->seed;
+        stream->bytesLeft = MIN(value, kMatchBytes);
+    /* fall-through */
+    case of_run_bytes: {
+        while (stream->bytesLeft > 0 && op < oend) {
+            *op++ = SEQ_randByte(&stream->seed) | 0x80;
+            --stream->bytesLeft;
+        }
+        if (stream->bytesLeft > 0)
+            break;
+        /* State transition */
+        stream->state = of_offset;
+        stream->bytesLeft = value - MIN(value, kMatchBytes);
+    }
+    /* fall-through */
+    case of_offset: {
+        /* Copy matchLength + 1 bytes to the output buffer */
+        size_t const setLength = MIN(stream->bytesLeft, (size_t)(oend - op));
+        if (setLength > 0) {
+            memset(op, 0, setLength);
+            op += setLength;
+            stream->bytesLeft -= setLength;
+        }
+        if (stream->bytesLeft > 0)
+            break;
+        /* State transition */
+        stream->state = of_run_match;
+        stream->bytesLeft = MIN(value, kMatchBytes);
+    }
+    /* fall-through */
+    case of_run_match: {
+        while (stream->bytesLeft > 0 && op < oend) {
+            *op++ = SEQ_randByte(&stream->saved) | 0x80;
+            --stream->bytesLeft;
+        }
+        if (stream->bytesLeft > 0)
+            break;
+    }
+    /* fall-through */
+    default:
+        stream->state = 0;
+        stream->bytesLeft = 0;
+        break;
+    }
+    XXH64_update(&stream->xxh, ostart + out->pos, (op - ostart) - out->pos);
+    out->pos = op - ostart;
+    return stream->bytesLeft;
+}
+
+/* Returns the number of bytes left to generate.
+ * Must pass the same type/value until it returns 0.
+ */
+size_t SEQ_gen(SEQ_stream* stream, SEQ_gen_type type, unsigned value, SEQ_outBuffer* out)
+{
+    switch (type) {
+        case SEQ_gen_ml: return SEQ_gen_matchLength(stream, value, out);
+        case SEQ_gen_ll: return SEQ_gen_litLength(stream, value, out);
+        case SEQ_gen_of: return SEQ_gen_offset(stream, value, out);
+        case SEQ_gen_max: /* fall-through */
+        default: return 0;
+    }
+}
+
+/* Returns the xxhash of the data produced so far */
+XXH64_hash_t SEQ_digest(SEQ_stream const* stream)
+{
+    return XXH64_digest(&stream->xxh);
+}
diff --git a/tests/seqgen.h b/tests/seqgen.h
new file mode 100644
index 000000000..72d798846
--- /dev/null
+++ b/tests/seqgen.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2017-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef SEQGEN_H
+#define SEQGEN_H
+
+#define XXH_STATIC_LINKING_ONLY
+
+#include "xxhash.h"
+#include <stddef.h>   /* size_t */
+
+typedef enum {
+    SEQ_gen_ml = 0,
+    SEQ_gen_ll,
+    SEQ_gen_of,
+    SEQ_gen_max /* Must be the last value */
+} SEQ_gen_type;
+
+/* Internal state, do not use */
+typedef struct {
+    XXH64_state_t xxh; /* xxh state for all the data produced so far (seed=0) */
+    unsigned seed;
+    int state; /* enum to control state machine (clean=0) */
+    unsigned saved;
+    size_t bytesLeft;
+} SEQ_stream;
+
+SEQ_stream SEQ_initStream(unsigned seed);
+
+typedef struct {
+    void* dst;
+    size_t size;
+    size_t pos;
+} SEQ_outBuffer;
+
+/* Returns non-zero until the current type/value has been generated.
+ * Must pass the same type/value until it returns 0.
+ *
+ * Recommended to pick a value in the middle of the range you want, since there
+ * may be some noise that causes actual results to be slightly different.
+ * We try to be more accurate for smaller values.
+ *
+ * NOTE: Very small values don't work well (< 6).
+ */
+size_t SEQ_gen(SEQ_stream* stream, SEQ_gen_type type, unsigned value,
+               SEQ_outBuffer* out);
+
+/* Returns the xxhash of the data produced so far */
+XXH64_hash_t SEQ_digest(SEQ_stream const* stream);
+
+#endif /* SEQGEN_H */
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index 8b4c83694..1b42bd5d8 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -36,6 +36,7 @@
 #include "datagen.h"      /* RDG_genBuffer */
 #define XXH_STATIC_LINKING_ONLY   /* XXH64_state_t */
 #include "xxhash.h"       /* XXH64_* */
+#include "seqgen.h"
 
 
 /*-************************************
@@ -96,15 +97,21 @@ unsigned int FUZ_rand(unsigned int* seedPtr)
     return rand32 >> 5;
 }
 
-#define CHECK_Z(f) {                                         \
-    size_t const err = f;                                    \
-    if (ZSTD_isError(err)) {                                 \
-        DISPLAY("Error => %s : %s ",                         \
-                #f, ZSTD_getErrorName(err));                 \
-        DISPLAY(" (seed %u, test nb %u)  \n", seed, testNb); \
+#define CHECK(cond, ...) {                                   \
+    if (cond) {                                              \
+        DISPLAY("Error => ");                                \
+        DISPLAY(__VA_ARGS__);                                \
+        DISPLAY(" (seed %u, test nb %u, line %u)  \n",       \
+                seed, testNb, __LINE__);                     \
         goto _output_error;                                  \
 }   }
 
+#define CHECK_Z(f) {                                         \
+    size_t const err = f;                                    \
+    CHECK(ZSTD_isError(err), "%s : %s ",                     \
+          #f, ZSTD_getErrorName(err));                       \
+}
+
 
 /*======================================================
 *   Basic Unit tests
@@ -144,6 +151,63 @@ static void FUZ_freeDictionary(buffer_t dict)
     free(dict.start);
 }
 
+/* Round trips data and updates xxh with the decompressed data produced */
+static size_t SEQ_roundTrip(ZSTD_CCtx* cctx, ZSTD_DCtx* dctx,
+                            XXH64_state_t* xxh, void* data, size_t size,
+                            ZSTD_EndDirective endOp)
+{
+    static BYTE compressed[1024];
+    static BYTE uncompressed[1024];
+
+    ZSTD_inBuffer cin = {data, size, 0};
+    size_t cret;
+
+    do {
+        ZSTD_outBuffer cout = {compressed, sizeof(compressed), 0};
+        ZSTD_inBuffer din = {compressed, 0, 0};
+        ZSTD_outBuffer dout = {uncompressed, 0, 0};
+
+        cret = ZSTD_compress_generic(cctx, &cout, &cin, endOp);
+        if (ZSTD_isError(cret))
+            return cret;
+
+        din.size = cout.pos;
+        while (din.pos < din.size || (endOp == ZSTD_e_end && cret == 0)) {
+            size_t dret;
+
+            dout.pos = 0;
+            dout.size = sizeof(uncompressed);
+            dret = ZSTD_decompressStream(dctx, &dout, &din);
+            if (ZSTD_isError(dret))
+                return dret;
+            XXH64_update(xxh, dout.dst, dout.pos);
+            if (dret == 0)
+                break;
+        }
+    } while (cin.pos < cin.size || (endOp != ZSTD_e_continue && cret != 0));
+    return 0;
+}
+
+/* Generates some data and round trips it */
+static size_t SEQ_generateRoundTrip(ZSTD_CCtx* cctx, ZSTD_DCtx* dctx,
+                                    XXH64_state_t* xxh, SEQ_stream* seq,
+                                    SEQ_gen_type type, unsigned value)
+{
+    static BYTE data[1024];
+    size_t gen;
+
+    do {
+        SEQ_outBuffer sout = {data, sizeof(data), 0};
+        size_t ret;
+        gen = SEQ_gen(seq, type, value, &sout);
+
+        ret = SEQ_roundTrip(cctx, dctx, xxh, sout.dst, sout.pos, ZSTD_e_continue);
+        if (ZSTD_isError(ret))
+            return ret;
+    } while (gen != 0);
+
+    return 0;
+}
 
 static int basicUnitTests(U32 seed, double compressibility, ZSTD_customMem customMem)
 {
@@ -618,6 +682,53 @@ static int basicUnitTests(U32 seed, double compressibility, ZSTD_customMem custo
       if (r != 0) goto _output_error; }  /* error, or some data not flushed */
     DISPLAYLEVEL(3, "OK \n");
 
+    DISPLAYLEVEL(3, "test%3i : check dictionary FSE tables can represent every code : ", testNb++);
+    {   unsigned const kMaxWindowLog = 24;
+        unsigned value;
+        ZSTD_compressionParameters cParams = ZSTD_getCParams(3, 1U << kMaxWindowLog, 1024);
+        ZSTD_CDict* cdict;
+        ZSTD_DDict* ddict;
+        SEQ_stream seq = SEQ_initStream(0x87654321);
+        SEQ_gen_type type;
+        XXH64_state_t xxh;
+
+        XXH64_reset(&xxh, 0);
+        cParams.windowLog = kMaxWindowLog;
+        cdict = ZSTD_createCDict_advanced(dictionary.start, dictionary.filled, ZSTD_dlm_byRef, ZSTD_dm_fullDict, cParams, ZSTD_defaultCMem);
+        ddict = ZSTD_createDDict(dictionary.start, dictionary.filled);
+
+        if (!cdict || !ddict) goto _output_error;
+
+        ZSTD_CCtx_reset(zc);
+        ZSTD_resetDStream(zd);
+        CHECK_Z(ZSTD_CCtx_refCDict(zc, cdict));
+        CHECK_Z(ZSTD_initDStream_usingDDict(zd, ddict));
+        CHECK_Z(ZSTD_setDStreamParameter(zd, DStream_p_maxWindowSize, 1U << kMaxWindowLog));
+        /* Test all values < 300 */
+        for (value = 0; value < 300; ++value) {
+            for (type = (SEQ_gen_type)0; type < SEQ_gen_max; ++type) {
+                CHECK_Z(SEQ_generateRoundTrip(zc, zd, &xxh, &seq, type, value));
+            }
+        }
+        /* Test values 2^8 to 2^17 */
+        for (value = (1 << 8); value < (1 << 17); value <<= 1) {
+            for (type = (SEQ_gen_type)0; type < SEQ_gen_max; ++type) {
+                CHECK_Z(SEQ_generateRoundTrip(zc, zd, &xxh, &seq, type, value));
+                CHECK_Z(SEQ_generateRoundTrip(zc, zd, &xxh, &seq, type, value + (value >> 2)));
+            }
+        }
+        /* Test offset values up to the max window log */
+        for (value = 8; value <= kMaxWindowLog; ++value) {
+            CHECK_Z(SEQ_generateRoundTrip(zc, zd, &xxh, &seq, SEQ_gen_of, (1U << value) - 1));
+        }
+
+        CHECK_Z(SEQ_roundTrip(zc, zd, &xxh, NULL, 0, ZSTD_e_end));
+        CHECK(SEQ_digest(&seq) != XXH64_digest(&xxh), "SEQ XXH64 does not match");
+
+        ZSTD_freeCDict(cdict);
+        ZSTD_freeDDict(ddict);
+    }
+    DISPLAYLEVEL(3, "OK \n");
 
     /* Overlen overwriting window data bug */
     DISPLAYLEVEL(3, "test%3i : wildcopy doesn't overwrite potential match data : ", testNb++);
@@ -708,14 +819,6 @@ static U32 FUZ_randomClampedLength(U32* seed, U32 minVal, U32 maxVal)
     return (U32)((FUZ_rand(seed) % mod) + minVal);
 }
 
-#define CHECK(cond, ...) {                                   \
-    if (cond) {                                              \
-        DISPLAY("Error => ");                                \
-        DISPLAY(__VA_ARGS__);                                \
-        DISPLAY(" (seed %u, test nb %u)  \n", seed, testNb); \
-        goto _output_error;                                  \
-}   }
-
 static int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compressibility, int bigTests)
 {
     U32 const maxSrcLog = bigTests ? 24 : 22;

From e2bf70ece1a623fbe4e6fdf1c4e5f03bb7011873 Mon Sep 17 00:00:00 2001
From: "W. Felix Handte" <w@felixhandte.com>
Date: Tue, 17 Oct 2017 16:02:39 -0400
Subject: [PATCH 018/145] Add `check` Target to Makefile

---
 Makefile | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Makefile b/Makefile
index 2805c8ad4..f2487c591 100644
--- a/Makefile
+++ b/Makefile
@@ -72,6 +72,9 @@ zstdmt:
 zlibwrapper:
 	$(MAKE) -C $(ZWRAPDIR) test
 
+.PHONY: check
+check: shortest
+
 .PHONY: test shortest
 test shortest:
 	$(MAKE) -C $(PRGDIR) allVariants

From 32c9f715ae1532d4ea06ee5f811ed61c46e48d31 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 17 Oct 2017 14:07:43 -0700
Subject: [PATCH 019/145] fixed : Visual build compressing stdin with
 multi-threading enabled fails

It was multiple reasons stacked :
- Visual use a different code path, because ZSTD_NEWAPI is not defined
- fileio.c sends `0` as `pledgedSrcSize` to mean `ZSTD_CONTENTSIZE_UNKNOWN`  (fixed)
- ZSTDMT_resetCCtx() interpreted `0` as "empty" instead of "unknown" (fixed)
---
 lib/compress/zstdmt_compress.c | 5 ++++-
 lib/compress/zstdmt_compress.h | 2 +-
 programs/Makefile              | 4 ++--
 programs/fileio.c              | 6 +++---
 4 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c
index 197a2c49e..af7be3167 100644
--- a/lib/compress/zstdmt_compress.c
+++ b/lib/compress/zstdmt_compress.c
@@ -838,9 +838,12 @@ size_t ZSTDMT_initCStream_usingCDict(ZSTDMT_CCtx* mtctx,
 
 
 /* ZSTDMT_resetCStream() :
- * pledgedSrcSize is optional and can be zero == unknown */
+ * pledgedSrcSize can be zero == unknown (for the time being)
+ * prefer using ZSTD_CONTENTSIZE_UNKNOWN,
+ * as `0` might mean "empty" in the future */
 size_t ZSTDMT_resetCStream(ZSTDMT_CCtx* zcs, unsigned long long pledgedSrcSize)
 {
+    if (!pledgedSrcSize) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;
     if (zcs->params.nbThreads==1)
         return ZSTD_resetCStream(zcs->cctxPool->cctx[0], pledgedSrcSize);
     return ZSTDMT_initCStream_internal(zcs, NULL, 0, ZSTD_dm_auto, 0, zcs->params,
diff --git a/lib/compress/zstdmt_compress.h b/lib/compress/zstdmt_compress.h
index 8c59c684f..a7ce7c7dd 100644
--- a/lib/compress/zstdmt_compress.h
+++ b/lib/compress/zstdmt_compress.h
@@ -50,7 +50,7 @@ ZSTDLIB_API size_t ZSTDMT_compressCCtx(ZSTDMT_CCtx* mtctx,
 /* ===   Streaming functions   === */
 
 ZSTDLIB_API size_t ZSTDMT_initCStream(ZSTDMT_CCtx* mtctx, int compressionLevel);
-ZSTDLIB_API size_t ZSTDMT_resetCStream(ZSTDMT_CCtx* mtctx, unsigned long long pledgedSrcSize);    /**< pledgedSrcSize is optional and can be zero == unknown */
+ZSTDLIB_API size_t ZSTDMT_resetCStream(ZSTDMT_CCtx* mtctx, unsigned long long pledgedSrcSize);  /**< if srcSize is not known at reset time, use ZSTD_CONTENTSIZE_UNKNOWN. Note: for compatibility with older programs, 0 means the same as ZSTD_CONTENTSIZE_UNKNOWN, but it may change in the future, to mean "empty" */
 
 ZSTDLIB_API size_t ZSTDMT_compressStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
 
diff --git a/programs/Makefile b/programs/Makefile
index cbb67e9fe..1b21281b4 100644
--- a/programs/Makefile
+++ b/programs/Makefile
@@ -37,8 +37,8 @@ endif
 
 CPPFLAGS+= -I$(ZSTDDIR) -I$(ZSTDDIR)/common -I$(ZSTDDIR)/compress \
            -I$(ZSTDDIR)/dictBuilder \
-           -DZSTD_NEWAPI \
-           -DXXH_NAMESPACE=ZSTD_   # because xxhash.o already compiled with this macro from library
+           -DXXH_NAMESPACE=ZSTD_ \
+           -DZSTD_NEWAPI
 CFLAGS  ?= -O3
 DEBUGFLAGS+=-Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \
             -Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement \
diff --git a/programs/fileio.c b/programs/fileio.c
index 17ad31b32..03e653893 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -817,11 +817,11 @@ static int FIO_compressFilename_internal(cRess_t ress,
     /* init */
 #ifdef ZSTD_NEWAPI
     if (fileSize!=0)  /* when src is stdin, fileSize==0, but is effectively unknown */
-        ZSTD_CCtx_setPledgedSrcSize(ress.cctx, fileSize);  /* note : fileSize==0 means "empty" */
+        ZSTD_CCtx_setPledgedSrcSize(ress.cctx, fileSize);
 #elif defined(ZSTD_MULTITHREAD)
-    CHECK( ZSTDMT_resetCStream(ress.cctx, fileSize) );   /* note : fileSize==0 means "unknown" */
+    CHECK( ZSTDMT_resetCStream(ress.cctx, fileSize ? fileSize : ZSTD_CONTENTSIZE_UNKNOWN) );
 #else
-    CHECK( ZSTD_resetCStream(ress.cctx, fileSize) );   /* note : fileSize==0 means "unknown" */
+    CHECK( ZSTD_resetCStream(ress.cctx, fileSize ? fileSize : ZSTD_CONTENTSIZE_UNKNOWN) );
 #endif
 
     /* Main compression loop */

From 18b795374a4d1e0b308fdf6e86b1ea08b4489489 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 17 Oct 2017 16:14:25 -0700
Subject: [PATCH 020/145] UTIL_getFileSize() returns UTIL_FILESIZE_UNKNOWN on
 failure

UTIL_getFileSize() used to return zero on failure.
This made it impossible to distinguish a failure from a genuine empty file.
Both cases where coalesced.

Adding UTIL_FILESIZE_UNKNOWN constant has many consequences on user code,
since in many places, the `0` was assumed to mean "error".
This is no longer the case, and the error code must be actively checked.
---
 programs/bench.c                  | 14 +++++++--
 programs/dibio.c                  |  7 +++--
 programs/fileio.c                 | 50 ++++++++++++++++++++-----------
 programs/util.h                   | 35 +++++++++++++---------
 tests/fullbench.c                 |  9 ++++--
 tests/paramgrill.c                | 10 +++++++
 zlibWrapper/examples/zwrapbench.c | 13 ++++++--
 7 files changed, 95 insertions(+), 43 deletions(-)

diff --git a/programs/bench.c b/programs/bench.c
index ec99c61ce..efec1892a 100644
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -551,6 +551,11 @@ static void BMK_loadFiles(void* buffer, size_t bufferSize,
             fileSizes[n] = 0;
             continue;
         }
+        if (fileSize == UTIL_FILESIZE_UNKNOWN) {
+            DISPLAYLEVEL(2, "Cannot evaluate size of %s, ignoring ... \n", fileNamesTable[n]);
+            fileSizes[n] = 0;
+            continue;
+        }
         f = fopen(fileNamesTable[n], "rb");
         if (f==NULL) EXM_THROW(10, "impossible to open file %s", fileNamesTable[n]);
         DISPLAYUPDATE(2, "Loading %s...       \r", fileNamesTable[n]);
@@ -581,11 +586,14 @@ static void BMK_benchFileTable(const char** fileNamesTable, unsigned nbFiles, co
 
     /* Load dictionary */
     if (dictFileName != NULL) {
-        U64 dictFileSize = UTIL_getFileSize(dictFileName);
-        if (dictFileSize > 64 MB) EXM_THROW(10, "dictionary file %s too large", dictFileName);
+        U64 const dictFileSize = UTIL_getFileSize(dictFileName);
+        if (dictFileSize > 64 MB)
+            EXM_THROW(10, "dictionary file %s too large", dictFileName);
         dictBufferSize = (size_t)dictFileSize;
         dictBuffer = malloc(dictBufferSize);
-        if (dictBuffer==NULL) EXM_THROW(11, "not enough memory for dictionary (%u bytes)", (U32)dictBufferSize);
+        if (dictBuffer==NULL)
+            EXM_THROW(11, "not enough memory for dictionary (%u bytes)",
+                            (U32)dictBufferSize);
         BMK_loadFiles(dictBuffer, dictBufferSize, fileSizes, &dictFileName, 1);
     }
 
diff --git a/programs/dibio.c b/programs/dibio.c
index 2cb2a4267..dea3ec44f 100644
--- a/programs/dibio.c
+++ b/programs/dibio.c
@@ -117,7 +117,7 @@ static unsigned DiB_loadFiles(void* buffer, size_t* bufferSizePtr,
     for (fileIndex=0; fileIndex<nbFiles; fileIndex++) {
         const char* const fileName = fileNamesTable[fileIndex];
         unsigned long long const fs64 = UTIL_getFileSize(fileName);
-        unsigned long long remainingToLoad = fs64;
+        unsigned long long remainingToLoad = (fs64 == UTIL_FILESIZE_UNKNOWN) ? 0 : fs64;
         U32 const nbChunks = targetChunkSize ? (U32)((fs64 + (targetChunkSize-1)) / targetChunkSize) : 1;
         U64 const chunkSize = targetChunkSize ? MIN(targetChunkSize, fs64) : fs64;
         size_t const maxChunkSize = (size_t)MIN(chunkSize, SAMPLESIZE_MAX);
@@ -245,8 +245,9 @@ static fileStats DiB_fileStats(const char** fileNamesTable, unsigned nbFiles, si
     memset(&fs, 0, sizeof(fs));
     for (n=0; n<nbFiles; n++) {
         U64 const fileSize = UTIL_getFileSize(fileNamesTable[n]);
-        U32 const nbSamples = (U32)(chunkSize ? (fileSize + (chunkSize-1)) / chunkSize : 1);
-        U64 const chunkToLoad = chunkSize ? MIN(chunkSize, fileSize) : fileSize;
+        U64 const srcSize = (fileSize == UTIL_FILESIZE_UNKNOWN) ? 0 : fileSize;
+        U32 const nbSamples = (U32)(chunkSize ? (srcSize + (chunkSize-1)) / chunkSize : 1);
+        U64 const chunkToLoad = chunkSize ? MIN(chunkSize, srcSize) : srcSize;
         size_t const cappedChunkSize = (size_t)MIN(chunkToLoad, SAMPLESIZE_MAX);
         fs.totalSizeToLoad += cappedChunkSize * nbSamples;
         fs.oneSampleTooLarge |= (chunkSize > 2*SAMPLESIZE_MAX);
diff --git a/programs/fileio.c b/programs/fileio.c
index 03e653893..1b18edefa 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -25,7 +25,7 @@
 *  Includes
 ***************************************/
 #include "platform.h"   /* Large Files support, SET_BINARY_MODE */
-#include "util.h"       /* UTIL_getFileSize */
+#include "util.h"       /* UTIL_getFileSize, UTIL_isRegularFile */
 #include <stdio.h>      /* fprintf, fopen, fread, _fileno, stdin, stdout */
 #include <stdlib.h>     /* malloc, free */
 #include <string.h>     /* strcmp, strlen */
@@ -564,7 +564,7 @@ static unsigned long long FIO_compressGzFrame(cRess_t* ress,
                 strm.avail_out = (uInt)ress->dstBufferSize;
             }
         }
-        if (!srcFileSize)
+        if (srcFileSize != UTIL_FILESIZE_UNKNOWN)
             DISPLAYUPDATE(2, "\rRead : %u MB ==> %.2f%%",
                             (U32)(inFileSize>>20),
                             (double)outFileSize/inFileSize*100)
@@ -651,7 +651,7 @@ static unsigned long long FIO_compressLzmaFrame(cRess_t* ress,
                 strm.next_out = (BYTE*)ress->dstBuffer;
                 strm.avail_out = ress->dstBufferSize;
         }   }
-        if (!srcFileSize)
+        if (srcFileSize != UTIL_FILESIZE_UNKNOWN)
             DISPLAYUPDATE(2, "\rRead : %u MB ==> %.2f%%",
                             (U32)(inFileSize>>20),
                             (double)outFileSize/inFileSize*100)
@@ -697,18 +697,17 @@ static unsigned long long FIO_compressLz4Frame(cRess_t* ress,
     prefs.frameInfo.blockSizeID = LZ4F_max4MB;
     prefs.frameInfo.contentChecksumFlag = (contentChecksum_t)g_checksumFlag;
 #if LZ4_VERSION_NUMBER >= 10600
-    prefs.frameInfo.contentSize = srcFileSize;
+    prefs.frameInfo.contentSize = (srcFileSize==UTIL_FILESIZE_UNKNOWN) ? 0 : srcFileSize;
 #endif
 
-    {
-        size_t blockSize = FIO_LZ4_GetBlockSize_FromBlockId(LZ4F_max4MB);
+    {   size_t blockSize = FIO_LZ4_GetBlockSize_FromBlockId(LZ4F_max4MB);
         size_t readSize;
         size_t headerSize = LZ4F_compressBegin(ctx, ress->dstBuffer, ress->dstBufferSize, &prefs);
         if (LZ4F_isError(headerSize))
             EXM_THROW(33, "File header generation failed : %s",
                             LZ4F_getErrorName(headerSize));
-        { size_t const sizeCheck = fwrite(ress->dstBuffer, 1, headerSize, ress->dstFile);
-          if (sizeCheck!=headerSize) EXM_THROW(34, "Write error : cannot write header"); }
+        if (fwrite(ress->dstBuffer, 1, headerSize, ress->dstFile) != headerSize)
+            EXM_THROW(34, "Write error : cannot write header");
         outFileSize += headerSize;
 
         /* Read first block */
@@ -725,7 +724,7 @@ static unsigned long long FIO_compressLz4Frame(cRess_t* ress,
                 EXM_THROW(35, "zstd: %s: lz4 compression failed : %s",
                             srcFileName, LZ4F_getErrorName(outSize));
             outFileSize += outSize;
-            if (!srcFileSize)
+            if (srcFileSize != UTIL_FILESIZE_UNKNOWN)
                 DISPLAYUPDATE(2, "\rRead : %u MB ==> %.2f%%",
                                 (U32)(inFileSize>>20),
                                 (double)outFileSize/inFileSize*100)
@@ -816,12 +815,12 @@ static int FIO_compressFilename_internal(cRess_t ress,
 
     /* init */
 #ifdef ZSTD_NEWAPI
-    if (fileSize!=0)  /* when src is stdin, fileSize==0, but is effectively unknown */
+    if (fileSize!=UTIL_FILESIZE_UNKNOWN)  /* when src is stdin, fileSize==0, but is effectively unknown */
         ZSTD_CCtx_setPledgedSrcSize(ress.cctx, fileSize);
 #elif defined(ZSTD_MULTITHREAD)
-    CHECK( ZSTDMT_resetCStream(ress.cctx, fileSize ? fileSize : ZSTD_CONTENTSIZE_UNKNOWN) );
+    CHECK( ZSTDMT_resetCStream(ress.cctx, (fileSize==UTIL_FILESIZE_UNKNOWN) ? ZSTD_CONTENTSIZE_UNKNOWN : fileSize) );
 #else
-    CHECK( ZSTD_resetCStream(ress.cctx, fileSize ? fileSize : ZSTD_CONTENTSIZE_UNKNOWN) );
+    CHECK( ZSTD_resetCStream(ress.cctx, (fileSize==UTIL_FILESIZE_UNKNOWN) ? ZSTD_CONTENTSIZE_UNKNOWN : fileSize) );
 #endif
 
     /* Main compression loop */
@@ -851,13 +850,13 @@ static int FIO_compressFilename_internal(cRess_t ress,
                 compressedfilesize += outBuff.pos;
         }   }
         if (g_nbThreads > 1) {
-            if (!fileSize)
+            if (fileSize != UTIL_FILESIZE_UNKNOWN)
                 DISPLAYUPDATE(2, "\rRead : %u MB", (U32)(readsize>>20))
             else
                 DISPLAYUPDATE(2, "\rRead : %u / %u MB",
                                     (U32)(readsize>>20), (U32)(fileSize>>20));
         } else {
-            if (!fileSize)
+            if (fileSize != UTIL_FILESIZE_UNKNOWN)
                 DISPLAYUPDATE(2, "\rRead : %u MB ==> %.2f%%",
                                 (U32)(readsize>>20),
                                 (double)compressedfilesize/readsize*100)
@@ -985,7 +984,8 @@ int FIO_compressFilename(const char* dstFileName, const char* srcFileName,
                          const char* dictFileName, int compressionLevel, ZSTD_compressionParameters* comprParams)
 {
     clock_t const start = clock();
-    U64 const srcSize = UTIL_getFileSize(srcFileName);
+    U64 const fileSize = UTIL_getFileSize(srcFileName);
+    U64 const srcSize = (fileSize == UTIL_FILESIZE_UNKNOWN) ? ZSTD_CONTENTSIZE_UNKNOWN : fileSize;
 
     cRess_t const ress = FIO_createCResources(dictFileName, compressionLevel, srcSize, comprParams);
     int const result = FIO_compressFilename_dstFile(ress, dstFileName, srcFileName, compressionLevel);
@@ -1007,7 +1007,9 @@ int FIO_compressMultipleFilenames(const char** inFileNamesTable, unsigned nbFile
     size_t dfnSize = FNSPACE;
     char*  dstFileName = (char*)malloc(FNSPACE);
     size_t const suffixSize = suffix ? strlen(suffix) : 0;
-    U64 const srcSize = (nbFiles != 1) ? ZSTD_CONTENTSIZE_UNKNOWN : UTIL_getFileSize(inFileNamesTable[0]) ;
+    U64 const firstFileSize = UTIL_getFileSize(inFileNamesTable[0]);
+    U64 const firstSrcSize = (firstFileSize == UTIL_FILESIZE_UNKNOWN) ? ZSTD_CONTENTSIZE_UNKNOWN : firstFileSize;
+    U64 const srcSize = (nbFiles != 1) ? ZSTD_CONTENTSIZE_UNKNOWN : firstSrcSize ;
     cRess_t ress = FIO_createCResources(dictFileName, compressionLevel, srcSize, comprParams);
 
     /* init */
@@ -1799,7 +1801,7 @@ typedef struct {
  *           2 for file not compressed with zstd
  *           3 for cases in which file could not be opened.
  */
-static int getFileInfo(fileInfo_t* info, const char* inFileName){
+static int getFileInfo_fileConfirmed(fileInfo_t* info, const char* inFileName){
     int detectError = 0;
     FILE* const srcFile = FIO_openSrcFile(inFileName);
     if (srcFile == NULL) {
@@ -1815,7 +1817,8 @@ static int getFileInfo(fileInfo_t* info, const char* inFileName){
         if (numBytesRead < ZSTD_frameHeaderSize_min) {
             if ( feof(srcFile)
               && (numBytesRead == 0)
-              && (info->compressedSize > 0) ) {
+              && (info->compressedSize > 0)
+              && (info->compressedSize != UTIL_FILESIZE_UNKNOWN) ) {
                 break;
             }
             else if (feof(srcFile)) {
@@ -1928,6 +1931,17 @@ static int getFileInfo(fileInfo_t* info, const char* inFileName){
     return detectError;
 }
 
+static int getFileInfo(fileInfo_t* info, const char* srcFileName)
+{
+    int const isAFile = UTIL_isRegularFile(srcFileName);
+    if (!isAFile) {
+        DISPLAY("Error : %s is not a file", srcFileName);
+        return 3;
+    }
+    return getFileInfo_fileConfirmed(info, srcFileName);
+}
+
+
 static void displayInfo(const char* inFileName, const fileInfo_t* info, int displayLevel){
     unsigned const unit = info->compressedSize < (1 MB) ? (1 KB) : (1 MB);
     const char* const unitStr = info->compressedSize < (1 MB) ? "KB" : "MB";
diff --git a/programs/util.h b/programs/util.h
index c8be5f5fb..c5e4365d0 100644
--- a/programs/util.h
+++ b/programs/util.h
@@ -313,33 +313,40 @@ UTIL_STATIC U32 UTIL_isLink(const char* infilename)
 }
 
 
+#define UTIL_FILESIZE_UNKNOWN  ((U64)(-1))
 UTIL_STATIC U64 UTIL_getFileSize(const char* infilename)
 {
-    int r;
+    if (!UTIL_isRegularFile(infilename)) return UTIL_FILESIZE_UNKNOWN;
+    {   int r;
 #if defined(_MSC_VER)
-    struct __stat64 statbuf;
-    r = _stat64(infilename, &statbuf);
-    if (r || !(statbuf.st_mode & S_IFREG)) return 0;   /* No good... */
+        struct __stat64 statbuf;
+        r = _stat64(infilename, &statbuf);
+        if (r || !(statbuf.st_mode & S_IFREG)) return UTIL_FILESIZE_UNKNOWN;
 #elif defined(__MINGW32__) && defined (__MSVCRT__)
-    struct _stati64 statbuf;
-    r = _stati64(infilename, &statbuf);
-    if (r || !(statbuf.st_mode & S_IFREG)) return 0;   /* No good... */
+        struct _stati64 statbuf;
+        r = _stati64(infilename, &statbuf);
+        if (r || !(statbuf.st_mode & S_IFREG)) return UTIL_FILESIZE_UNKNOWN;
 #else
-    struct stat statbuf;
-    r = stat(infilename, &statbuf);
-    if (r || !S_ISREG(statbuf.st_mode)) return 0;   /* No good... */
+        struct stat statbuf;
+        r = stat(infilename, &statbuf);
+        if (r || !S_ISREG(statbuf.st_mode)) return UTIL_FILESIZE_UNKNOWN;
 #endif
-    return (U64)statbuf.st_size;
+        return (U64)statbuf.st_size;
+    }
 }
 
 
 UTIL_STATIC U64 UTIL_getTotalFileSize(const char** fileNamesTable, unsigned nbFiles)
 {
     U64 total = 0;
+    int error = 0;
     unsigned n;
-    for (n=0; n<nbFiles; n++)
-        total += UTIL_getFileSize(fileNamesTable[n]);
-    return total;
+    for (n=0; n<nbFiles; n++) {
+        U64 const size = UTIL_getFileSize(fileNamesTable[n]);
+        error |= (size == UTIL_FILESIZE_UNKNOWN);
+        total += size;
+    }
+    return error ? UTIL_FILESIZE_UNKNOWN : total;
 }
 
 
diff --git a/tests/fullbench.c b/tests/fullbench.c
index 3f497b034..2ec3ce555 100644
--- a/tests/fullbench.c
+++ b/tests/fullbench.c
@@ -484,8 +484,8 @@ static int benchFiles(const char** fileNamesTable, const int nbFiles, U32 benchN
     /* Loop for each file */
     int fileIdx;
     for (fileIdx=0; fileIdx<nbFiles; fileIdx++) {
-        const char* inFileName = fileNamesTable[fileIdx];
-        FILE* inFile = fopen( inFileName, "rb" );
+        const char* const inFileName = fileNamesTable[fileIdx];
+        FILE* const inFile = fopen( inFileName, "rb" );
         U64   inFileSize;
         size_t benchedSize;
         void* origBuff;
@@ -495,6 +495,11 @@ static int benchFiles(const char** fileNamesTable, const int nbFiles, U32 benchN
 
         /* Memory allocation & restrictions */
         inFileSize = UTIL_getFileSize(inFileName);
+        if (inFileSize == UTIL_FILESIZE_UNKNOWN) {
+            DISPLAY( "Cannot measure size of %s\n", inFileName);
+            fclose(inFile);
+            return 11;
+        }
         benchedSize = BMK_findMaxMem(inFileSize*3) / 3;
         if ((U64)benchedSize > inFileSize) benchedSize = (size_t)inFileSize;
         if (benchedSize < inFileSize)
diff --git a/tests/paramgrill.c b/tests/paramgrill.c
index 317ec461c..a387a44c6 100644
--- a/tests/paramgrill.c
+++ b/tests/paramgrill.c
@@ -687,6 +687,11 @@ int benchFiles(const char** fileNamesTable, int nbFiles)
             DISPLAY( "Pb opening %s\n", inFileName);
             return 11;
         }
+        if (inFileSize == UTIL_FILESIZE_UNKNOWN) {
+            DISPLAY("Pb evaluatin size of %s \n", inFileName);
+            fclose(inFile);
+            return 11;
+        }
 
         /* Memory allocation */
         benchedSize = BMK_findMaxMem(inFileSize*3) / 3;
@@ -740,6 +745,11 @@ int optimizeForSize(const char* inFileName, U32 targetSpeed)
 
     /* Init */
     if (inFile==NULL) { DISPLAY( "Pb opening %s\n", inFileName); return 11; }
+    if (inFileSize == UTIL_FILESIZE_UNKNOWN) {
+        DISPLAY("Pb evaluatin size of %s \n", inFileName);
+        fclose(inFile);
+        return 11;
+    }
 
     /* Memory allocation & restrictions */
     if ((U64)benchedSize > inFileSize) benchedSize = (size_t)inFileSize;
diff --git a/zlibWrapper/examples/zwrapbench.c b/zlibWrapper/examples/zwrapbench.c
index 25a23f885..9226932b5 100644
--- a/zlibWrapper/examples/zwrapbench.c
+++ b/zlibWrapper/examples/zwrapbench.c
@@ -684,6 +684,11 @@ static void BMK_loadFiles(void* buffer, size_t bufferSize,
             fileSizes[n] = 0;
             continue;
         }
+        if (fileSize == UTIL_FILESIZE_UNKNOWN) {
+            DISPLAYLEVEL(2, "Cannot determine size of %s ...    \n", fileNamesTable[n]);
+            fileSizes[n] = 0;
+            continue;
+        }
         f = fopen(fileNamesTable[n], "rb");
         if (f==NULL) EXM_THROW(10, "impossible to open file %s", fileNamesTable[n]);
         DISPLAYUPDATE(2, "Loading %s...       \r", fileNamesTable[n]);
@@ -714,11 +719,13 @@ static void BMK_benchFileTable(const char** fileNamesTable, unsigned nbFiles,
 
     /* Load dictionary */
     if (dictFileName != NULL) {
-        U64 dictFileSize = UTIL_getFileSize(dictFileName);
-        if (dictFileSize > 64 MB) EXM_THROW(10, "dictionary file %s too large", dictFileName);
+        U64 const dictFileSize = UTIL_getFileSize(dictFileName);
+        if (dictFileSize > 64 MB)
+            EXM_THROW(10, "dictionary file %s too large", dictFileName);
         dictBufferSize = (size_t)dictFileSize;
         dictBuffer = malloc(dictBufferSize);
-        if (dictBuffer==NULL) EXM_THROW(11, "not enough memory for dictionary (%u bytes)", (U32)dictBufferSize);
+        if (dictBuffer==NULL)
+            EXM_THROW(11, "not enough memory for dictionary (%u bytes)", (U32)dictBufferSize);
         BMK_loadFiles(dictBuffer, dictBufferSize, fileSizes, &dictFileName, 1);
     }
 

From 5891f1d952b26f75ab80c1869e7a6af249e104eb Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 17 Oct 2017 16:23:20 -0700
Subject: [PATCH 021/145] added a check to ensure 0-size is present in frame
 header

---
 tests/playTests.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/playTests.sh b/tests/playTests.sh
index f008d8998..299c2d883 100755
--- a/tests/playTests.sh
+++ b/tests/playTests.sh
@@ -621,7 +621,7 @@ $ECHO "\n===>  zstd --list/-l test with null files "
 $ZSTD tmp5
 $ZSTD -l tmp5.zst
 ! $ZSTD -l tmp5*
-$ZSTD -lv tmp5.zst
+$ZSTD -lv tmp5.zst | grep "Decompressed Size: 0.00 KB (0 B)"  # check that 0 size is present in header
 ! $ZSTD -lv tmp5*
 
 $ECHO "\n===>  zstd --list/-l test with no content size field "

From ca1a9ebac54b01766373e138833dc39674bad7c3 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 18 Oct 2017 11:18:27 -0700
Subject: [PATCH 022/145] fixed zlib wrapper

it was invoking ZSTD_initCStream_advanced() with pledgedSrcSize==0 and contentSizeFlag=1
which means "empty"
while the intention was to mean "unknown".

The contentSizeFlag==1 is new, it is a consequence of setting this value to 1 by default.

The solution selected here is to pass ZSTD_CONTENTSIZE_UNKNOWN to mean "unknown".
So contentSizeFlag remains set (it wasn't in previous versions).
---
 doc/zstd_manual.html           | 4 ++--
 lib/zstd.h                     | 2 +-
 zlibWrapper/zstd_zlibwrapper.c | 6 +++---
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/doc/zstd_manual.html b/doc/zstd_manual.html
index 7ef86a23d..9697ebd57 100644
--- a/doc/zstd_manual.html
+++ b/doc/zstd_manual.html
@@ -518,7 +518,7 @@ size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMet
 
 <pre><b>ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);
 </b><p>   same as ZSTD_getCParams(), but @return a full `ZSTD_parameters` object instead of sub-component `ZSTD_compressionParameters`.
-   All fields of `ZSTD_frameParameters` are set to default (0) 
+   All fields of `ZSTD_frameParameters` are set to default : contentSize=1, checksum=0, noDictID=0 
 </p></pre><BR>
 
 <pre><b>size_t ZSTD_checkCParams(ZSTD_compressionParameters params);
@@ -634,7 +634,7 @@ ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize);
 size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize);   </b>/**< pledgedSrcSize must be correct. If it is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs, a size of 0 is interepreted as "unknown". But it may change in some future version to mean "empty". */<b>
 size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel); </b>/**< creates of an internal CDict (incompatible with static CCtx), except if dict == NULL or dictSize < 8, in which case no dict is used. Note: dict is loaded with ZSTD_dm_auto (treated as a full zstd dictionary if it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.*/<b>
 size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, const void* dict, size_t dictSize,
-                                             ZSTD_parameters params, unsigned long long pledgedSrcSize);  </b>/**< pledgedSrcSize : If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */<b>
+                                             ZSTD_parameters params, unsigned long long pledgedSrcSize);  </b>/**< pledgedSrcSize : if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */<b>
 size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);  </b>/**< note : cdict will just be referenced, and must outlive compression session */<b>
 size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize);  </b>/**< same as ZSTD_initCStream_usingCDict(), with control over frame parameters */<b>
 </pre></b><BR>
diff --git a/lib/zstd.h b/lib/zstd.h
index 4681d3f2a..6b7bfd03c 100644
--- a/lib/zstd.h
+++ b/lib/zstd.h
@@ -613,7 +613,7 @@ ZSTDLIB_API ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, uns
 
 /*! ZSTD_getParams() :
 *   same as ZSTD_getCParams(), but @return a full `ZSTD_parameters` object instead of sub-component `ZSTD_compressionParameters`.
-*   All fields of `ZSTD_frameParameters` are set to default (0) */
+*   All fields of `ZSTD_frameParameters` are set to default : contentSize=1, checksum=0, noDictID=0 */
 ZSTDLIB_API ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);
 
 /*! ZSTD_checkCParams() :
diff --git a/zlibWrapper/zstd_zlibwrapper.c b/zlibWrapper/zstd_zlibwrapper.c
index c5fbdf98e..b3e5f3672 100644
--- a/zlibWrapper/zstd_zlibwrapper.c
+++ b/zlibWrapper/zstd_zlibwrapper.c
@@ -270,7 +270,7 @@ ZEXTERN int ZEXPORT z_deflateSetDictionary OF((z_streamp strm,
             zwc->zbc = ZSTD_createCStream_advanced(zwc->customMem);
             if (zwc->zbc == NULL) return ZWRAPC_finishWithError(zwc, strm, 0);
         }
-        { int res = ZWRAP_initializeCStream(zwc, dictionary, dictLength, 0);
+        { int res = ZWRAP_initializeCStream(zwc, dictionary, dictLength, ZSTD_CONTENTSIZE_UNKNOWN);
           if (res != Z_OK) return ZWRAPC_finishWithError(zwc, strm, res); }
         zwc->comprState = ZWRAP_useReset;
     }
@@ -295,7 +295,7 @@ ZEXTERN int ZEXPORT z_deflate OF((z_streamp strm, int flush))
     if (zwc->zbc == NULL) {
         zwc->zbc = ZSTD_createCStream_advanced(zwc->customMem);
         if (zwc->zbc == NULL) return ZWRAPC_finishWithError(zwc, strm, 0);
-        { int const initErr = ZWRAP_initializeCStream(zwc, NULL, 0, (flush == Z_FINISH) ? strm->avail_in : 0);
+        { int const initErr = ZWRAP_initializeCStream(zwc, NULL, 0, (flush == Z_FINISH) ? strm->avail_in : ZSTD_CONTENTSIZE_UNKNOWN);
           if (initErr != Z_OK) return ZWRAPC_finishWithError(zwc, strm, initErr); }
         if (flush != Z_FINISH) zwc->comprState = ZWRAP_useReset;
     } else {
@@ -308,7 +308,7 @@ ZEXTERN int ZEXPORT z_deflate OF((z_streamp strm, int flush))
                     return ZWRAPC_finishWithError(zwc, strm, 0);
                 }
             } else {
-                int const res = ZWRAP_initializeCStream(zwc, NULL, 0, (flush == Z_FINISH) ? strm->avail_in : 0);
+                int const res = ZWRAP_initializeCStream(zwc, NULL, 0, (flush == Z_FINISH) ? strm->avail_in : ZSTD_CONTENTSIZE_UNKNOWN);
                 if (res != Z_OK) return ZWRAPC_finishWithError(zwc, strm, res);
                 if (flush != Z_FINISH) zwc->comprState = ZWRAP_useReset;
             }

From 300e1df0a38b8200155fe11a851b3ecc9bc6ddfe Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 18 Oct 2017 11:41:52 -0700
Subject: [PATCH 023/145] fixed wrong test to display compression status

---
 programs/fileio.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/programs/fileio.c b/programs/fileio.c
index 1b18edefa..4ddb8f8e0 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -564,7 +564,7 @@ static unsigned long long FIO_compressGzFrame(cRess_t* ress,
                 strm.avail_out = (uInt)ress->dstBufferSize;
             }
         }
-        if (srcFileSize != UTIL_FILESIZE_UNKNOWN)
+        if (srcFileSize == UTIL_FILESIZE_UNKNOWN)
             DISPLAYUPDATE(2, "\rRead : %u MB ==> %.2f%%",
                             (U32)(inFileSize>>20),
                             (double)outFileSize/inFileSize*100)
@@ -651,7 +651,7 @@ static unsigned long long FIO_compressLzmaFrame(cRess_t* ress,
                 strm.next_out = (BYTE*)ress->dstBuffer;
                 strm.avail_out = ress->dstBufferSize;
         }   }
-        if (srcFileSize != UTIL_FILESIZE_UNKNOWN)
+        if (srcFileSize == UTIL_FILESIZE_UNKNOWN)
             DISPLAYUPDATE(2, "\rRead : %u MB ==> %.2f%%",
                             (U32)(inFileSize>>20),
                             (double)outFileSize/inFileSize*100)
@@ -724,7 +724,7 @@ static unsigned long long FIO_compressLz4Frame(cRess_t* ress,
                 EXM_THROW(35, "zstd: %s: lz4 compression failed : %s",
                             srcFileName, LZ4F_getErrorName(outSize));
             outFileSize += outSize;
-            if (srcFileSize != UTIL_FILESIZE_UNKNOWN)
+            if (srcFileSize == UTIL_FILESIZE_UNKNOWN)
                 DISPLAYUPDATE(2, "\rRead : %u MB ==> %.2f%%",
                                 (U32)(inFileSize>>20),
                                 (double)outFileSize/inFileSize*100)
@@ -850,18 +850,18 @@ static int FIO_compressFilename_internal(cRess_t ress,
                 compressedfilesize += outBuff.pos;
         }   }
         if (g_nbThreads > 1) {
-            if (fileSize != UTIL_FILESIZE_UNKNOWN)
+            if (fileSize == UTIL_FILESIZE_UNKNOWN)
                 DISPLAYUPDATE(2, "\rRead : %u MB", (U32)(readsize>>20))
             else
                 DISPLAYUPDATE(2, "\rRead : %u / %u MB",
                                     (U32)(readsize>>20), (U32)(fileSize>>20));
         } else {
-            if (fileSize != UTIL_FILESIZE_UNKNOWN)
+            if (fileSize == UTIL_FILESIZE_UNKNOWN)
                 DISPLAYUPDATE(2, "\rRead : %u MB ==> %.2f%%",
                                 (U32)(readsize>>20),
                                 (double)compressedfilesize/readsize*100)
             else
-            DISPLAYUPDATE(2, "\rRead : %u / %u MB ==> %.2f%%",
+                DISPLAYUPDATE(2, "\rRead : %u / %u MB ==> %.2f%%",
                                 (U32)(readsize>>20), (U32)(fileSize>>20),
                                 (double)compressedfilesize/readsize*100);
         }

From d3b9547aa4cab7421946ef4010a998de34703da8 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 18 Oct 2017 17:01:53 -0700
Subject: [PATCH 024/145] IO and bench : ZSTD_NEWAPI is the only remaining code
 path

removed the other 2 code paths (single thread, and ZSTDMT ones)
keeping only the new advanced API, for easier code coverage.

It shall also fix identified issue with Visual Studio
which doesn't have ZSTD_NEWAPI defined.
---
 programs/Makefile |   3 +-
 programs/bench.c  |  39 --------------
 programs/fileio.c | 135 +++++++++++-----------------------------------
 3 files changed, 33 insertions(+), 144 deletions(-)

diff --git a/programs/Makefile b/programs/Makefile
index 1b21281b4..e1c5f50b6 100644
--- a/programs/Makefile
+++ b/programs/Makefile
@@ -37,8 +37,7 @@ endif
 
 CPPFLAGS+= -I$(ZSTDDIR) -I$(ZSTDDIR)/common -I$(ZSTDDIR)/compress \
            -I$(ZSTDDIR)/dictBuilder \
-           -DXXH_NAMESPACE=ZSTD_ \
-           -DZSTD_NEWAPI
+           -DXXH_NAMESPACE=ZSTD_
 CFLAGS  ?= -O3
 DEBUGFLAGS+=-Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \
             -Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement \
diff --git a/programs/bench.c b/programs/bench.c
index efec1892a..5b67d5c76 100644
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -287,7 +287,6 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
                     U64 const clockLoop = g_nbSeconds ? TIMELOOP_MICROSEC : 1;
                     U32 nbLoops = 0;
                     ZSTD_CDict* cdict = NULL;
-#ifdef ZSTD_NEWAPI
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_nbThreads, g_nbThreads);
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_compressionLevel, cLevel);
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_enableLongDistanceMatching, g_ldmFlag);
@@ -306,25 +305,10 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_targetLength, comprParams->targetLength);
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_compressionStrategy, comprParams->strategy);
                     ZSTD_CCtx_loadDictionary(ctx, dictBuffer, dictBufferSize);
-#else
-                    size_t const avgSize = MIN(blockSize, (srcSize / nbFiles));
-                    ZSTD_parameters zparams = ZSTD_getParams(cLevel, avgSize, dictBufferSize);
-                    ZSTD_customMem const cmem = { NULL, NULL, NULL };
-                    if (comprParams->windowLog) zparams.cParams.windowLog = comprParams->windowLog;
-                    if (comprParams->chainLog) zparams.cParams.chainLog = comprParams->chainLog;
-                    if (comprParams->hashLog) zparams.cParams.hashLog = comprParams->hashLog;
-                    if (comprParams->searchLog) zparams.cParams.searchLog = comprParams->searchLog;
-                    if (comprParams->searchLength) zparams.cParams.searchLength = comprParams->searchLength;
-                    if (comprParams->targetLength) zparams.cParams.targetLength = comprParams->targetLength;
-                    if (comprParams->strategy) zparams.cParams.strategy = comprParams->strategy;
-                    cdict = ZSTD_createCDict_advanced(dictBuffer, dictBufferSize, ZSTD_dlm_byRef, ZSTD_dm_auto, zparams.cParams, cmem);
-                    if (cdict==NULL) EXM_THROW(1, "ZSTD_createCDict_advanced() allocation failure");
-#endif
                     do {
                         U32 blockNb;
                         for (blockNb=0; blockNb<nbBlocks; blockNb++) {
                             size_t rSize;
-#ifdef ZSTD_NEWAPI
                             ZSTD_outBuffer out = { blockTable[blockNb].cPtr,  blockTable[blockNb].cRoom, 0 };
                             ZSTD_inBuffer in = { blockTable[blockNb].srcPtr,  blockTable[blockNb].srcSize, 0 };
                             size_t cError = 1;
@@ -336,29 +320,6 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
                                                 ZSTD_getErrorName(cError));
                             }
                             rSize = out.pos;
-#else  /* ! ZSTD_NEWAPI */
-                            if (dictBufferSize) {
-                                rSize = ZSTD_compress_usingCDict(ctx,
-                                                blockTable[blockNb].cPtr,  blockTable[blockNb].cRoom,
-                                                blockTable[blockNb].srcPtr,blockTable[blockNb].srcSize,
-                                                cdict);
-                            } else {
-#  ifdef ZSTD_MULTITHREAD       /* note : limitation : MT single-pass does not support compression with dictionary */
-                                rSize = ZSTDMT_compressCCtx(mtctx,
-                                                blockTable[blockNb].cPtr,  blockTable[blockNb].cRoom,
-                                                blockTable[blockNb].srcPtr,blockTable[blockNb].srcSize,
-                                                cLevel);
-#  else
-                                rSize = ZSTD_compress_advanced (ctx,
-                                                blockTable[blockNb].cPtr,  blockTable[blockNb].cRoom,
-                                                blockTable[blockNb].srcPtr,blockTable[blockNb].srcSize,
-                                                NULL, 0, zparams);
-#  endif
-                            }
-                            if (ZSTD_isError(rSize))
-                                EXM_THROW(1, "ZSTD_compress_usingCDict() failed : %s",
-                                            ZSTD_getErrorName(rSize));
-#endif  /* ZSTD_NEWAPI */
                             blockTable[blockNb].cSize = rSize;
                         }
                         nbLoops++;
diff --git a/programs/fileio.c b/programs/fileio.c
index 4ddb8f8e0..c8eab0679 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -393,11 +393,7 @@ typedef struct {
     size_t srcBufferSize;
     void*  dstBuffer;
     size_t dstBufferSize;
-#if !defined(ZSTD_NEWAPI) && defined(ZSTD_MULTITHREAD)
-    ZSTDMT_CCtx* cctx;
-#else
     ZSTD_CStream* cctx;
-#endif
 } cRess_t;
 
 static cRess_t FIO_createCResources(const char* dictFileName, int cLevel,
@@ -406,24 +402,9 @@ static cRess_t FIO_createCResources(const char* dictFileName, int cLevel,
     cRess_t ress;
     memset(&ress, 0, sizeof(ress));
 
-#ifdef ZSTD_NEWAPI
     ress.cctx = ZSTD_createCCtx();
     if (ress.cctx == NULL)
         EXM_THROW(30, "allocation error : can't create ZSTD_CCtx");
-#elif defined(ZSTD_MULTITHREAD)
-    ress.cctx = ZSTDMT_createCCtx(g_nbThreads);
-    if (ress.cctx == NULL)
-        EXM_THROW(30, "allocation error : can't create ZSTDMT_CCtx");
-    if ((cLevel==ZSTD_maxCLevel()) && (g_overlapLog==FIO_OVERLAP_LOG_NOTSET))
-        /* use complete window for overlap */
-        ZSTDMT_setMTCtxParameter(ress.cctx, ZSTDMT_p_overlapSectionLog, 9);
-    if (g_overlapLog != FIO_OVERLAP_LOG_NOTSET)
-        ZSTDMT_setMTCtxParameter(ress.cctx, ZSTDMT_p_overlapSectionLog, g_overlapLog);
-#else
-    ress.cctx = ZSTD_createCStream();
-    if (ress.cctx == NULL)
-        EXM_THROW(30, "allocation error : can't create ZSTD_CStream");
-#endif
     ress.srcBufferSize = ZSTD_CStreamInSize();
     ress.srcBuffer = malloc(ress.srcBufferSize);
     ress.dstBufferSize = ZSTD_CStreamOutSize();
@@ -437,68 +418,38 @@ static cRess_t FIO_createCResources(const char* dictFileName, int cLevel,
         if (dictFileName && (dictBuffer==NULL))
             EXM_THROW(32, "allocation error : can't create dictBuffer");
 
-#ifdef ZSTD_NEWAPI
-        {   /* frame parameters */
-            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_contentSizeFlag, 1) );
-            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_dictIDFlag, g_dictIDFlag) );
-            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_checksumFlag, g_checksumFlag) );
-            /* compression level */
-            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_compressionLevel, cLevel) );
-            /* long distance matching */
-            CHECK( ZSTD_CCtx_setParameter(
-                          ress.cctx, ZSTD_p_enableLongDistanceMatching, g_ldmFlag) );
-            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_ldmHashLog, g_ldmHashLog) );
-            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_ldmMinMatch, g_ldmMinMatch) );
-            if (g_ldmBucketSizeLog != FIO_LDM_PARAM_NOTSET) {
-                CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_ldmBucketSizeLog, g_ldmBucketSizeLog) );
-            }
-            if (g_ldmHashEveryLog != FIO_LDM_PARAM_NOTSET) {
-                CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_ldmHashEveryLog, g_ldmHashEveryLog) );
-            }
-            /* compression parameters */
-            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_windowLog, comprParams->windowLog) );
-            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_chainLog, comprParams->chainLog) );
-            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_hashLog, comprParams->hashLog) );
-            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_searchLog, comprParams->searchLog) );
-            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_minMatch, comprParams->searchLength) );
-            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_targetLength, comprParams->targetLength) );
-            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_compressionStrategy, (U32)comprParams->strategy) );
-            /* multi-threading */
-            DISPLAYLEVEL(5,"set nb threads = %u \n", g_nbThreads);
-            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_nbThreads, g_nbThreads) );
-            /* dictionary */
-            CHECK( ZSTD_CCtx_setPledgedSrcSize(ress.cctx, srcSize) );  /* just to load dictionary with good compression parameters */
-            CHECK( ZSTD_CCtx_loadDictionary(ress.cctx, dictBuffer, dictBuffSize) );
-            CHECK( ZSTD_CCtx_setPledgedSrcSize(ress.cctx, ZSTD_CONTENTSIZE_UNKNOWN) );  /* reset */
+        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_contentSizeFlag, 1) );  /* always enable content size, when available (note: supposed to be default anyway) */
+        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_dictIDFlag, g_dictIDFlag) );
+        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_checksumFlag, g_checksumFlag) );
+        /* compression level */
+        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_compressionLevel, cLevel) );
+        /* long distance matching */
+        CHECK( ZSTD_CCtx_setParameter(
+                      ress.cctx, ZSTD_p_enableLongDistanceMatching, g_ldmFlag) );
+        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_ldmHashLog, g_ldmHashLog) );
+        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_ldmMinMatch, g_ldmMinMatch) );
+        if (g_ldmBucketSizeLog != FIO_LDM_PARAM_NOTSET) {
+            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_ldmBucketSizeLog, g_ldmBucketSizeLog) );
         }
-#elif defined(ZSTD_MULTITHREAD)
-        {   ZSTD_parameters params = ZSTD_getParams(cLevel, srcSize, dictBuffSize);
-            params.fParams.checksumFlag = g_checksumFlag;
-            params.fParams.noDictIDFlag = !g_dictIDFlag;
-            if (comprParams->windowLog) params.cParams.windowLog = comprParams->windowLog;
-            if (comprParams->chainLog) params.cParams.chainLog = comprParams->chainLog;
-            if (comprParams->hashLog) params.cParams.hashLog = comprParams->hashLog;
-            if (comprParams->searchLog) params.cParams.searchLog = comprParams->searchLog;
-            if (comprParams->searchLength) params.cParams.searchLength = comprParams->searchLength;
-            if (comprParams->targetLength) params.cParams.targetLength = comprParams->targetLength;
-            if (comprParams->strategy) params.cParams.strategy = (ZSTD_strategy) comprParams->strategy;
-            CHECK( ZSTDMT_initCStream_advanced(ress.cctx, dictBuffer, dictBuffSize, params, srcSize) );
-            ZSTDMT_setMTCtxParameter(ress.cctx, ZSTDMT_p_sectionSize, g_blockSize);
+        if (g_ldmHashEveryLog != FIO_LDM_PARAM_NOTSET) {
+            CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_ldmHashEveryLog, g_ldmHashEveryLog) );
         }
-#else
-        {   ZSTD_parameters params = ZSTD_getParams(cLevel, srcSize, dictBuffSize);
-            params.fParams.checksumFlag = g_checksumFlag;
-            params.fParams.noDictIDFlag = !g_dictIDFlag;
-            if (comprParams->windowLog) params.cParams.windowLog = comprParams->windowLog;
-            if (comprParams->chainLog) params.cParams.chainLog = comprParams->chainLog;
-            if (comprParams->hashLog) params.cParams.hashLog = comprParams->hashLog;
-            if (comprParams->searchLog) params.cParams.searchLog = comprParams->searchLog;
-            if (comprParams->searchLength) params.cParams.searchLength = comprParams->searchLength;
-            if (comprParams->targetLength) params.cParams.targetLength = comprParams->targetLength;
-            if (comprParams->strategy) params.cParams.strategy = (ZSTD_strategy) comprParams->strategy;
-            CHECK( ZSTD_initCStream_advanced(ress.cctx, dictBuffer, dictBuffSize, params, srcSize) );
-        }
-#endif
+        /* compression parameters */
+        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_windowLog, comprParams->windowLog) );
+        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_chainLog, comprParams->chainLog) );
+        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_hashLog, comprParams->hashLog) );
+        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_searchLog, comprParams->searchLog) );
+        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_minMatch, comprParams->searchLength) );
+        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_targetLength, comprParams->targetLength) );
+        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_compressionStrategy, (U32)comprParams->strategy) );
+        /* multi-threading */
+        DISPLAYLEVEL(5,"set nb threads = %u \n", g_nbThreads);
+        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_nbThreads, g_nbThreads) );
+        /* dictionary */
+        CHECK( ZSTD_CCtx_setPledgedSrcSize(ress.cctx, srcSize) );  /* just to load dictionary with good compression parameters */
+        CHECK( ZSTD_CCtx_loadDictionary(ress.cctx, dictBuffer, dictBuffSize) );
+        CHECK( ZSTD_CCtx_setPledgedSrcSize(ress.cctx, ZSTD_CONTENTSIZE_UNKNOWN) );  /* reset */
+
         free(dictBuffer);
     }
 
@@ -509,11 +460,7 @@ static void FIO_freeCResources(cRess_t ress)
 {
     free(ress.srcBuffer);
     free(ress.dstBuffer);
-#if !defined(ZSTD_NEWAPI) && defined(ZSTD_MULTITHREAD)
-    ZSTDMT_freeCCtx(ress.cctx);
-#else
     ZSTD_freeCStream(ress.cctx);   /* never fails */
-#endif
 }
 
 
@@ -814,14 +761,8 @@ static int FIO_compressFilename_internal(cRess_t ress,
     }
 
     /* init */
-#ifdef ZSTD_NEWAPI
-    if (fileSize!=UTIL_FILESIZE_UNKNOWN)  /* when src is stdin, fileSize==0, but is effectively unknown */
+    if (fileSize != UTIL_FILESIZE_UNKNOWN)
         ZSTD_CCtx_setPledgedSrcSize(ress.cctx, fileSize);
-#elif defined(ZSTD_MULTITHREAD)
-    CHECK( ZSTDMT_resetCStream(ress.cctx, (fileSize==UTIL_FILESIZE_UNKNOWN) ? ZSTD_CONTENTSIZE_UNKNOWN : fileSize) );
-#else
-    CHECK( ZSTD_resetCStream(ress.cctx, (fileSize==UTIL_FILESIZE_UNKNOWN) ? ZSTD_CONTENTSIZE_UNKNOWN : fileSize) );
-#endif
 
     /* Main compression loop */
     while (1) {
@@ -833,14 +774,8 @@ static int FIO_compressFilename_internal(cRess_t ress,
 
         while (inBuff.pos != inBuff.size) {
             ZSTD_outBuffer outBuff = { ress.dstBuffer, ress.dstBufferSize, 0 };
-#ifdef ZSTD_NEWAPI
             CHECK( ZSTD_compress_generic(ress.cctx,
                         &outBuff, &inBuff, ZSTD_e_continue) );
-#elif defined(ZSTD_MULTITHREAD)
-            CHECK( ZSTDMT_compressStream(ress.cctx, &outBuff, &inBuff) );
-#else
-            CHECK( ZSTD_compressStream(ress.cctx, &outBuff, &inBuff) );
-#endif
 
             /* Write compressed stream */
             if (outBuff.pos) {
@@ -871,21 +806,15 @@ static int FIO_compressFilename_internal(cRess_t ress,
     {   size_t result = 1;
         while (result != 0) {
             ZSTD_outBuffer outBuff = { ress.dstBuffer, ress.dstBufferSize, 0 };
-#ifdef ZSTD_NEWAPI
             ZSTD_inBuffer inBuff = { NULL, 0, 0 };
             result = ZSTD_compress_generic(ress.cctx,
                         &outBuff, &inBuff, ZSTD_e_end);
-#elif defined(ZSTD_MULTITHREAD)
-            result = ZSTDMT_endStream(ress.cctx, &outBuff);
-#else
-            result = ZSTD_endStream(ress.cctx, &outBuff);
-#endif
             if (ZSTD_isError(result)) {
                 EXM_THROW(26, "Compression error during frame end : %s",
                             ZSTD_getErrorName(result));
             }
             {   size_t const sizeCheck = fwrite(ress.dstBuffer, 1, outBuff.pos, dstFile);
-                if (sizeCheck!=outBuff.pos)
+                if (sizeCheck != outBuff.pos)
                     EXM_THROW(27, "Write error : cannot write frame end into %s", dstFileName);
             }
             compressedfilesize += outBuff.pos;

From eac42534fe4f631606c2d604d5db0b6613cf01cd Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Thu, 19 Oct 2017 11:56:14 -0700
Subject: [PATCH 025/145] bench: fixed Visual warning regarding struct
 initialization

also :
removed dependency on zstdmt_compress.h
removed several unused macros
fileio : small code refactoring to reduce some variable scope
---
 programs/bench.c  |  51 ++++++++--------
 programs/fileio.c | 146 +++++++++++++++++++++-------------------------
 2 files changed, 93 insertions(+), 104 deletions(-)

diff --git a/programs/bench.c b/programs/bench.c
index 5b67d5c76..8ecae9ebd 100644
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -41,7 +41,6 @@
 #include "zstd.h"
 #include "datagen.h"     /* RDG_genBuffer */
 #include "xxhash.h"
-#include "zstdmt_compress.h"
 
 
 /* *************************************
@@ -189,7 +188,6 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
     size_t const maxCompressedSize = ZSTD_compressBound(srcSize) + (maxNbBlocks * 1024);   /* add some room for safety */
     void* const compressedBuffer = malloc(maxCompressedSize);
     void* resultBuffer = malloc(srcSize);
-    ZSTDMT_CCtx* const mtctx = ZSTDMT_createCCtx(g_nbThreads);
     ZSTD_CCtx* const ctx = ZSTD_createCCtx();
     ZSTD_DCtx* const dctx = ZSTD_createDCtx();
     size_t const loadedCompressedSize = srcSize;
@@ -286,7 +284,6 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
                 if (!cCompleted) {   /* still some time to do compression tests */
                     U64 const clockLoop = g_nbSeconds ? TIMELOOP_MICROSEC : 1;
                     U32 nbLoops = 0;
-                    ZSTD_CDict* cdict = NULL;
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_nbThreads, g_nbThreads);
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_compressionLevel, cLevel);
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_enableLongDistanceMatching, g_ldmFlag);
@@ -308,27 +305,31 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
                     do {
                         U32 blockNb;
                         for (blockNb=0; blockNb<nbBlocks; blockNb++) {
-                            size_t rSize;
-                            ZSTD_outBuffer out = { blockTable[blockNb].cPtr,  blockTable[blockNb].cRoom, 0 };
-                            ZSTD_inBuffer in = { blockTable[blockNb].srcPtr,  blockTable[blockNb].srcSize, 0 };
-                            size_t cError = 1;
-                            while (cError) {
-                                cError = ZSTD_compress_generic(ctx,
+                            size_t moreToFlush = 1;
+                            ZSTD_outBuffer out;
+                            ZSTD_inBuffer in;
+                            in.src = blockTable[blockNb].srcPtr;
+                            in.size = blockTable[blockNb].srcSize;
+                            in.pos = 0;
+                            out.dst = blockTable[blockNb].cPtr;
+                            out.size = blockTable[blockNb].cRoom;
+                            out.pos = 0;
+                            while (moreToFlush) {
+                                moreToFlush = ZSTD_compress_generic(ctx,
                                                     &out, &in, ZSTD_e_end);
-                                if (ZSTD_isError(cError))
+                                if (ZSTD_isError(moreToFlush))
                                     EXM_THROW(1, "ZSTD_compress_generic() error : %s",
-                                                ZSTD_getErrorName(cError));
+                                                ZSTD_getErrorName(moreToFlush));
                             }
-                            rSize = out.pos;
-                            blockTable[blockNb].cSize = rSize;
+                            blockTable[blockNb].cSize = out.pos;
                         }
                         nbLoops++;
                     } while (UTIL_clockSpanMicro(clockStart) < clockLoop);
-                    ZSTD_freeCDict(cdict);
-                    {   U64 const clockSpanMicro = UTIL_clockSpanMicro(clockStart);
-                        if (clockSpanMicro < fastestC*nbLoops) fastestC = clockSpanMicro / nbLoops;
-                        totalCTime += clockSpanMicro;
-                        cCompleted = (totalCTime >= maxTime);
+                    {   U64 const loopDuration = UTIL_clockSpanMicro(clockStart);
+                        if (loopDuration < fastestC*nbLoops)
+                            fastestC = loopDuration / nbLoops;
+                        totalCTime += loopDuration;
+                        cCompleted = (totalCTime >= maxTime);  /* end compression tests */
                 }   }
 
                 cSize = 0;
@@ -336,15 +337,15 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
                 ratio = (double)srcSize / (double)cSize;
                 markNb = (markNb+1) % NB_MARKS;
                 DISPLAYLEVEL(2, "%2s-%-17.17s :%10u ->%10u (%5.3f),%6.1f MB/s\r",
-                        marks[markNb], displayName, (U32)srcSize, (U32)cSize, ratio,
-                        (double)srcSize / fastestC );
+                        marks[markNb], displayName, (U32)srcSize, (U32)cSize,
+                        ratio, (double)srcSize / fastestC );
             } else {   /* g_decodeOnly */
                 memcpy(compressedBuffer, srcBuffer, loadedCompressedSize);
             }
 
 #if 0       /* disable decompression test */
             dCompleted=1;
-            (void)totalDTime; (void)fastestD; (void)crcOrig;   /*  unused when decompression disabled */
+            (void)totalDTime; (void)fastestD; (void)crcOrig;   /* unused when decompression disabled */
 #else
             /* Decompression */
             if (!dCompleted) memset(resultBuffer, 0xD6, srcSize);  /* warm result buffer */
@@ -374,9 +375,10 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
                     nbLoops++;
                 } while (UTIL_clockSpanMicro(clockStart) < clockLoop);
                 ZSTD_freeDDict(ddict);
-                {   U64 const clockSpanMicro = UTIL_clockSpanMicro(clockStart);
-                    if (clockSpanMicro < fastestD*nbLoops) fastestD = clockSpanMicro / nbLoops;
-                    totalDTime += clockSpanMicro;
+                {   U64 const loopDuration = UTIL_clockSpanMicro(clockStart);
+                    if (loopDuration < fastestD*nbLoops)
+                        fastestD = loopDuration / nbLoops;
+                    totalDTime += loopDuration;
                     dCompleted = (totalDTime >= maxTime);
             }   }
 
@@ -439,7 +441,6 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
     free(blockTable);
     free(compressedBuffer);
     free(resultBuffer);
-    ZSTDMT_freeCCtx(mtctx);
     ZSTD_freeCCtx(ctx);
     ZSTD_freeDCtx(dctx);
     return 0;
diff --git a/programs/fileio.c b/programs/fileio.c
index c8eab0679..7efa3c656 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -42,9 +42,6 @@
 #include "fileio.h"
 #define ZSTD_STATIC_LINKING_ONLY   /* ZSTD_magicNumber, ZSTD_frameHeaderSize_max */
 #include "zstd.h"
-#ifdef ZSTD_MULTITHREAD
-#  include "zstdmt_compress.h"
-#endif
 #if defined(ZSTD_GZCOMPRESS) || defined(ZSTD_GZDECOMPRESS)
 #  include <zlib.h>
 #  if !defined(z_const)
@@ -70,18 +67,6 @@
 #define MB *(1<<20)
 #define GB *(1U<<30)
 
-#define _1BIT  0x01
-#define _2BITS 0x03
-#define _3BITS 0x07
-#define _4BITS 0x0F
-#define _6BITS 0x3F
-#define _8BITS 0xFF
-
-#define BLOCKSIZE      (128 KB)
-#define ROLLBUFFERSIZE (BLOCKSIZE*8*64)
-
-#define FIO_FRAMEHEADERSIZE  5    /* as a define, because needed to allocated table on stack */
-
 #define DICTSIZE_MAX (32 MB)   /* protection against large input (attack scenario) */
 
 #define FNSPACE 30
@@ -122,14 +107,14 @@ static clock_t g_time = 0;
 #  define ZSTD_DEBUG 0
 #endif
 #define DEBUGLOG(l,...) if (l<=ZSTD_DEBUG) DISPLAY(__VA_ARGS__);
-#define EXM_THROW(error, ...)                                              \
-{                                                                          \
-    DISPLAYLEVEL(1, "zstd: ");                                             \
-    DEBUGLOG(1, "Error defined at %s, line %i : \n", __FILE__, __LINE__);  \
-    DISPLAYLEVEL(1, "error %i : ", error);                                 \
-    DISPLAYLEVEL(1, __VA_ARGS__);                                          \
-    DISPLAYLEVEL(1, " \n");                                                \
-    exit(error);                                                           \
+#define EXM_THROW(error, ...)                                             \
+{                                                                         \
+    DISPLAYLEVEL(1, "zstd: ");                                            \
+    DEBUGLOG(1, "Error defined at %s, line %i : \n", __FILE__, __LINE__); \
+    DISPLAYLEVEL(1, "error %i : ", error);                                \
+    DISPLAYLEVEL(1, __VA_ARGS__);                                         \
+    DISPLAYLEVEL(1, " \n");                                               \
+    exit(error);                                                          \
 }
 
 #define CHECK(f) {                                   \
@@ -273,86 +258,88 @@ static int FIO_remove(const char* path)
 }
 
 /** FIO_openSrcFile() :
- * condition : `dstFileName` must be non-NULL.
- * @result : FILE* to `dstFileName`, or NULL if it fails */
+ *  condition : `srcFileName` must be non-NULL.
+ * @result : FILE* to `srcFileName`, or NULL if it fails */
 static FILE* FIO_openSrcFile(const char* srcFileName)
 {
-    FILE* f;
-
+    assert(srcFileName != NULL);
     if (!strcmp (srcFileName, stdinmark)) {
         DISPLAYLEVEL(4,"Using stdin for input\n");
-        f = stdin;
         SET_BINARY_MODE(stdin);
-    } else {
-        if (!UTIL_isRegularFile(srcFileName)) {
-            DISPLAYLEVEL(1, "zstd: %s is not a regular file -- ignored \n",
-                            srcFileName);
-            return NULL;
-        }
-        f = fopen(srcFileName, "rb");
-        if ( f==NULL )
-            DISPLAYLEVEL(1, "zstd: %s: %s \n", srcFileName, strerror(errno));
+        return stdin;
     }
 
-    return f;
+    if (!UTIL_isRegularFile(srcFileName)) {
+        DISPLAYLEVEL(1, "zstd: %s is not a regular file -- ignored \n",
+                        srcFileName);
+        return NULL;
+    }
+
+    {   FILE* const f = fopen(srcFileName, "rb");
+        if (f == NULL)
+            DISPLAYLEVEL(1, "zstd: %s: %s \n", srcFileName, strerror(errno));
+        return f;
+    }
 }
 
 /** FIO_openDstFile() :
- * condition : `dstFileName` must be non-NULL.
+ *  condition : `dstFileName` must be non-NULL.
  * @result : FILE* to `dstFileName`, or NULL if it fails */
 static FILE* FIO_openDstFile(const char* dstFileName)
 {
-    FILE* f;
-
+    assert(dstFileName != NULL);
     if (!strcmp (dstFileName, stdoutmark)) {
         DISPLAYLEVEL(4,"Using stdout for output\n");
-        f = stdout;
         SET_BINARY_MODE(stdout);
         if (g_sparseFileSupport==1) {
             g_sparseFileSupport = 0;
             DISPLAYLEVEL(4, "Sparse File Support is automatically disabled on stdout ; try --sparse \n");
         }
-    } else {
-        if (g_sparseFileSupport == 1) {
-            g_sparseFileSupport = ZSTD_SPARSE_DEFAULT;
-        }
-        if (strcmp (dstFileName, nulmark)) {
-            /* Check if destination file already exists */
-            f = fopen( dstFileName, "rb" );
-            if (f != 0) {  /* dst file exists, prompt for overwrite authorization */
-                fclose(f);
-                if (!g_overwrite) {
-                    if (g_displayLevel <= 1) {
-                        /* No interaction possible */
-                        DISPLAY("zstd: %s already exists; not overwritten  \n",
-                                dstFileName);
-                        return NULL;
-                    }
-                    DISPLAY("zstd: %s already exists; do you wish to overwrite (y/N) ? ",
-                            dstFileName);
-                    {   int ch = getchar();
-                        if ((ch!='Y') && (ch!='y')) {
-                            DISPLAY("    not overwritten  \n");
-                            return NULL;
-                        }
-                        /* flush rest of input line */
-                        while ((ch!=EOF) && (ch!='\n')) ch = getchar();
-                }   }
-                /* need to unlink */
-                FIO_remove(dstFileName);
-        }   }
-        f = fopen( dstFileName, "wb" );
-        if (f==NULL) DISPLAYLEVEL(1, "zstd: %s: %s\n", dstFileName, strerror(errno));
+        return stdout;
     }
 
-    return f;
+    if (g_sparseFileSupport == 1) {
+        g_sparseFileSupport = ZSTD_SPARSE_DEFAULT;
+    }
+
+    if (strcmp (dstFileName, nulmark)) {  /* not /dev/null */
+        /* Check if destination file already exists */
+        FILE* const fCheck = fopen( dstFileName, "rb" );
+        if (fCheck != NULL) {  /* dst file exists, authorization prompt */
+            fclose(fCheck);
+            if (!g_overwrite) {
+                if (g_displayLevel <= 1) {
+                    /* No interaction possible */
+                    DISPLAY("zstd: %s already exists; not overwritten  \n",
+                            dstFileName);
+                    return NULL;
+                }
+                DISPLAY("zstd: %s already exists; overwrite (y/N) ? ",
+                        dstFileName);
+                {   int ch = getchar();
+                    if ((ch!='Y') && (ch!='y')) {
+                        DISPLAY("    not overwritten  \n");
+                        return NULL;
+                    }
+                    /* flush rest of input line */
+                    while ((ch!=EOF) && (ch!='\n')) ch = getchar();
+            }   }
+            /* need to unlink */
+            FIO_remove(dstFileName);
+    }   }
+
+    {   FILE* const f = fopen( dstFileName, "wb" );
+        if (f == NULL)
+            DISPLAYLEVEL(1, "zstd: %s: %s\n", dstFileName, strerror(errno));
+        return f;
+    }
 }
 
 
 /*! FIO_createDictBuffer() :
  *  creates a buffer, pointed by `*bufferPtr`,
  *  loads `filename` content into it, up to DICTSIZE_MAX bytes.
- *  @return : loaded size
+ * @return : loaded size
  *  if fileName==NULL, returns 0 and a NULL pointer
  */
 static size_t FIO_createDictBuffer(void** bufferPtr, const char* fileName)
@@ -360,12 +347,13 @@ static size_t FIO_createDictBuffer(void** bufferPtr, const char* fileName)
     FILE* fileHandle;
     U64 fileSize;
 
+    assert(bufferPtr != NULL);
     *bufferPtr = NULL;
     if (fileName == NULL) return 0;
 
     DISPLAYLEVEL(4,"Loading %s as dictionary \n", fileName);
     fileHandle = fopen(fileName, "rb");
-    if (fileHandle==0) EXM_THROW(31, "%s: %s", fileName, strerror(errno));
+    if (fileHandle==NULL) EXM_THROW(31, "%s: %s", fileName, strerror(errno));
     fileSize = UTIL_getFileSize(fileName);
     if (fileSize > DICTSIZE_MAX) {
         EXM_THROW(32, "Dictionary file %s is too large (> %u MB)",
@@ -412,13 +400,13 @@ static cRess_t FIO_createCResources(const char* dictFileName, int cLevel,
     if (!ress.srcBuffer || !ress.dstBuffer)
         EXM_THROW(31, "allocation error : not enough memory");
 
-    /* dictionary */
+    /* Advances parameters, including dictionary */
     {   void* dictBuffer;
         size_t const dictBuffSize = FIO_createDictBuffer(&dictBuffer, dictFileName);   /* works with dictFileName==NULL */
         if (dictFileName && (dictBuffer==NULL))
             EXM_THROW(32, "allocation error : can't create dictBuffer");
 
-        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_contentSizeFlag, 1) );  /* always enable content size, when available (note: supposed to be default anyway) */
+        CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_contentSizeFlag, 1) );  /* always enable content size when available (note: supposed to be default) */
         CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_dictIDFlag, g_dictIDFlag) );
         CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_checksumFlag, g_checksumFlag) );
         /* compression level */
@@ -446,7 +434,7 @@ static cRess_t FIO_createCResources(const char* dictFileName, int cLevel,
         DISPLAYLEVEL(5,"set nb threads = %u \n", g_nbThreads);
         CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_nbThreads, g_nbThreads) );
         /* dictionary */
-        CHECK( ZSTD_CCtx_setPledgedSrcSize(ress.cctx, srcSize) );  /* just to load dictionary with good compression parameters */
+        CHECK( ZSTD_CCtx_setPledgedSrcSize(ress.cctx, srcSize) );  /* just for dictionary loading, using good compression parameters */
         CHECK( ZSTD_CCtx_loadDictionary(ress.cctx, dictBuffer, dictBuffSize) );
         CHECK( ZSTD_CCtx_setPledgedSrcSize(ress.cctx, ZSTD_CONTENTSIZE_UNKNOWN) );  /* reset */
 

From 91535d71ec58b9ef9090c5b4ed39a31243a5ced4 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Thu, 19 Oct 2017 12:09:34 -0700
Subject: [PATCH 026/145] fixed missing zstdmt_compress.h dependency

we lose a warning message :
when a job size is chosen < minimum job size for multithreading,
it is automatically resized to minimum size.

If this information is really useful, it should be present in zstd.h now.
---
 programs/fileio.c | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/programs/fileio.c b/programs/fileio.c
index 7efa3c656..a8e33994c 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -203,10 +203,6 @@ static U32 g_blockSize = 0;
 void FIO_setBlockSize(unsigned blockSize) {
     if (blockSize && g_nbThreads==1)
         DISPLAYLEVEL(2, "Setting block size is useless in single-thread mode \n");
-#ifdef ZSTD_MULTITHREAD
-    if (blockSize-1 < ZSTDMT_SECTION_SIZE_MIN-1)   /* intentional underflow */
-        DISPLAYLEVEL(2, "Note : minimum block size is %u KB \n", (ZSTDMT_SECTION_SIZE_MIN>>10));
-#endif
     g_blockSize = blockSize;
 }
 #define FIO_OVERLAP_LOG_NOTSET 9999

From 97dccbbb2b9905d491c65ccab79d53e3b0a05187 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Thu, 19 Oct 2017 14:05:23 -0700
Subject: [PATCH 027/145] fixed zbufftest

preserve "pledgedSrcSize=0" means "unknown" in init_advanced()
---
 lib/deprecated/zbuff_compress.c | 1 +
 tests/zbufftest.c               | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/deprecated/zbuff_compress.c b/lib/deprecated/zbuff_compress.c
index 8adbaec26..f39c60d89 100644
--- a/lib/deprecated/zbuff_compress.c
+++ b/lib/deprecated/zbuff_compress.c
@@ -72,6 +72,7 @@ size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc,
                                    const void* dict, size_t dictSize,
                                    ZSTD_parameters params, unsigned long long pledgedSrcSize)
 {
+    if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;  /* preserve "0 == unknown" behavior */
     return ZSTD_initCStream_advanced(zbc, dict, dictSize, params, pledgedSrcSize);
 }
 
diff --git a/tests/zbufftest.c b/tests/zbufftest.c
index e64c886a5..ce5e5518a 100644
--- a/tests/zbufftest.c
+++ b/tests/zbufftest.c
@@ -357,7 +357,7 @@ static int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compres
             {   ZSTD_parameters params = ZSTD_getParams(cLevel, 0, dictSize);
                 params.fParams.checksumFlag = FUZ_rand(&lseed) & 1;
                 params.fParams.noDictIDFlag = FUZ_rand(&lseed) & 1;
-                {   size_t const initError = ZBUFF_compressInit_advanced(zc, dict, dictSize, params, 0);
+                {   size_t const initError = ZBUFF_compressInit_advanced(zc, dict, dictSize, params, ZSTD_CONTENTSIZE_UNKNOWN);
                     CHECK (ZBUFF_isError(initError),"init error : %s", ZBUFF_getErrorName(initError));
         }   }   }
 

From b495140f67cb638beaa9dd0120fe7954861d0bdf Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Wed, 25 Oct 2017 12:47:57 -0700
Subject: [PATCH 028/145] Update BUCK files

* Correct XXH namespace (Fixes #901)
* Multithreading always enabled
* GZIP/LZ4/LZMA always enabled
* Legacy support always fully enabled
---
 lib/BUCK         | 41 +++++++++++++++++++++++++++++++----------
 programs/BUCK    | 41 +++++++++++------------------------------
 zlibWrapper/BUCK |  2 +-
 3 files changed, 43 insertions(+), 41 deletions(-)

diff --git a/lib/BUCK b/lib/BUCK
index 6812c1b1e..9e01468f4 100644
--- a/lib/BUCK
+++ b/lib/BUCK
@@ -15,15 +15,9 @@ cxx_library(
     header_namespace='',
     visibility=['PUBLIC'],
     exported_headers=subdir_glob([
-        ('compress', 'zstdmt_compress.h'),
+        ('compress', 'zstd*.h'),
     ]),
-    headers=subdir_glob([
-        ('compress', 'zstd_opt.h'),
-    ]),
-    srcs=[
-        'compress/zstd_compress.c',
-        'compress/zstdmt_compress.c',
-    ],
+    srcs=glob(['compress/zstd*.c']),
     deps=[':common'],
 )
 
@@ -31,7 +25,7 @@ cxx_library(
     name='decompress',
     header_namespace='',
     visibility=['PUBLIC'],
-    srcs=['decompress/zstd_decompress.c'],
+    srcs=glob(['decompress/zstd*.c']),
     deps=[
         ':common',
         ':legacy',
@@ -58,6 +52,9 @@ cxx_library(
     ]),
     srcs=glob(['legacy/*.c']),
     deps=[':common'],
+    exported_preprocessor_flags=[
+        '-DZSTD_LEGACY_SUPPORT=4',
+    ],
 )
 
 cxx_library(
@@ -74,6 +71,15 @@ cxx_library(
     deps=[':common'],
 )
 
+cxx_library(
+    name='compiler',
+    header_namespace='',
+    visibility=['PUBLIC'],
+    exported_headers=subdir_glob([
+        ('common', 'compiler.h'),
+    ]),
+)
+
 cxx_library(
     name='bitstream',
     header_namespace='',
@@ -100,6 +106,7 @@ cxx_library(
     ],
     deps=[
         ':bitstream',
+        ':compiler',
         ':errors',
         ':mem',
     ],
@@ -133,7 +140,10 @@ cxx_library(
         ('common', 'pool.h'),
     ]),
     srcs=['common/pool.c'],
-    deps=[':threading'],
+    deps=[
+        ':threading',
+        ':zstd_common',
+    ],
 )
 
 cxx_library(
@@ -144,6 +154,12 @@ cxx_library(
         ('common', 'threading.h'),
     ]),
     srcs=['common/threading.c'],
+    exported_preprocessor_flags=[
+        '-DZSTD_MULTITHREAD',
+    ],
+    exported_linker_flags=[
+        '-pthread',
+    ],
 )
 
 cxx_library(
@@ -154,6 +170,9 @@ cxx_library(
         ('common', 'xxhash.h'),
     ]),
     srcs=['common/xxhash.c'],
+    exported_preprocessor_flags=[
+        '-DXXH_NAMESPACE=ZSTD_',
+    ],
 )
 
 cxx_library(
@@ -166,6 +185,7 @@ cxx_library(
     ]),
     srcs=['common/zstd_common.c'],
     deps=[
+        ':compiler',
         ':errors',
         ':mem',
     ],
@@ -175,6 +195,7 @@ cxx_library(
     name='common',
     deps=[
         ':bitstream',
+        ':compiler',
         ':entropy',
         ':errors',
         ':mem',
diff --git a/programs/BUCK b/programs/BUCK
index 069403042..d2aa6373f 100644
--- a/programs/BUCK
+++ b/programs/BUCK
@@ -10,38 +10,19 @@ cxx_binary(
         '//lib:mem',
         '//lib:xxhash',
     ],
-)
-
-cxx_binary(
-    name='zstdmt',
-    headers=glob(['*.h'], excludes=['datagen.h', 'platform.h', 'util.h']),
-    srcs=glob(['*.c'], excludes=['datagen.c']),
-    deps=[
-        ':datagen',
-        ':util',
-        '//lib:zstd',
-        '//lib:zdict',
-        '//lib:mem',
-        '//lib:xxhash',
+    preprocessor_flags=[
+        '-DZSTD_GZCOMPRESS',
+        '-DZSTD_GZDECOMPRESS',
+        '-DZSTD_LZMACOMPRESS',
+        '-DZSTD_LZMADECOMPRES',
+        '-DZSTD_LZ4COMPRESS',
+        '-DZSTD_LZ4DECOMPRES',
     ],
-    preprocessor_flags=['-DZSTD_MULTITHREAD'],
-    linker_flags=['-lpthread'],
-)
-
-cxx_binary(
-    name='gzstd',
-    headers=glob(['*.h'], excludes=['datagen.h', 'platform.h', 'util.h']),
-    srcs=glob(['*.c'], excludes=['datagen.c']),
-    deps=[
-        ':datagen',
-        ':util',
-        '//lib:zstd',
-        '//lib:zdict',
-        '//lib:mem',
-        '//lib:xxhash',
+    linker_flags=[
+        '-lz',
+        '-llzma',
+        '-llz4',
     ],
-    preprocessor_flags=['-DZSTD_GZDECOMPRESS'],
-    linker_flags=['-lz'],
 )
 
 cxx_library(
diff --git a/zlibWrapper/BUCK b/zlibWrapper/BUCK
index a3b74ac3f..a0710e1cf 100644
--- a/zlibWrapper/BUCK
+++ b/zlibWrapper/BUCK
@@ -12,7 +12,7 @@ cxx_library(
     deps=[
         '//lib:zstd',
         '//lib:zstd_common',
-    ]
+    ],
 )
 
 cxx_binary(

From 86b8134cadadc7dcfb7f9e43baa54212ea7c58c3 Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Wed, 25 Oct 2017 17:10:57 -0700
Subject: [PATCH 029/145] [libzstd] Fix parameter selection for empty input

ZSTD_compress() and friends would treat an empty input as an unknown size
when selecting parameters. Thus, they would drastically overallocate the
context. Tell ZSTD_getParams() that the source size is 1 when it is empty.
---
 lib/compress/zstd_compress.c | 2 +-
 tests/fuzzer.c               | 8 ++++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 635cc665c..21b84d104 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -2213,7 +2213,7 @@ size_t ZSTD_compress_advanced_internal(
 size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize,
                                const void* dict, size_t dictSize, int compressionLevel)
 {
-    ZSTD_parameters params = ZSTD_getParams(compressionLevel, srcSize, dict ? dictSize : 0);
+    ZSTD_parameters params = ZSTD_getParams(compressionLevel, srcSize ? srcSize : 1, dict ? dictSize : 0);
     params.fParams.contentSizeFlag = 1;
     return ZSTD_compress_internal(ctx, dst, dstCapacity, src, srcSize, dict, dictSize, params);
 }
diff --git a/tests/fuzzer.c b/tests/fuzzer.c
index 76df77af9..e40f19978 100644
--- a/tests/fuzzer.c
+++ b/tests/fuzzer.c
@@ -359,6 +359,14 @@ static int basicUnitTests(U32 seed, double compressibility)
       if (ZSTD_getErrorCode(r) != ZSTD_error_srcSize_wrong) goto _output_error; }
     DISPLAYLEVEL(4, "OK \n");
 
+    DISPLAYLEVEL(4, "test%di : check CCtx size after compressing empty input : ", testNb++);
+    {   ZSTD_CCtx* cctx = ZSTD_createCCtx();
+        size_t const r = ZSTD_compressCCtx(cctx, compressedBuffer, compressedBufferSize, NULL, 0, 19);
+        if (ZSTD_isError(r)) goto _output_error;
+        if (ZSTD_sizeof_CCtx(cctx) > (1U << 20)) goto _output_error;
+        ZSTD_freeCCtx(cctx);
+    }
+    DISPLAYLEVEL(4, "OK \n");
 
     /* Static CCtx tests */
 #define STATIC_CCTX_LEVEL 3

From 61e5a1adfc1645bf44e7c69a41c372b595202b22 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 31 Oct 2017 17:43:24 -0700
Subject: [PATCH 030/145] removed direct call to malloc() from pool.c

---
 lib/common/pool.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/lib/common/pool.c b/lib/common/pool.c
index 1b0fe1035..98b109e72 100644
--- a/lib/common/pool.c
+++ b/lib/common/pool.c
@@ -11,7 +11,6 @@
 
 /* ======   Dependencies   ======= */
 #include <stddef.h>  /* size_t */
-#include <stdlib.h>  /* malloc, calloc, free */
 #include "pool.h"
 
 /* ======   Compiler specifics   ====== */
@@ -115,7 +114,7 @@ POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize, ZSTD_customM
      * and full queues.
      */
     ctx->queueSize = queueSize + 1;
-    ctx->queue = (POOL_job*) malloc(ctx->queueSize * sizeof(POOL_job));
+    ctx->queue = (POOL_job*)ZSTD_malloc(ctx->queueSize * sizeof(POOL_job), customMem);
     ctx->queueHead = 0;
     ctx->queueTail = 0;
     ctx->numThreadsBusy = 0;

From 1fc4f593da3cc810ae1744550196dacfa36d628d Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Wed, 1 Nov 2017 12:49:51 -0700
Subject: [PATCH 031/145] Allow skippable frames of any size

---
 lib/decompress/zstd_decompress.c | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/lib/decompress/zstd_decompress.c b/lib/decompress/zstd_decompress.c
index 96fc60908..caeafc255 100644
--- a/lib/decompress/zstd_decompress.c
+++ b/lib/decompress/zstd_decompress.c
@@ -2555,17 +2555,21 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
             /* fall-through */
         case zdss_load:
             {   size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds);
-                size_t const toLoad = neededInSize - zds->inPos;   /* should always be <= remaining space within inBuff */
+                size_t const toLoad = neededInSize - zds->inPos;
+                int const isSkipFrame = ZSTD_isSkipFrame(zds);
                 size_t loadedSize;
-                if (toLoad > zds->inBuffSize - zds->inPos) return ERROR(corruption_detected);   /* should never happen */
-                loadedSize = ZSTD_limitCopy(zds->inBuff + zds->inPos, toLoad, ip, iend-ip);
+                if (isSkipFrame) {
+                    loadedSize = MIN(toLoad, (size_t)(iend-ip));
+                } else {
+                    if (toLoad > zds->inBuffSize - zds->inPos) return ERROR(corruption_detected);   /* should never happen */
+                    loadedSize = ZSTD_limitCopy(zds->inBuff + zds->inPos, toLoad, ip, iend-ip);
+                }
                 ip += loadedSize;
                 zds->inPos += loadedSize;
                 if (loadedSize < toLoad) { someMoreWork = 0; break; }   /* not enough input, wait for more */
 
                 /* decode loaded input */
-                {  const int isSkipFrame = ZSTD_isSkipFrame(zds);
-                   size_t const decodedSize = ZSTD_decompressContinue(zds,
+                {   size_t const decodedSize = ZSTD_decompressContinue(zds,
                         zds->outBuff + zds->outStart, zds->outBuffSize - zds->outStart,
                         zds->inBuff, neededInSize);
                     if (ZSTD_isError(decodedSize)) return decodedSize;

From e19b0822bc08e0427daa4b1a7c366e51a3efb809 Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Wed, 1 Nov 2017 13:10:03 -0700
Subject: [PATCH 032/145] Test large skippable frames

---
 tests/fuzzer.c      | 2 +-
 tests/zstreamtest.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/fuzzer.c b/tests/fuzzer.c
index e40f19978..be9dc3e06 100644
--- a/tests/fuzzer.c
+++ b/tests/fuzzer.c
@@ -525,7 +525,7 @@ static int basicUnitTests(U32 seed, double compressibility)
             off += r;
             if (i == segs/2) {
                 /* insert skippable frame */
-                const U32 skipLen = 128 KB;
+                const U32 skipLen = 129 KB;
                 MEM_writeLE32((BYTE*)compressedBuffer + off, ZSTD_MAGIC_SKIPPABLE_START);
                 MEM_writeLE32((BYTE*)compressedBuffer + off + 4, skipLen);
                 off += skipLen + ZSTD_skippableHeaderSize;
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index 6f1f6df18..53dbaf3ba 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -213,7 +213,7 @@ static int basicUnitTests(U32 seed, double compressibility, ZSTD_customMem custo
 {
     size_t const CNBufferSize = COMPRESSIBLE_NOISE_LENGTH;
     void* CNBuffer = malloc(CNBufferSize);
-    size_t const skippableFrameSize = 11;
+    size_t const skippableFrameSize = 200 KB;
     size_t const compressedBufferSize = (8 + skippableFrameSize) + ZSTD_compressBound(COMPRESSIBLE_NOISE_LENGTH);
     void* compressedBuffer = malloc(compressedBufferSize);
     size_t const decodedBufferSize = CNBufferSize;

From 428e8b3bf49ed9d36e732acf634d6150d0e2b302 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 1 Nov 2017 13:15:23 -0700
Subject: [PATCH 033/145] fix : ZSTD_compress_generic(,,,ZSTD_e_end)
 automatically sets pledgedSrcSize

as per documentation, on ZSTD_setPledgedSrcSize() :
> If all data is provided and consumed in a single round,
> this value (pledgedSrcSize) is overriden by srcSize instead.

This wasn't applied before compression level is transformed into compression parameters.
As a consequence, small input missed compression parameters adaptation.

It seems to work fine now : compression was compared with ZSTD_compress_advanced(),
results were the same.
---
 lib/compress/zstd_compress.c |  1 +
 programs/bench.c             | 10 ++++++++++
 2 files changed, 11 insertions(+)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 21b84d104..d50f35116 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -2814,6 +2814,7 @@ size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
     if (cctx->streamStage == zcss_init) {
         ZSTD_prefixDict const prefixDict = cctx->prefixDict;
         ZSTD_CCtx_params params = cctx->requestedParams;
+        if (endOp == ZSTD_e_end) cctx->pledgedSrcSizePlusOne = input->size + 1;
         params.cParams = ZSTD_getCParamsFromCCtxParams(
                 cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1, 0 /*dictSize*/);
         memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));  /* single usage */
diff --git a/programs/bench.c b/programs/bench.c
index 8ecae9ebd..66c406abd 100644
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -286,6 +286,7 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
                     U32 nbLoops = 0;
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_nbThreads, g_nbThreads);
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_compressionLevel, cLevel);
+                    //ZSTD_CCtx_setPledgedSrcSize(ctx, blockTable[0].srcSize);  /* estimation, only to help cLevel conversion before applying advanced compression parameters */
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_enableLongDistanceMatching, g_ldmFlag);
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_ldmMinMatch, g_ldmMinMatch);
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_ldmHashLog, g_ldmHashLog);
@@ -305,6 +306,14 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
                     do {
                         U32 blockNb;
                         for (blockNb=0; blockNb<nbBlocks; blockNb++) {
+#if 0   /* direct compression function, for occasional comparison */
+                            ZSTD_parameters const params = ZSTD_getParams(cLevel, blockTable[blockNb].srcSize, dictBufferSize);
+                            blockTable[blockNb].cSize = ZSTD_compress_advanced(ctx,
+                                                            blockTable[blockNb].cPtr, blockTable[blockNb].cRoom,
+                                                            blockTable[blockNb].srcPtr, blockTable[blockNb].srcSize,
+                                                            dictBuffer, dictBufferSize,
+                                                            params);
+#else
                             size_t moreToFlush = 1;
                             ZSTD_outBuffer out;
                             ZSTD_inBuffer in;
@@ -322,6 +331,7 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
                                                 ZSTD_getErrorName(moreToFlush));
                             }
                             blockTable[blockNb].cSize = out.pos;
+#endif
                         }
                         nbLoops++;
                     } while (UTIL_clockSpanMicro(clockStart) < clockLoop);

From 150354c5fe59b7c0ca970589d54d67da60048cbd Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 1 Nov 2017 16:57:48 -0700
Subject: [PATCH 034/145] minor refactor

added some traces and assert
related to hunting a potential ubsan error in 32-bits more
(it ends up being a compiler-side issue : https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82802).

Modified one pointer arithmetic expression for a more conformant way.
---
 lib/compress/zstd_compress.c   | 15 +++++++++-----
 lib/compress/zstdmt_compress.c | 36 ++++++++++++++++++++++------------
 tests/zstreamtest.c            |  3 ++-
 3 files changed, 36 insertions(+), 18 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index d50f35116..808418a60 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -1468,14 +1468,18 @@ MEM_STATIC size_t ZSTD_compressSequences_internal(seqStore_t* seqStorePtr,
                 entropy, cParams->strategy, op, dstCapacity, literals, litSize);
         if (ZSTD_isError(cSize))
           return cSize;
+        assert(cSize <= dstCapacity);
         op += cSize;
     }
 
     /* Sequences Header */
-    if ((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead */) return ERROR(dstSize_tooSmall);
-    if (nbSeq < 0x7F) *op++ = (BYTE)nbSeq;
-    else if (nbSeq < LONGNBSEQ) op[0] = (BYTE)((nbSeq>>8) + 0x80), op[1] = (BYTE)nbSeq, op+=2;
-    else op[0]=0xFF, MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ)), op+=3;
+    if ((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/) return ERROR(dstSize_tooSmall);
+    if (nbSeq < 0x7F)
+        *op++ = (BYTE)nbSeq;
+    else if (nbSeq < LONGNBSEQ)
+        op[0] = (BYTE)((nbSeq>>8) + 0x80), op[1] = (BYTE)nbSeq, op+=2;
+    else
+        op[0]=0xFF, MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ)), op+=3;
     if (nbSeq==0) return op - ostart;
 
     /* seqHead : flags for FSE encoding type */
@@ -1606,6 +1610,7 @@ static void ZSTD_storeLastLiterals(seqStore_t* seqStorePtr,
 
 static size_t ZSTD_compressBlock_internal(ZSTD_CCtx* zc, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
 {
+    DEBUGLOG(5, "ZSTD_compressBlock_internal : dstCapacity = %u", (U32)dstCapacity);
     if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1)
         return 0;   /* don't even attempt compression below a certain srcSize */
     ZSTD_resetSeqStore(&(zc->seqStore));
@@ -1867,7 +1872,7 @@ static size_t ZSTD_loadDictionaryContent(ZSTD_CCtx* zc, const void* src, size_t
     zc->lowLimit = zc->dictLimit;
     zc->dictLimit = (U32)(zc->nextSrc - zc->base);
     zc->dictBase = zc->base;
-    zc->base += ip - zc->nextSrc;
+    zc->base = ip - zc->dictLimit;
     zc->nextToUpdate = zc->dictLimit;
     zc->loadedDictEnd = zc->appliedParams.forceWindow ? 0 : (U32)(iend - zc->base);
 
diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c
index af7be3167..a855745be 100644
--- a/lib/compress/zstdmt_compress.c
+++ b/lib/compress/zstdmt_compress.c
@@ -142,7 +142,10 @@ static size_t ZSTDMT_sizeof_bufferPool(ZSTDMT_bufferPool* bufPool)
 
 static void ZSTDMT_setBufferSize(ZSTDMT_bufferPool* bufPool, size_t bSize)
 {
+    ZSTD_pthread_mutex_lock(&bufPool->poolMutex);
+    DEBUGLOG(4, "ZSTDMT_setBufferSize: bSize = %u", (U32)bSize);
     bufPool->bufferSize = bSize;
+    ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
 }
 
 /** ZSTDMT_getBuffer() :
@@ -150,28 +153,31 @@ static void ZSTDMT_setBufferSize(ZSTDMT_bufferPool* bufPool, size_t bSize)
 static buffer_t ZSTDMT_getBuffer(ZSTDMT_bufferPool* bufPool)
 {
     size_t const bSize = bufPool->bufferSize;
-    DEBUGLOG(5, "ZSTDMT_getBuffer");
+    DEBUGLOG(5, "ZSTDMT_getBuffer: bSize = %u", (U32)bufPool->bufferSize);
     ZSTD_pthread_mutex_lock(&bufPool->poolMutex);
     if (bufPool->nbBuffers) {   /* try to use an existing buffer */
         buffer_t const buf = bufPool->bTable[--(bufPool->nbBuffers)];
         size_t const availBufferSize = buf.size;
         bufPool->bTable[bufPool->nbBuffers] = g_nullBuffer;
-        if ((availBufferSize >= bSize) & (availBufferSize <= 10*bSize)) {
+        if ((availBufferSize >= bSize) & ((availBufferSize>>3) <= bSize)) {
             /* large enough, but not too much */
+            DEBUGLOG(5, "ZSTDMT_getBuffer: provide buffer %u of size %u",
+                        bufPool->nbBuffers, (U32)buf.size);
             ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
             return buf;
         }
         /* size conditions not respected : scratch this buffer, create new one */
-        DEBUGLOG(5, "existing buffer does not meet size conditions => freeing");
+        DEBUGLOG(5, "ZSTDMT_getBuffer: existing buffer does not meet size conditions => freeing");
         ZSTD_free(buf.start, bufPool->cMem);
     }
     ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
     /* create new buffer */
-    DEBUGLOG(5, "create a new buffer");
+    DEBUGLOG(5, "ZSTDMT_getBuffer: create a new buffer");
     {   buffer_t buffer;
         void* const start = ZSTD_malloc(bSize, bufPool->cMem);
         buffer.start = start;   /* note : start can be NULL if malloc fails ! */
         buffer.size = (start==NULL) ? 0 : bSize;
+        DEBUGLOG(5, "ZSTDMT_getBuffer: created buffer of size %u", (U32)bSize);
         return buffer;
     }
 }
@@ -184,12 +190,14 @@ static void ZSTDMT_releaseBuffer(ZSTDMT_bufferPool* bufPool, buffer_t buf)
     ZSTD_pthread_mutex_lock(&bufPool->poolMutex);
     if (bufPool->nbBuffers < bufPool->totalBuffers) {
         bufPool->bTable[bufPool->nbBuffers++] = buf;  /* stored for later use */
+        DEBUGLOG(5, "ZSTDMT_releaseBuffer: stored buffer of size %u in slot %u",
+                    (U32)buf.size, (U32)(bufPool->nbBuffers-1));
         ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
         return;
     }
     ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
     /* Reached bufferPool capacity (should not happen) */
-    DEBUGLOG(5, "buffer pool capacity reached => freeing ");
+    DEBUGLOG(5, "ZSTDMT_releaseBuffer: pool capacity reached => freeing ");
     ZSTD_free(buf.start, bufPool->cMem);
 }
 
@@ -324,11 +332,10 @@ typedef struct {
 void ZSTDMT_compressChunk(void* jobDescription)
 {
     ZSTDMT_jobDescription* const job = (ZSTDMT_jobDescription*)jobDescription;
-    ZSTD_CCtx* cctx = ZSTDMT_getCCtx(job->cctxPool);
+    ZSTD_CCtx* const cctx = ZSTDMT_getCCtx(job->cctxPool);
     const void* const src = (const char*)job->srcStart + job->dictSize;
     buffer_t dstBuff = job->dstBuff;
-    DEBUGLOG(5, "ZSTDMT_compressChunk")
-    DEBUGLOG(5, "job (first:%u) (last:%u) : dictSize %u, srcSize %u",
+    DEBUGLOG(5, "ZSTDMT_compressChunk: job (first:%u) (last:%u) : dictSize %u, srcSize %u",
                  job->firstChunk, job->lastChunk, (U32)job->dictSize, (U32)job->srcSize);
 
     if (cctx==NULL) {
@@ -343,11 +350,12 @@ void ZSTDMT_compressChunk(void* jobDescription)
             goto _endJob;
         }
         job->dstBuff = dstBuff;
+        DEBUGLOG(5, "ZSTDMT_compressChunk: allocated dstBuff of size %u", (U32)dstBuff.size);
     }
 
     if (job->cdict) {
         size_t const initError = ZSTD_compressBegin_usingCDict_advanced(cctx, job->cdict, job->params.fParams, job->fullFrameSize);
-        DEBUGLOG(4, "ZSTDMT_compressChunk, using CDict");
+        DEBUGLOG(4, "ZSTDMT_compressChunk: init using CDict");
         assert(job->firstChunk); /* should only happen for first segment */
         if (ZSTD_isError(initError)) { job->cSize = initError; goto _endJob; }
     } else {  /* srcStart points at reloaded section */
@@ -367,7 +375,7 @@ void ZSTDMT_compressChunk(void* jobDescription)
         ZSTD_invalidateRepCodes(cctx);
     }
 
-    DEBUGLOG(5, "Compressing : ");
+    DEBUGLOG(5, "Compressing into dstBuff of size %u", (U32)dstBuff.size);
     DEBUG_PRINTHEX(6, job->srcStart, 12);
     job->cSize = (job->lastChunk) ?
                  ZSTD_compressEnd     (cctx, dstBuff.start, dstBuff.size, src, job->srcSize) :
@@ -769,6 +777,7 @@ size_t ZSTDMT_initCStream_internal(
                                          dict, dictSize, cdict,
                                          singleThreadParams, pledgedSrcSize);
     }
+    DEBUGLOG(4, "multi - threading mode");
 
     if (zcs->allJobsCompleted == 0) {   /* previous compression not correctly finished */
         ZSTDMT_waitForAllJobsCompleted(zcs);
@@ -796,9 +805,10 @@ size_t ZSTDMT_initCStream_internal(
     DEBUGLOG(4, "overlap Size : %u KB", (U32)(zcs->targetDictSize>>10));
     zcs->targetSectionSize = params.jobSize ? params.jobSize : (size_t)1 << (params.cParams.windowLog + 2);
     zcs->targetSectionSize = MAX(ZSTDMT_SECTION_SIZE_MIN, zcs->targetSectionSize);
-    zcs->targetSectionSize = MAX(zcs->targetDictSize, zcs->targetSectionSize);
+    zcs->targetSectionSize = MAX(zcs->targetDictSize, zcs->targetSectionSize);   /* one job size must be at least overlap */
     DEBUGLOG(4, "Section Size : %u KB", (U32)(zcs->targetSectionSize>>10));
     zcs->inBuffSize = zcs->targetDictSize + zcs->targetSectionSize;
+    DEBUGLOG(4, "inBuff Size : %u KB", (U32)(zcs->inBuffSize>>10));
     ZSTDMT_setBufferSize(zcs->bufPool, MAX(zcs->inBuffSize, ZSTD_compressBound(zcs->targetSectionSize)) );
     zcs->inBuff.buffer = g_nullBuffer;
     zcs->dictSize = 0;
@@ -863,7 +873,8 @@ static size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* zcs, size_t srcSize, unsi
 {
     unsigned const jobID = zcs->nextJobID & zcs->jobIDMask;
 
-    DEBUGLOG(4, "preparing job %u to compress %u bytes with %u preload ",
+    DEBUGLOG(5, "ZSTDMT_createCompressionJob");
+    DEBUGLOG(5, "preparing job %u to compress %u bytes with %u preload ",
                 zcs->nextJobID, (U32)srcSize, (U32)zcs->dictSize);
     zcs->jobs[jobID].src = zcs->inBuff.buffer;
     zcs->jobs[jobID].srcStart = zcs->inBuff.buffer.start;
@@ -994,6 +1005,7 @@ size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
 {
     size_t const newJobThreshold = mtctx->dictSize + mtctx->targetSectionSize;
     unsigned forwardInputProgress = 0;
+    DEBUGLOG(5, "ZSTDMT_compressStream_generic");
     assert(output->pos <= output->size);
     assert(input->pos  <= input->size);
     if ((mtctx->frameEnded) && (endOp==ZSTD_e_continue)) {
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index 6f1f6df18..84dcc6fbf 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -951,7 +951,7 @@ static int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compres
             for (n=0, cSize=0, totalTestSize=0 ; totalTestSize < maxTestSize ; n++) {
                 /* compress random chunks into randomly sized dst buffers */
                 {   size_t const randomSrcSize = FUZ_randomLength(&lseed, maxSampleLog);
-                    size_t const srcSize = MIN (maxTestSize-totalTestSize, randomSrcSize);
+                    size_t const srcSize = MIN(maxTestSize-totalTestSize, randomSrcSize);
                     size_t const srcStart = FUZ_rand(&lseed) % (srcBufferSize - srcSize);
                     size_t const randomDstSize = FUZ_randomLength(&lseed, maxSampleLog);
                     size_t const dstBuffSize = MIN(cBufferSize - cSize, randomDstSize);
@@ -1564,6 +1564,7 @@ static int fuzzerTests_newAPI(U32 seed, U32 nbTests, unsigned startTest, double
                 size_t const srcStart = FUZ_rand(&lseed) % (srcBufferSize - srcSize);
                 size_t const randomDstSize = FUZ_randomLength(&lseed, maxSampleLog+1);
                 size_t const dstBuffSize = MIN(cBufferSize - cSize, randomDstSize);
+                DISPLAYLEVEL(2, "dstBuffSize : %u \n", (U32)dstBuffSize);
                 ZSTD_EndDirective const flush = (FUZ_rand(&lseed) & 15) ? ZSTD_e_continue : ZSTD_e_flush;
                 ZSTD_inBuffer inBuff = { srcBuffer+srcStart, srcSize, 0 };
                 outBuff.size = outBuff.pos + dstBuffSize;

From 6f1dfa8adf0cc3a8038266ce8926534d08ab7d71 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 1 Nov 2017 17:01:45 -0700
Subject: [PATCH 035/145] removed line with `//` comment

this is for a different topic
(better parameter adaptation for small files + dictionary and/or custome parameters)
---
 programs/bench.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/programs/bench.c b/programs/bench.c
index 66c406abd..5093f110d 100644
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -286,7 +286,6 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
                     U32 nbLoops = 0;
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_nbThreads, g_nbThreads);
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_compressionLevel, cLevel);
-                    //ZSTD_CCtx_setPledgedSrcSize(ctx, blockTable[0].srcSize);  /* estimation, only to help cLevel conversion before applying advanced compression parameters */
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_enableLongDistanceMatching, g_ldmFlag);
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_ldmMinMatch, g_ldmMinMatch);
                     ZSTD_CCtx_setParameter(ctx, ZSTD_p_ldmHashLog, g_ldmHashLog);

From 3b59a010397f5da74aabdf8eca7c8f9c6765b6b5 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 1 Nov 2017 17:36:31 -0700
Subject: [PATCH 036/145] fixed zstreamtest declaration after statement

---
 tests/zstreamtest.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index 84dcc6fbf..6dc9cada1 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -1564,7 +1564,6 @@ static int fuzzerTests_newAPI(U32 seed, U32 nbTests, unsigned startTest, double
                 size_t const srcStart = FUZ_rand(&lseed) % (srcBufferSize - srcSize);
                 size_t const randomDstSize = FUZ_randomLength(&lseed, maxSampleLog+1);
                 size_t const dstBuffSize = MIN(cBufferSize - cSize, randomDstSize);
-                DISPLAYLEVEL(2, "dstBuffSize : %u \n", (U32)dstBuffSize);
                 ZSTD_EndDirective const flush = (FUZ_rand(&lseed) & 15) ? ZSTD_e_continue : ZSTD_e_flush;
                 ZSTD_inBuffer inBuff = { srcBuffer+srcStart, srcSize, 0 };
                 outBuff.size = outBuff.pos + dstBuffSize;

From 8b6aecf2cb6671c943a31a069bbed1e8ffea5064 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 7 Nov 2017 15:27:06 -0800
Subject: [PATCH 037/145] moved a few structures from `zstd_internal.h` to
 `zstd_compress.h`

which is a more precise scope
---
 lib/common/zstd_internal.h     | 153 +++------------------------------
 lib/compress/zstd_compress.h   | 146 ++++++++++++++++++++++++++++++-
 lib/compress/zstd_opt.c        |  15 ++--
 lib/compress/zstdmt_compress.c |   2 +-
 4 files changed, 164 insertions(+), 152 deletions(-)

diff --git a/lib/common/zstd_internal.h b/lib/common/zstd_internal.h
index e91cd20ba..0fb8e49da 100644
--- a/lib/common/zstd_internal.h
+++ b/lib/common/zstd_internal.h
@@ -11,6 +11,10 @@
 #ifndef ZSTD_CCOMMON_H_MODULE
 #define ZSTD_CCOMMON_H_MODULE
 
+/* this module contains definitions which must be identical
+ * across compression, decompression and dictBuilder.
+ * It also contains a few functions useful to at least 2 of them
+ * and which benefit from being inlined */
 
 /*-*************************************
 *  Dependencies
@@ -191,17 +195,14 @@ MEM_STATIC void ZSTD_wildcopy_e(void* dst, const void* src, void* dstEnd)   /* s
 
 
 /*-*******************************************
-*  Private interfaces
+*  Private declarations
 *********************************************/
-typedef struct ZSTD_stats_s ZSTD_stats_t;
-
 typedef struct seqDef_s {
     U32 offset;
     U16 litLength;
     U16 matchLength;
 } seqDef;
 
-
 typedef struct {
     seqDef* sequencesStart;
     seqDef* sequences;
@@ -216,100 +217,8 @@ typedef struct {
     U32   repToConfirm[ZSTD_REP_NUM];
 } seqStore_t;
 
-typedef struct {
-    U32 off;
-    U32 len;
-} ZSTD_match_t;
-
-typedef struct {
-    U32 price;
-    U32 off;
-    U32 mlen;
-    U32 litlen;
-    U32 rep[ZSTD_REP_NUM];
-} ZSTD_optimal_t;
-
-typedef struct {
-    U32* litFreq;
-    U32* litLengthFreq;
-    U32* matchLengthFreq;
-    U32* offCodeFreq;
-    ZSTD_match_t* matchTable;
-    ZSTD_optimal_t* priceTable;
-
-    U32  matchLengthSum;
-    U32  matchSum;
-    U32  litLengthSum;
-    U32  litSum;
-    U32  offCodeSum;
-    U32  log2matchLengthSum;
-    U32  log2matchSum;
-    U32  log2litLengthSum;
-    U32  log2litSum;
-    U32  log2offCodeSum;
-    U32  factor;
-    U32  staticPrices;
-    U32  cachedPrice;
-    U32  cachedLitLength;
-    const BYTE* cachedLiterals;
-} optState_t;
-
-typedef struct {
-    U32 offset;
-    U32 checksum;
-} ldmEntry_t;
-
-typedef struct {
-    ldmEntry_t* hashTable;
-    BYTE* bucketOffsets;    /* Next position in bucket to insert entry */
-    U64 hashPower;          /* Used to compute the rolling hash.
-                             * Depends on ldmParams.minMatchLength */
-} ldmState_t;
-
-typedef struct {
-    U32 enableLdm;          /* 1 if enable long distance matching */
-    U32 hashLog;            /* Log size of hashTable */
-    U32 bucketSizeLog;      /* Log bucket size for collision resolution, at most 8 */
-    U32 minMatchLength;     /* Minimum match length */
-    U32 hashEveryLog;       /* Log number of entries to skip */
-} ldmParams_t;
-
-typedef struct {
-    U32 hufCTable[HUF_CTABLE_SIZE_U32(255)];
-    FSE_CTable offcodeCTable[FSE_CTABLE_SIZE_U32(OffFSELog, MaxOff)];
-    FSE_CTable matchlengthCTable[FSE_CTABLE_SIZE_U32(MLFSELog, MaxML)];
-    FSE_CTable litlengthCTable[FSE_CTABLE_SIZE_U32(LLFSELog, MaxLL)];
-    U32 workspace[HUF_WORKSPACE_SIZE_U32];
-    HUF_repeat hufCTable_repeatMode;
-    FSE_repeat offcode_repeatMode;
-    FSE_repeat matchlength_repeatMode;
-    FSE_repeat litlength_repeatMode;
-} ZSTD_entropyCTables_t;
-
-struct ZSTD_CCtx_params_s {
-    ZSTD_format_e format;
-    ZSTD_compressionParameters cParams;
-    ZSTD_frameParameters fParams;
-
-    int compressionLevel;
-    U32 forceWindow;           /* force back-references to respect limit of
-                                * 1<<wLog, even for dictionary */
-
-    /* Multithreading: used to pass parameters to mtctx */
-    U32 nbThreads;
-    unsigned jobSize;
-    unsigned overlapSizeLog;
-
-    /* Long distance matching parameters */
-    ldmParams_t ldmParams;
-
-    /* For use with createCCtxParams() and freeCCtxParams() only */
-    ZSTD_customMem customMem;
-
-};  /* typedef'd to ZSTD_CCtx_params within "zstd.h" */
-
-const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx);
-void ZSTD_seqToCodes(const seqStore_t* seqStorePtr);
+const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx);   /* compress & dictBuilder */
+void ZSTD_seqToCodes(const seqStore_t* seqStorePtr);   /* compress, dictBuilder, decodeCorpus (shouldn't get its definition from here) */
 
 /* custom memory allocation functions */
 void* ZSTD_malloc(size_t size, ZSTD_customMem customMem);
@@ -317,9 +226,7 @@ void* ZSTD_calloc(size_t size, ZSTD_customMem customMem);
 void ZSTD_free(void* ptr, ZSTD_customMem customMem);
 
 
-/*======  common function  ======*/
-
-MEM_STATIC U32 ZSTD_highbit32(U32 val)
+MEM_STATIC U32 ZSTD_highbit32(U32 val)   /* compress, dictBuilder, decodeCorpus */
 {
     assert(val != 0);
     {
@@ -345,52 +252,13 @@ MEM_STATIC U32 ZSTD_highbit32(U32 val)
 }
 
 
-/* hidden functions */
-
 /* ZSTD_invalidateRepCodes() :
  * ensures next compression will not use repcodes from previous block.
  * Note : only works with regular variant;
  *        do not use with extDict variant ! */
-void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx);
+void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx);   /* zstdmt, adaptive_compression (shouldn't get this definition from here) */
 
 
-/*! ZSTD_initCStream_internal() :
- *  Private use only. Init streaming operation.
- *  expects params to be valid.
- *  must receive dict, or cdict, or none, but not both.
- *  @return : 0, or an error code */
-size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
-                     const void* dict, size_t dictSize,
-                     const ZSTD_CDict* cdict,
-                     ZSTD_CCtx_params  params, unsigned long long pledgedSrcSize);
-
-/*! ZSTD_compressStream_generic() :
- *  Private use only. To be called from zstdmt_compress.c in single-thread mode. */
-size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
-                                   ZSTD_outBuffer* output,
-                                   ZSTD_inBuffer* input,
-                                   ZSTD_EndDirective const flushMode);
-
-/*! ZSTD_getCParamsFromCDict() :
- *  as the name implies */
-ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict);
-
-/* ZSTD_compressBegin_advanced_internal() :
- * Private use only. To be called from zstdmt_compress.c. */
-size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
-                                    const void* dict, size_t dictSize,
-                                    ZSTD_dictMode_e dictMode,
-                                    ZSTD_CCtx_params params,
-                                    unsigned long long pledgedSrcSize);
-
-/* ZSTD_compress_advanced_internal() :
- * Private use only. To be called from zstdmt_compress.c. */
-size_t ZSTD_compress_advanced_internal(ZSTD_CCtx* cctx,
-                                       void* dst, size_t dstCapacity,
-                                 const void* src, size_t srcSize,
-                                 const void* dict,size_t dictSize,
-                                 ZSTD_CCtx_params params);
-
 typedef struct {
     blockType_e blockType;
     U32 lastBlock;
@@ -398,7 +266,8 @@ typedef struct {
 } blockProperties_t;
 
 /*! ZSTD_getcBlockSize() :
-*   Provides the size of compressed block from block header `src` */
+*   Provides the size of compressed block from block header `src`
+*   Used by: decompress, fullbench (does not get its definition from here) */
 size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
                           blockProperties_t* bpPtr);
 
diff --git a/lib/compress/zstd_compress.h b/lib/compress/zstd_compress.h
index fe98da78d..bb508795d 100644
--- a/lib/compress/zstd_compress.h
+++ b/lib/compress/zstd_compress.h
@@ -8,6 +8,9 @@
  * You may select, at your option, one of the above-listed licenses.
  */
 
+/* This header contains definitions
+ * that shall only be used by modules from within lib/compress.
+ */
 
 #ifndef ZSTD_COMPRESS_H
 #define ZSTD_COMPRESS_H
@@ -43,6 +46,98 @@ typedef struct ZSTD_prefixDict_s {
     ZSTD_dictMode_e dictMode;
 } ZSTD_prefixDict;
 
+typedef struct {
+    U32 hufCTable[HUF_CTABLE_SIZE_U32(255)];
+    FSE_CTable offcodeCTable[FSE_CTABLE_SIZE_U32(OffFSELog, MaxOff)];
+    FSE_CTable matchlengthCTable[FSE_CTABLE_SIZE_U32(MLFSELog, MaxML)];
+    FSE_CTable litlengthCTable[FSE_CTABLE_SIZE_U32(LLFSELog, MaxLL)];
+    U32 workspace[HUF_WORKSPACE_SIZE_U32];
+    HUF_repeat hufCTable_repeatMode;
+    FSE_repeat offcode_repeatMode;
+    FSE_repeat matchlength_repeatMode;
+    FSE_repeat litlength_repeatMode;
+} ZSTD_entropyCTables_t;
+
+typedef struct {
+    U32 off;
+    U32 len;
+} ZSTD_match_t;
+
+typedef struct {
+    U32 price;
+    U32 off;
+    U32 mlen;
+    U32 litlen;
+    U32 rep[ZSTD_REP_NUM];
+} ZSTD_optimal_t;
+
+typedef struct {
+    U32* litFreq;
+    U32* litLengthFreq;
+    U32* matchLengthFreq;
+    U32* offCodeFreq;
+    ZSTD_match_t* matchTable;
+    ZSTD_optimal_t* priceTable;
+
+    U32  matchLengthSum;
+    U32  matchSum;
+    U32  litLengthSum;
+    U32  litSum;
+    U32  offCodeSum;
+    U32  log2matchLengthSum;
+    U32  log2matchSum;
+    U32  log2litLengthSum;
+    U32  log2litSum;
+    U32  log2offCodeSum;
+    U32  factor;
+    U32  staticPrices;
+    U32  cachedPrice;
+    U32  cachedLitLength;
+    const BYTE* cachedLiterals;
+} optState_t;
+
+typedef struct {
+    U32 offset;
+    U32 checksum;
+} ldmEntry_t;
+
+typedef struct {
+    ldmEntry_t* hashTable;
+    BYTE* bucketOffsets;    /* Next position in bucket to insert entry */
+    U64 hashPower;          /* Used to compute the rolling hash.
+                             * Depends on ldmParams.minMatchLength */
+} ldmState_t;
+
+typedef struct {
+    U32 enableLdm;          /* 1 if enable long distance matching */
+    U32 hashLog;            /* Log size of hashTable */
+    U32 bucketSizeLog;      /* Log bucket size for collision resolution, at most 8 */
+    U32 minMatchLength;     /* Minimum match length */
+    U32 hashEveryLog;       /* Log number of entries to skip */
+} ldmParams_t;
+
+struct ZSTD_CCtx_params_s {
+    ZSTD_format_e format;
+    ZSTD_compressionParameters cParams;
+    ZSTD_frameParameters fParams;
+
+    int compressionLevel;
+    U32 forceWindow;           /* force back-references to respect limit of
+                                * 1<<wLog, even for dictionary */
+
+    /* Multithreading: used to pass parameters to mtctx */
+    U32 nbThreads;
+    unsigned jobSize;
+    unsigned overlapSizeLog;
+
+    /* Long distance matching parameters */
+    ldmParams_t ldmParams;
+
+    /* For use with createCCtxParams() and freeCCtxParams() only */
+    ZSTD_customMem customMem;
+
+};  /* typedef'd to ZSTD_CCtx_params within "zstd.h" */
+
 struct ZSTD_CCtx_s {
     const BYTE* nextSrc;    /* next block here to continue on current prefix */
     const BYTE* base;       /* All regular indexes relative to this position */
@@ -118,9 +213,9 @@ static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11
                                   42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 };
 
 /*! ZSTD_storeSeq() :
-    Store a sequence (literal length, literals, offset code and match length code) into seqStore_t.
-    `offsetCode` : distance to match, or 0 == repCode.
-    `matchCode` : matchLength - MINMATCH
+ *  Store a sequence (literal length, literals, offset code and match length code) into seqStore_t.
+ *  `offsetCode` : distance to match + 3 (values 1-3 are repCodes).
+ *  `matchCode` : matchLength - MINMATCH
 */
 MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const void* literals, U32 offsetCode, size_t matchCode)
 {
@@ -139,6 +234,7 @@ MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const v
 
     /* literal Length */
     if (litLength>0xFFFF) {
+        assert(seqStorePtr->longLengthID == 0); /* there can only be a single long length */
         seqStorePtr->longLengthID = 1;
         seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
     }
@@ -149,6 +245,7 @@ MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const v
 
     /* match Length */
     if (matchCode>0xFFFF) {
+        assert(seqStorePtr->longLengthID == 0); /* there can only be a single long length */
         seqStorePtr->longLengthID = 2;
         seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
     }
@@ -304,4 +401,47 @@ MEM_STATIC size_t ZSTD_hashPtr(const void* p, U32 hBits, U32 mls)
 }
 #endif
 
+
+/* ==============================================================
+ * Private declarations
+ * These prototypes shall only be called from within lib/compress
+ * ============================================================== */
+
+/*! ZSTD_initCStream_internal() :
+ *  Private use only. Init streaming operation.
+ *  expects params to be valid.
+ *  must receive dict, or cdict, or none, but not both.
+ *  @return : 0, or an error code */
+size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
+                     const void* dict, size_t dictSize,
+                     const ZSTD_CDict* cdict,
+                     ZSTD_CCtx_params  params, unsigned long long pledgedSrcSize);
+
+/*! ZSTD_compressStream_generic() :
+ *  Private use only. To be called from zstdmt_compress.c in single-thread mode. */
+size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
+                                   ZSTD_outBuffer* output,
+                                   ZSTD_inBuffer* input,
+                                   ZSTD_EndDirective const flushMode);
+
+/*! ZSTD_getCParamsFromCDict() :
+ *  as the name implies */
+ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict);
+
+/* ZSTD_compressBegin_advanced_internal() :
+ * Private use only. To be called from zstdmt_compress.c. */
+size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
+                                    const void* dict, size_t dictSize,
+                                    ZSTD_dictMode_e dictMode,
+                                    ZSTD_CCtx_params params,
+                                    unsigned long long pledgedSrcSize);
+
+/* ZSTD_compress_advanced_internal() :
+ * Private use only. To be called from zstdmt_compress.c. */
+size_t ZSTD_compress_advanced_internal(ZSTD_CCtx* cctx,
+                                       void* dst, size_t dstCapacity,
+                                 const void* src, size_t srcSize,
+                                 const void* dict,size_t dictSize,
+                                 ZSTD_CCtx_params params);
+
 #endif /* ZSTD_COMPRESS_H */
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index c47ce23ad..e349bb993 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -25,19 +25,19 @@ static void ZSTD_setLog2Prices(optState_t* optPtr)
     optPtr->log2litLengthSum = ZSTD_highbit32(optPtr->litLengthSum+1);
     optPtr->log2litSum = ZSTD_highbit32(optPtr->litSum+1);
     optPtr->log2offCodeSum = ZSTD_highbit32(optPtr->offCodeSum+1);
-    optPtr->factor = 1 + ((optPtr->litSum>>5) / optPtr->litLengthSum) + ((optPtr->litSum<<1) / (optPtr->litSum + optPtr->matchSum));
+    optPtr->factor = 1 + ((optPtr->litSum>>5) / optPtr->litLengthSum)
+                       + ((optPtr->litSum<<1) / (optPtr->litSum + optPtr->matchSum));
 }
 
 
 static void ZSTD_rescaleFreqs(optState_t* optPtr, const BYTE* src, size_t srcSize)
 {
-    unsigned u;
-
     optPtr->cachedLiterals = NULL;
     optPtr->cachedPrice = optPtr->cachedLitLength = 0;
     optPtr->staticPrices = 0;
 
-    if (optPtr->litLengthSum == 0) {
+    if (optPtr->litLengthSum == 0) {  /* first init */
+        unsigned u;
         if (srcSize <= 1024) optPtr->staticPrices = 1;
 
         assert(optPtr->litFreq!=NULL);
@@ -50,10 +50,10 @@ static void ZSTD_rescaleFreqs(optState_t* optPtr, const BYTE* src, size_t srcSiz
         optPtr->litLengthSum = MaxLL+1;
         optPtr->matchLengthSum = MaxML+1;
         optPtr->offCodeSum = (MaxOff+1);
-        optPtr->matchSum = (ZSTD_LITFREQ_ADD<<Litbits);
+        optPtr->matchSum = (ZSTD_LITFREQ_ADD << Litbits);
 
         for (u=0; u<=MaxLit; u++) {
-            optPtr->litFreq[u] = 1 + (optPtr->litFreq[u]>>ZSTD_FREQ_DIV);
+            optPtr->litFreq[u] = 1 + (optPtr->litFreq[u] >> ZSTD_FREQ_DIV);
             optPtr->litSum += optPtr->litFreq[u];
         }
         for (u=0; u<=MaxLL; u++)
@@ -62,7 +62,10 @@ static void ZSTD_rescaleFreqs(optState_t* optPtr, const BYTE* src, size_t srcSiz
             optPtr->matchLengthFreq[u] = 1;
         for (u=0; u<=MaxOff; u++)
             optPtr->offCodeFreq[u] = 1;
+
     } else {
+
+        unsigned u;
         optPtr->matchLengthSum = 0;
         optPtr->litLengthSum = 0;
         optPtr->offCodeSum = 0;
diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c
index a855745be..eb17f9701 100644
--- a/lib/compress/zstdmt_compress.c
+++ b/lib/compress/zstdmt_compress.c
@@ -24,7 +24,7 @@
 #include <string.h>      /* memcpy, memset */
 #include "pool.h"        /* threadpool */
 #include "threading.h"   /* mutex */
-#include "zstd_internal.h"  /* MIN, ERROR, ZSTD_*, ZSTD_highbit32 */
+#include "zstd_compress.h"  /* MIN, ERROR, ZSTD_*, ZSTD_highbit32 */
 #include "zstdmt_compress.h"
 
 

From ee441d5d2b0334df0e164f9f8c2b095ef9c275f4 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 7 Nov 2017 16:15:23 -0800
Subject: [PATCH 038/145] renamed zstd_compress.h into zstd_compress_internal.h

to emphasize the fact that all definitions it contains
must remain private, accross lib/compress modules.
---
 lib/compress/zstd_compress.c                               | 2 +-
 lib/compress/{zstd_compress.h => zstd_compress_internal.h} | 2 +-
 lib/compress/zstd_double_fast.c                            | 1 +
 lib/compress/zstd_double_fast.h                            | 5 +++--
 lib/compress/zstd_fast.c                                   | 1 +
 lib/compress/zstd_fast.h                                   | 5 +++--
 lib/compress/zstd_lazy.c                                   | 1 +
 lib/compress/zstd_lazy.h                                   | 5 +++--
 lib/compress/zstd_ldm.h                                    | 5 +++--
 lib/compress/zstd_opt.c                                    | 3 ++-
 lib/compress/zstd_opt.h                                    | 4 ++--
 lib/compress/zstdmt_compress.c                             | 2 +-
 12 files changed, 22 insertions(+), 14 deletions(-)
 rename lib/compress/{zstd_compress.h => zstd_compress_internal.h} (99%)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 808418a60..a1162e3a4 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -26,7 +26,7 @@
 #include "fse.h"
 #define HUF_STATIC_LINKING_ONLY
 #include "huf.h"
-#include "zstd_compress.h"
+#include "zstd_compress_internal.h"
 #include "zstd_fast.h"
 #include "zstd_double_fast.h"
 #include "zstd_lazy.h"
diff --git a/lib/compress/zstd_compress.h b/lib/compress/zstd_compress_internal.h
similarity index 99%
rename from lib/compress/zstd_compress.h
rename to lib/compress/zstd_compress_internal.h
index bb508795d..e01d532cc 100644
--- a/lib/compress/zstd_compress.h
+++ b/lib/compress/zstd_compress_internal.h
@@ -9,7 +9,7 @@
  */
 
 /* This header contains definitions
- * that shall only be used by modules from within lib/compress.
+ * that shall **only** be used by modules within lib/compress.
  */
 
 #ifndef ZSTD_COMPRESS_H
diff --git a/lib/compress/zstd_double_fast.c b/lib/compress/zstd_double_fast.c
index 876a36042..fee5127c3 100644
--- a/lib/compress/zstd_double_fast.c
+++ b/lib/compress/zstd_double_fast.c
@@ -8,6 +8,7 @@
  * You may select, at your option, one of the above-listed licenses.
  */
 
+#include "zstd_compress_internal.h"
 #include "zstd_double_fast.h"
 
 
diff --git a/lib/compress/zstd_double_fast.h b/lib/compress/zstd_double_fast.h
index 3dba6c710..75e041580 100644
--- a/lib/compress/zstd_double_fast.h
+++ b/lib/compress/zstd_double_fast.h
@@ -11,12 +11,13 @@
 #ifndef ZSTD_DOUBLE_FAST_H
 #define ZSTD_DOUBLE_FAST_H
 
-#include "zstd_compress.h"
-
 #if defined (__cplusplus)
 extern "C" {
 #endif
 
+#include "mem.h"      /* U32 */
+#include "zstd.h"     /* ZSTD_CCtx, size_t */
+
 void ZSTD_fillDoubleHashTable(ZSTD_CCtx* cctx, const void* end, const U32 mls);
 size_t ZSTD_compressBlock_doubleFast(ZSTD_CCtx* ctx, const void* src, size_t srcSize);
 size_t ZSTD_compressBlock_doubleFast_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize);
diff --git a/lib/compress/zstd_fast.c b/lib/compress/zstd_fast.c
index 2e057017b..7b56c3d6a 100644
--- a/lib/compress/zstd_fast.c
+++ b/lib/compress/zstd_fast.c
@@ -8,6 +8,7 @@
  * You may select, at your option, one of the above-listed licenses.
  */
 
+#include "zstd_compress_internal.h"
 #include "zstd_fast.h"
 
 
diff --git a/lib/compress/zstd_fast.h b/lib/compress/zstd_fast.h
index 4205141a9..d8b777195 100644
--- a/lib/compress/zstd_fast.h
+++ b/lib/compress/zstd_fast.h
@@ -11,12 +11,13 @@
 #ifndef ZSTD_FAST_H
 #define ZSTD_FAST_H
 
-#include "zstd_compress.h"
-
 #if defined (__cplusplus)
 extern "C" {
 #endif
 
+#include "mem.h"      /* U32 */
+#include "zstd.h"     /* ZSTD_CCtx, size_t */
+
 void ZSTD_fillHashTable(ZSTD_CCtx* zc, const void* end, const U32 mls);
 size_t ZSTD_compressBlock_fast(ZSTD_CCtx* ctx,
                          const void* src, size_t srcSize);
diff --git a/lib/compress/zstd_lazy.c b/lib/compress/zstd_lazy.c
index 2a7f6a0fe..d80e06f7d 100644
--- a/lib/compress/zstd_lazy.c
+++ b/lib/compress/zstd_lazy.c
@@ -8,6 +8,7 @@
  * You may select, at your option, one of the above-listed licenses.
  */
 
+#include "zstd_compress_internal.h"
 #include "zstd_lazy.h"
 
 
diff --git a/lib/compress/zstd_lazy.h b/lib/compress/zstd_lazy.h
index a9c4daed2..74e1fd697 100644
--- a/lib/compress/zstd_lazy.h
+++ b/lib/compress/zstd_lazy.h
@@ -11,12 +11,13 @@
 #ifndef ZSTD_LAZY_H
 #define ZSTD_LAZY_H
 
-#include "zstd_compress.h"
-
 #if defined (__cplusplus)
 extern "C" {
 #endif
 
+#include "mem.h"    /* U32 */
+#include "zstd.h"   /* ZSTD_CCtx, size_t */
+
 U32 ZSTD_insertAndFindFirstIndex (ZSTD_CCtx* zc, const BYTE* ip, U32 mls);
 void ZSTD_updateTree(ZSTD_CCtx* zc, const BYTE* const ip, const BYTE* const iend, const U32 nbCompares, const U32 mls);
 void ZSTD_updateTree_extDict(ZSTD_CCtx* zc, const BYTE* const ip, const BYTE* const iend, const U32 nbCompares, const U32 mls);
diff --git a/lib/compress/zstd_ldm.h b/lib/compress/zstd_ldm.h
index d6d3d42c3..8f12c677a 100644
--- a/lib/compress/zstd_ldm.h
+++ b/lib/compress/zstd_ldm.h
@@ -10,12 +10,13 @@
 #ifndef ZSTD_LDM_H
 #define ZSTD_LDM_H
 
-#include "zstd_compress.h"
-
 #if defined (__cplusplus)
 extern "C" {
 #endif
 
+#include "zstd_compress_internal.h"   /* ldmParams_t, U32 */
+#include "zstd.h"   /* ZSTD_CCtx, size_t */
+
 /*-*************************************
 *  Long distance matching
 ***************************************/
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index e349bb993..f416c15ff 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -8,8 +8,9 @@
  * You may select, at your option, one of the above-listed licenses.
  */
 
+#include "zstd_compress_internal.h"
 #include "zstd_opt.h"
-#include "zstd_lazy.h"
+#include "zstd_lazy.h"   /* ZSTD_updateTree, ZSTD_updateTree_extDict */
 
 
 #define ZSTD_LITFREQ_ADD    2
diff --git a/lib/compress/zstd_opt.h b/lib/compress/zstd_opt.h
index 816a1fabb..82e810c29 100644
--- a/lib/compress/zstd_opt.h
+++ b/lib/compress/zstd_opt.h
@@ -11,12 +11,12 @@
 #ifndef ZSTD_OPT_H
 #define ZSTD_OPT_H
 
-#include "zstd_compress.h"
-
 #if defined (__cplusplus)
 extern "C" {
 #endif
 
+#include "zstd.h"   /* ZSTD_CCtx, size_t */
+
 size_t ZSTD_compressBlock_btopt(ZSTD_CCtx* ctx, const void* src, size_t srcSize);
 size_t ZSTD_compressBlock_btultra(ZSTD_CCtx* ctx, const void* src, size_t srcSize);
 
diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c
index eb17f9701..0b9173f3b 100644
--- a/lib/compress/zstdmt_compress.c
+++ b/lib/compress/zstdmt_compress.c
@@ -24,7 +24,7 @@
 #include <string.h>      /* memcpy, memset */
 #include "pool.h"        /* threadpool */
 #include "threading.h"   /* mutex */
-#include "zstd_compress.h"  /* MIN, ERROR, ZSTD_*, ZSTD_highbit32 */
+#include "zstd_compress_internal.h"  /* MIN, ERROR, ZSTD_*, ZSTD_highbit32 */
 #include "zstdmt_compress.h"
 
 

From 4191efa993894bf98336a9500c6615768093663b Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 8 Nov 2017 11:05:32 -0800
Subject: [PATCH 039/145] zstd_opt: ensure sufficient_len < ZSTD_OPT_NUM to
 simplify some tests

---
 lib/common/zstd_internal.h            |  40 +++++----
 lib/compress/zstd_compress_internal.h |  25 +++---
 lib/compress/zstd_opt.c               | 113 +++++++++++++-------------
 3 files changed, 96 insertions(+), 82 deletions(-)

diff --git a/lib/common/zstd_internal.h b/lib/common/zstd_internal.h
index 0fb8e49da..218cbc204 100644
--- a/lib/common/zstd_internal.h
+++ b/lib/common/zstd_internal.h
@@ -138,28 +138,40 @@ typedef enum { set_basic, set_rle, set_compressed, set_repeat } symbolEncodingTy
 #define LLFSELog    9
 #define OffFSELog   8
 
-static const U32 LL_bits[MaxLL+1] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                      1, 1, 1, 1, 2, 2, 3, 3, 4, 6, 7, 8, 9,10,11,12,
+static const U32 LL_bits[MaxLL+1] = { 0, 0, 0, 0, 0, 0, 0, 0,
+                                      0, 0, 0, 0, 0, 0, 0, 0,
+                                      1, 1, 1, 1, 2, 2, 3, 3,
+                                      4, 6, 7, 8, 9,10,11,12,
                                      13,14,15,16 };
-static const S16 LL_defaultNorm[MaxLL+1] = { 4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1,
-                                             2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 1, 1, 1, 1, 1,
+static const S16 LL_defaultNorm[MaxLL+1] = { 4, 3, 2, 2, 2, 2, 2, 2,
+                                             2, 2, 2, 2, 2, 1, 1, 1,
+                                             2, 2, 2, 2, 2, 2, 2, 2,
+                                             2, 3, 2, 1, 1, 1, 1, 1,
                                             -1,-1,-1,-1 };
 #define LL_DEFAULTNORMLOG 6  /* for static allocation */
 static const U32 LL_defaultNormLog = LL_DEFAULTNORMLOG;
 
-static const U32 ML_bits[MaxML+1] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                      1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 7, 8, 9,10,11,
+static const U32 ML_bits[MaxML+1] = { 0, 0, 0, 0, 0, 0, 0, 0,
+                                      0, 0, 0, 0, 0, 0, 0, 0,
+                                      0, 0, 0, 0, 0, 0, 0, 0,
+                                      0, 0, 0, 0, 0, 0, 0, 0,
+                                      1, 1, 1, 1, 2, 2, 3, 3,
+                                      4, 4, 5, 7, 8, 9,10,11,
                                      12,13,14,15,16 };
-static const S16 ML_defaultNorm[MaxML+1] = { 1, 4, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
-                                             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-                                             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,-1,-1,
+static const S16 ML_defaultNorm[MaxML+1] = { 1, 4, 3, 2, 2, 2, 2, 2,
+                                             2, 1, 1, 1, 1, 1, 1, 1,
+                                             1, 1, 1, 1, 1, 1, 1, 1,
+                                             1, 1, 1, 1, 1, 1, 1, 1,
+                                             1, 1, 1, 1, 1, 1, 1, 1,
+                                             1, 1, 1, 1, 1, 1,-1,-1,
                                             -1,-1,-1,-1,-1 };
 #define ML_DEFAULTNORMLOG 6  /* for static allocation */
 static const U32 ML_defaultNormLog = ML_DEFAULTNORMLOG;
 
-static const S16 OF_defaultNorm[DefaultMaxOff+1] = { 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
-                                                     1, 1, 1, 1, 1, 1, 1, 1,-1,-1,-1,-1,-1 };
+static const S16 OF_defaultNorm[DefaultMaxOff+1] = { 1, 1, 1, 1, 1, 1, 2, 2,
+                                                     2, 1, 1, 1, 1, 1, 1, 1,
+                                                     1, 1, 1, 1, 1, 1, 1, 1,
+                                                    -1,-1,-1,-1,-1 };
 #define OF_DEFAULTNORMLOG 5  /* for static allocation */
 static const U32 OF_defaultNormLog = OF_DEFAULTNORMLOG;
 
@@ -266,8 +278,8 @@ typedef struct {
 } blockProperties_t;
 
 /*! ZSTD_getcBlockSize() :
-*   Provides the size of compressed block from block header `src`
-*   Used by: decompress, fullbench (does not get its definition from here) */
+ *  Provides the size of compressed block from block header `src` */
+/* Used by: decompress, fullbench (does not get its definition from here) */
 size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
                           blockProperties_t* bpPtr);
 
diff --git a/lib/compress/zstd_compress_internal.h b/lib/compress/zstd_compress_internal.h
index e01d532cc..4f4697682 100644
--- a/lib/compress/zstd_compress_internal.h
+++ b/lib/compress/zstd_compress_internal.h
@@ -79,18 +79,19 @@ typedef struct {
     ZSTD_match_t* matchTable;
     ZSTD_optimal_t* priceTable;
 
-    U32  matchLengthSum;
-    U32  matchSum;
-    U32  litLengthSum;
-    U32  litSum;
-    U32  offCodeSum;
-    U32  log2matchLengthSum;
-    U32  log2matchSum;
-    U32  log2litLengthSum;
-    U32  log2litSum;
-    U32  log2offCodeSum;
-    U32  factor;
-    U32  staticPrices;
+    U32  litSum;                 /* nb of literals */
+    U32  litLengthSum;           /* nb of litLength codes */
+    U32  matchLengthSum;         /* nb of matchLength codes */
+    U32  matchSum;               /* one argument to calculate `factor` */
+    U32  offCodeSum;             /* nb of offset codes */
+    /* begin updated by ZSTD_setLog2Prices */
+    U32  log2litSum;             /* pow2 to compare log2(litfreq) to */
+    U32  log2litLengthSum;       /* pow2 to compare log2(llfreq) to */
+    U32  log2matchLengthSum;     /* pow2 to compare log2(mlfreq) to */
+    U32  log2offCodeSum;         /* pow2 to compare log2(offreq) to */
+    U32  factor;                 /* added to calculate ZSTD_getPrice() (but why?) */
+    /* end : updated by ZSTD_setLog2Prices */
+    U32  staticPrices;           /* ? do not update statistics ? */
     U32  cachedPrice;
     U32  cachedLitLength;
     const BYTE* cachedLiterals;
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index f416c15ff..d0104eeda 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -13,21 +13,21 @@
 #include "zstd_lazy.h"   /* ZSTD_updateTree, ZSTD_updateTree_extDict */
 
 
-#define ZSTD_LITFREQ_ADD    2
-#define ZSTD_FREQ_DIV       4
-#define ZSTD_MAX_PRICE      (1<<30)
+#define ZSTD_LITFREQ_ADD    2   /* sort of scaling factor for litSum and litFreq (why the need ?), but also used for matchSum ? */
+#define ZSTD_FREQ_DIV       4   /* log factor when using previous stats to init next stats */
+#define ZSTD_MAX_PRICE     (1<<30)
 
 /*-*************************************
 *  Price functions for optimal parser
 ***************************************/
 static void ZSTD_setLog2Prices(optState_t* optPtr)
 {
-    optPtr->log2matchLengthSum = ZSTD_highbit32(optPtr->matchLengthSum+1);
-    optPtr->log2litLengthSum = ZSTD_highbit32(optPtr->litLengthSum+1);
     optPtr->log2litSum = ZSTD_highbit32(optPtr->litSum+1);
+    optPtr->log2litLengthSum = ZSTD_highbit32(optPtr->litLengthSum+1);
+    optPtr->log2matchLengthSum = ZSTD_highbit32(optPtr->matchLengthSum+1);
     optPtr->log2offCodeSum = ZSTD_highbit32(optPtr->offCodeSum+1);
     optPtr->factor = 1 + ((optPtr->litSum>>5) / optPtr->litLengthSum)
-                       + ((optPtr->litSum<<1) / (optPtr->litSum + optPtr->matchSum));
+                       + ((optPtr->litSum<<1) / (optPtr->litSum + optPtr->matchSum));  /* => {0,1}, == (optPtr->matchSum <= optPtr->litSum) */
 }
 
 
@@ -46,47 +46,45 @@ static void ZSTD_rescaleFreqs(optState_t* optPtr, const BYTE* src, size_t srcSiz
             optPtr->litFreq[u] = 0;
         for (u=0; u<srcSize; u++)
             optPtr->litFreq[src[u]]++;
-
         optPtr->litSum = 0;
-        optPtr->litLengthSum = MaxLL+1;
-        optPtr->matchLengthSum = MaxML+1;
-        optPtr->offCodeSum = (MaxOff+1);
-        optPtr->matchSum = (ZSTD_LITFREQ_ADD << Litbits);
-
         for (u=0; u<=MaxLit; u++) {
             optPtr->litFreq[u] = 1 + (optPtr->litFreq[u] >> ZSTD_FREQ_DIV);
             optPtr->litSum += optPtr->litFreq[u];
         }
+
         for (u=0; u<=MaxLL; u++)
             optPtr->litLengthFreq[u] = 1;
+        optPtr->litLengthSum = MaxLL+1;
         for (u=0; u<=MaxML; u++)
             optPtr->matchLengthFreq[u] = 1;
+        optPtr->matchLengthSum = MaxML+1;
+        optPtr->matchSum = (ZSTD_LITFREQ_ADD << Litbits);
         for (u=0; u<=MaxOff; u++)
             optPtr->offCodeFreq[u] = 1;
+        optPtr->offCodeSum = (MaxOff+1);
 
     } else {
-
         unsigned u;
-        optPtr->matchLengthSum = 0;
-        optPtr->litLengthSum = 0;
-        optPtr->offCodeSum = 0;
-        optPtr->matchSum = 0;
-        optPtr->litSum = 0;
 
+        optPtr->litSum = 0;
         for (u=0; u<=MaxLit; u++) {
-            optPtr->litFreq[u] = 1 + (optPtr->litFreq[u]>>(ZSTD_FREQ_DIV+1));
+            optPtr->litFreq[u] = 1 + (optPtr->litFreq[u] >> (ZSTD_FREQ_DIV+1));
             optPtr->litSum += optPtr->litFreq[u];
         }
+        optPtr->litLengthSum = 0;
         for (u=0; u<=MaxLL; u++) {
             optPtr->litLengthFreq[u] = 1 + (optPtr->litLengthFreq[u]>>(ZSTD_FREQ_DIV+1));
             optPtr->litLengthSum += optPtr->litLengthFreq[u];
         }
+        optPtr->matchLengthSum = 0;
+        optPtr->matchSum = 0;
         for (u=0; u<=MaxML; u++) {
             optPtr->matchLengthFreq[u] = 1 + (optPtr->matchLengthFreq[u]>>ZSTD_FREQ_DIV);
             optPtr->matchLengthSum += optPtr->matchLengthFreq[u];
             optPtr->matchSum += optPtr->matchLengthFreq[u] * (u + 3);
         }
         optPtr->matchSum *= ZSTD_LITFREQ_ADD;
+        optPtr->offCodeSum = 0;
         for (u=0; u<=MaxOff; u++) {
             optPtr->offCodeFreq[u] = 1 + (optPtr->offCodeFreq[u]>>ZSTD_FREQ_DIV);
             optPtr->offCodeSum += optPtr->offCodeFreq[u];
@@ -99,24 +97,26 @@ static void ZSTD_rescaleFreqs(optState_t* optPtr, const BYTE* src, size_t srcSiz
 
 static U32 ZSTD_getLiteralPrice(optState_t* optPtr, U32 litLength, const BYTE* literals)
 {
-    U32 price, u;
+    U32 price;
 
     if (optPtr->staticPrices)
-        return ZSTD_highbit32((U32)litLength+1) + (litLength*6);
+        return ZSTD_highbit32((U32)litLength+1) + (litLength*6);  /* 6 bit per literal - no real estimation */
 
     if (litLength == 0)
         return optPtr->log2litLengthSum - ZSTD_highbit32(optPtr->litLengthFreq[0]+1);
 
     /* literals */
     if (optPtr->cachedLiterals == literals) {
+        U32 u;
         U32 const additional = litLength - optPtr->cachedLitLength;
-        const BYTE* literals2 = optPtr->cachedLiterals + optPtr->cachedLitLength;
+        const BYTE* const literals2 = optPtr->cachedLiterals + optPtr->cachedLitLength;
         price = optPtr->cachedPrice + additional * optPtr->log2litSum;
         for (u=0; u < additional; u++)
             price -= ZSTD_highbit32(optPtr->litFreq[literals2[u]]+1);
         optPtr->cachedPrice = price;
         optPtr->cachedLitLength = litLength;
     } else {
+        U32 u;
         price = litLength * optPtr->log2litSum;
         for (u=0; u < litLength; u++)
             price -= ZSTD_highbit32(optPtr->litFreq[literals[u]]+1);
@@ -129,8 +129,8 @@ static U32 ZSTD_getLiteralPrice(optState_t* optPtr, U32 litLength, const BYTE* l
     }
 
     /* literal Length */
-    {   const BYTE LL_deltaCode = 19;
-        const BYTE llCode = (litLength>63) ? (BYTE)ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength];
+    {   BYTE const LL_deltaCode = 19;
+        BYTE const llCode = (litLength>63) ? (BYTE)ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength];
         price += LL_bits[llCode] + optPtr->log2litLengthSum - ZSTD_highbit32(optPtr->litLengthFreq[llCode]+1);
     }
 
@@ -148,11 +148,11 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr, U32 litLength, const
         return ZSTD_getLiteralPrice(optPtr, litLength, literals) + ZSTD_highbit32((U32)matchLength+1) + 16 + offCode;
 
     price = offCode + optPtr->log2offCodeSum - ZSTD_highbit32(optPtr->offCodeFreq[offCode]+1);
-    if (!ultra && offCode >= 20) price += (offCode-19)*2;
+    if (!ultra && offCode >= 20) price += (offCode-19)*2; /* handicap for long matches, to favor decompression speed */
 
     /* match Length */
-    {   const BYTE ML_deltaCode = 36;
-        const BYTE mlCode = (matchLength>127) ? (BYTE)ZSTD_highbit32(matchLength) + ML_deltaCode : ML_Code[matchLength];
+    {   BYTE const ML_deltaCode = 36;
+        BYTE const mlCode = (matchLength>127) ? (BYTE)ZSTD_highbit32(matchLength) + ML_deltaCode : ML_Code[matchLength];
         price += ML_bits[mlCode] + optPtr->log2matchLengthSum - ZSTD_highbit32(optPtr->matchLengthFreq[mlCode]+1);
     }
 
@@ -193,13 +193,14 @@ static void ZSTD_updatePrice(optState_t* optPtr, U32 litLength, const BYTE* lite
 }
 
 
+/* update opt[pos] and last_pos */
 #define SET_PRICE(pos, mlen_, offset_, litlen_, price_)   \
-    {                                                 \
+    {                                                     \
         while (last_pos < pos)  { opt[last_pos+1].price = ZSTD_MAX_PRICE; last_pos++; } \
-        opt[pos].mlen = mlen_;                         \
-        opt[pos].off = offset_;                        \
-        opt[pos].litlen = litlen_;                     \
-        opt[pos].price = price_;                       \
+        opt[pos].mlen = mlen_;                            \
+        opt[pos].off = offset_;                           \
+        opt[pos].litlen = litlen_;                        \
+        opt[pos].price = price_;                          \
     }
 
 
@@ -220,15 +221,14 @@ static U32 ZSTD_readMINMATCH(const void* memPtr, U32 length)
 
 /* Update hashTable3 up to ip (excluded)
    Assumption : always within prefix (i.e. not within extDict) */
-static
-U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* zc, const BYTE* ip)
+static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* zc, const BYTE* ip)
 {
     U32* const hashTable3  = zc->hashTable3;
     U32 const hashLog3  = zc->hashLog3;
     const BYTE* const base = zc->base;
     U32 idx = zc->nextToUpdate3;
-    const U32 target = zc->nextToUpdate3 = (U32)(ip - base);
-    const size_t hash3 = ZSTD_hash3Ptr(ip, hashLog3);
+    U32 const target = zc->nextToUpdate3 = (U32)(ip - base);
+    size_t const hash3 = ZSTD_hash3Ptr(ip, hashLog3);
 
     while(idx < target) {
         hashTable3[ZSTD_hash3Ptr(base+idx, hashLog3)] = idx;
@@ -427,15 +427,14 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
     const BYTE* const base = ctx->base;
     const BYTE* const prefixStart = base + ctx->dictLimit;
 
-    const U32 maxSearches = 1U << ctx->appliedParams.cParams.searchLog;
-    const U32 sufficient_len = ctx->appliedParams.cParams.targetLength;
-    const U32 mls = ctx->appliedParams.cParams.searchLength;
-    const U32 minMatch = (ctx->appliedParams.cParams.searchLength == 3) ? 3 : 4;
+    U32 const maxSearches = 1U << ctx->appliedParams.cParams.searchLog;
+    U32 const sufficient_len = MIN(ctx->appliedParams.cParams.targetLength, ZSTD_OPT_NUM -1);
+    U32 const mls = ctx->appliedParams.cParams.searchLength;
+    U32 const minMatch = (ctx->appliedParams.cParams.searchLength == 3) ? 3 : 4;
 
-    ZSTD_optimal_t* opt = optStatePtr->priceTable;
-    ZSTD_match_t* matches = optStatePtr->matchTable;
-    const BYTE* inr;
-    U32 offset, rep[ZSTD_REP_NUM];
+    ZSTD_optimal_t* const opt = optStatePtr->priceTable;
+    ZSTD_match_t* const matches = optStatePtr->matchTable;
+    U32 rep[ZSTD_REP_NUM];
 
     /* init */
     ctx->nextToUpdate3 = ctx->nextToUpdate;
@@ -446,19 +445,20 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
     /* Match Loop */
     while (ip < ilimit) {
         U32 cur, match_num, last_pos, litlen, price;
-        U32 u, mlen, best_mlen, best_off, litLength;
+        U32 u, mlen, best_mlen, best_off, litLength, offset;
         memset(opt, 0, sizeof(ZSTD_optimal_t));
         last_pos = 0;
         litlen = (U32)(ip - anchor);
 
         /* check repCode */
         {   U32 i, last_i = ZSTD_REP_CHECK + (ip==anchor);
-            for (i=(ip == anchor); i<last_i; i++) {
-                const S32 repCur = (i==ZSTD_REP_MOVE_OPT) ? (rep[0] - 1) : rep[i];
-                if ( (repCur > 0) && (repCur < (S32)(ip-prefixStart))
-                    && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repCur, minMatch))) {
+            for (i = (ip==anchor); i < last_i; i++) {
+                S32 const repCur = (i==ZSTD_REP_MOVE_OPT) ? (rep[0] - 1) : rep[i];
+                if ( (repCur > 0)
+                  && (repCur < (S32)(ip-prefixStart))  /* only check within current mem segment */
+                  && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repCur, minMatch))) {
                     mlen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repCur, iend) + minMatch;
-                    if (mlen > sufficient_len || mlen >= ZSTD_OPT_NUM) {
+                    if (mlen > sufficient_len) {
                         best_mlen = mlen; best_off = i; cur = 0; last_pos = 1;
                         goto _storeSequence;
                     }
@@ -475,7 +475,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
 
         if (!last_pos && !match_num) { ip++; continue; }
 
-        if (match_num && (matches[match_num-1].len > sufficient_len || matches[match_num-1].len >= ZSTD_OPT_NUM)) {
+        if (match_num && (matches[match_num-1].len > sufficient_len)) {
             best_mlen = matches[match_num-1].len;
             best_off = matches[match_num-1].off;
             cur = 0;
@@ -504,7 +504,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
 
          /* check further positions */
         for (cur = 1; cur <= last_pos; cur++) {
-           inr = ip + cur;
+           const BYTE* const inr = ip + cur;
 
            if (opt[cur-1].mlen == 1) {
                 litlen = opt[cur-1].litlen + 1;
@@ -518,7 +518,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
            }
 
            if (cur > last_pos || price <= opt[cur].price)
-                SET_PRICE(cur, 1, 0, litlen, price);
+                SET_PRICE(cur, 1, 0, litlen, price);  /* note : macro modifies last_pos */
 
            if (cur == last_pos) break;
 
@@ -572,7 +572,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                             }
 
                             if (cur + mlen > last_pos || price <= opt[cur + mlen].price)
-                                SET_PRICE(cur + mlen, mlen, i, litlen, price);
+                                SET_PRICE(cur + mlen, mlen, i, litlen, price);  /* note : macro modifies last_pos */
                             mlen--;
                         } while (mlen >= minMatch);
             }   }   }
@@ -604,7 +604,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                     }
 
                     if (cur + mlen > last_pos || (price < opt[cur + mlen].price))
-                        SET_PRICE(cur + mlen, mlen, matches[u].off, litlen, price);
+                        SET_PRICE(cur + mlen, mlen, matches[u].off, litlen, price);  /* note : macro modifies last_pos */
 
                     mlen++;
         }   }   }
@@ -657,7 +657,8 @@ _storeSequence:   /* cur, last_pos, best_mlen, best_off have to be set */
             ZSTD_updatePrice(optStatePtr, litLength, anchor, offset, mlen-MINMATCH);
             ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
             anchor = ip = ip + mlen;
-    }    }   /* for (cur=0; cur < last_pos; ) */
+        }
+    }   /* for (cur=0; cur < last_pos; ) */
 
     /* Save reps for next block */
     { int i; for (i=0; i<ZSTD_REP_NUM; i++) seqStorePtr->repToConfirm[i] = rep[i]; }

From bf730e20440766fa945b84431084701e004e106e Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 8 Nov 2017 11:36:38 -0800
Subject: [PATCH 040/145] zstd_opt: refactor code for improved readability

renamed variables to be more meaningful
reduced scope of multiple variables
removed some useless var attribution
---
 lib/compress/zstd_opt.c | 63 +++++++++++++++++++++--------------------
 1 file changed, 33 insertions(+), 30 deletions(-)

diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index d0104eeda..f333a5063 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -440,42 +440,44 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
     ctx->nextToUpdate3 = ctx->nextToUpdate;
     ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize);
     ip += (ip==prefixStart);
-    { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) rep[i]=seqStorePtr->rep[i]; }
+    { int i; for (i=0; i<ZSTD_REP_NUM; i++) rep[i]=seqStorePtr->rep[i]; }
 
     /* Match Loop */
     while (ip < ilimit) {
-        U32 cur, match_num, last_pos, litlen, price;
+        U32 cur, match_num, last_pos = 0, litlen, price;
         U32 u, mlen, best_mlen, best_off, litLength, offset;
         memset(opt, 0, sizeof(ZSTD_optimal_t));
-        last_pos = 0;
         litlen = (U32)(ip - anchor);
 
         /* check repCode */
-        {   U32 i, last_i = ZSTD_REP_CHECK + (ip==anchor);
-            for (i = (ip==anchor); i < last_i; i++) {
-                S32 const repCur = (i==ZSTD_REP_MOVE_OPT) ? (rep[0] - 1) : rep[i];
-                if ( (repCur > 0)
-                  && (repCur < (S32)(ip-prefixStart))  /* only check within current mem segment */
-                  && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repCur, minMatch))) {
-                    mlen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repCur, iend) + minMatch;
-                    if (mlen > sufficient_len) {
-                        best_mlen = mlen; best_off = i; cur = 0; last_pos = 1;
+        {   U32 const ll0 = (ip==anchor);
+            U32 const lastR = ZSTD_REP_CHECK + ll0;
+            U32 repCode;
+            for (repCode = ll0; repCode < lastR; repCode++) {
+                S32 const repOffset = (repCode==ZSTD_REP_MOVE_OPT) ? (rep[0] - 1) : rep[repCode];
+                if ( (repOffset > 0)
+                  && (repOffset < (S32)(ip-prefixStart))  /* only check within current mem segment */
+                  && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repOffset, minMatch))) {
+                    U32 repLen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repOffset, iend) + minMatch;
+                    if (repLen > sufficient_len) {
+                        /* large repMatch => immediate encoding */
+                        best_mlen = repLen; best_off = repCode; cur = 0; last_pos = 1;
                         goto _storeSequence;
                     }
-                    best_off = i - (ip == anchor);
                     do {
-                        price = ZSTD_getPrice(optStatePtr, litlen, anchor, best_off, mlen - MINMATCH, ultra);
-                        if (mlen > last_pos || price < opt[mlen].price)
-                            SET_PRICE(mlen, mlen, i, litlen, price);   /* note : macro modifies last_pos */
-                        mlen--;
-                    } while (mlen >= minMatch);
+                        U32 const repPrice = ZSTD_getPrice(optStatePtr, litlen, anchor, repCode - ll0, repLen - MINMATCH, ultra);
+                        if (repLen > last_pos || repPrice < opt[repLen].price)
+                            SET_PRICE(repLen, repLen, repCode, litlen, repPrice);   /* note : macro modifies last_pos */
+                        repLen--;
+                    } while (repLen >= minMatch);
         }   }   }
 
         match_num = ZSTD_BtGetAllMatches_selectMLS(ctx, ip, iend, maxSearches, mls, matches, minMatch);
 
-        if (!last_pos && !match_num) { ip++; continue; }
+        if (!last_pos /*no repCode*/ && !match_num /*no match*/) { ip++; continue; }
 
         if (match_num && (matches[match_num-1].len > sufficient_len)) {
+            /* large match => immediate encoding */
             best_mlen = matches[match_num-1].len;
             best_off = matches[match_num-1].off;
             cur = 0;
@@ -483,17 +485,18 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
             goto _storeSequence;
         }
 
-        /* set prices using matches at position = 0 */
-        best_mlen = (last_pos) ? last_pos : minMatch;
-        for (u = 0; u < match_num; u++) {
-            mlen = (u>0) ? matches[u-1].len+1 : best_mlen;
-            best_mlen = matches[u].len;
-            while (mlen <= best_mlen) {
-                price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[u].off-1, mlen - MINMATCH, ultra);
-                if (mlen > last_pos || price < opt[mlen].price)
-                    SET_PRICE(mlen, mlen, matches[u].off, litlen, price);   /* note : macro modifies last_pos */
-                mlen++;
-        }   }
+        /* set prices for first matches from position == 0 */
+        {   U32 matchNb;
+            for (matchNb = 0; matchNb < match_num; matchNb++) {
+                U32 pos = (matchNb==0) ? (last_pos /*some repCode (assumed cheaper)*/ ? last_pos : minMatch)
+                                       : matches[matchNb-1].len+1;
+                U32 const end = matches[matchNb].len;
+                while (pos <= end) {
+                    U32 const matchPrice = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[matchNb].off-1, pos - MINMATCH, ultra);
+                    if (pos > last_pos || matchPrice < opt[pos].price)
+                        SET_PRICE(pos, pos, matches[matchNb].off, litlen, matchPrice);   /* note : macro modifies last_pos */
+                    pos++;
+        }   }   }
 
         if (last_pos < minMatch) { ip++; continue; }
 

From 5aa0352742ca9ad33b8aba09cb95d6574d4f959d Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 8 Nov 2017 12:20:07 -0800
Subject: [PATCH 041/145] zstd_opt: simplified ZSTD_getPrice() and
 ZSTD_updatePrice() interface

ZSTD_getPrice() and ZSTD_updatePrice() accept normal matchlength as argument
instead of matchlength-MINMATCH,
which makes them easier / more logical to use and read.
Conversion is simply done internally.
---
 lib/compress/zstd_compress_internal.h |  2 +-
 lib/compress/zstd_opt.c               | 49 ++++++++++++++-------------
 2 files changed, 26 insertions(+), 25 deletions(-)

diff --git a/lib/compress/zstd_compress_internal.h b/lib/compress/zstd_compress_internal.h
index 4f4697682..7501f7aae 100644
--- a/lib/compress/zstd_compress_internal.h
+++ b/lib/compress/zstd_compress_internal.h
@@ -91,7 +91,7 @@ typedef struct {
     U32  log2offCodeSum;         /* pow2 to compare log2(offreq) to */
     U32  factor;                 /* added to calculate ZSTD_getPrice() (but why?) */
     /* end : updated by ZSTD_setLog2Prices */
-    U32  staticPrices;           /* ? do not update statistics ? */
+    U32  staticPrices;           /* prices follow a static cost structure, statistics are irrelevant */
     U32  cachedPrice;
     U32  cachedLitLength;
     const BYTE* cachedLiterals;
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index f333a5063..dab53835a 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -140,19 +140,19 @@ static U32 ZSTD_getLiteralPrice(optState_t* optPtr, U32 litLength, const BYTE* l
 
 FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength, const int ultra)
 {
-    /* offset */
-    U32 price;
     BYTE const offCode = (BYTE)ZSTD_highbit32(offset+1);
+    U32 const mlBase = matchLength - MINMATCH;
+    U32 price;
 
     if (optPtr->staticPrices)
-        return ZSTD_getLiteralPrice(optPtr, litLength, literals) + ZSTD_highbit32((U32)matchLength+1) + 16 + offCode;
+        return ZSTD_getLiteralPrice(optPtr, litLength, literals) + ZSTD_highbit32((U32)mlBase+1) + 16 + offCode;
 
     price = offCode + optPtr->log2offCodeSum - ZSTD_highbit32(optPtr->offCodeFreq[offCode]+1);
     if (!ultra && offCode >= 20) price += (offCode-19)*2; /* handicap for long matches, to favor decompression speed */
 
     /* match Length */
     {   BYTE const ML_deltaCode = 36;
-        BYTE const mlCode = (matchLength>127) ? (BYTE)ZSTD_highbit32(matchLength) + ML_deltaCode : ML_Code[matchLength];
+        BYTE const mlCode = (mlBase>127) ? (BYTE)ZSTD_highbit32(mlBase) + ML_deltaCode : ML_Code[mlBase];
         price += ML_bits[mlCode] + optPtr->log2matchLengthSum - ZSTD_highbit32(optPtr->matchLengthFreq[mlCode]+1);
     }
 
@@ -183,8 +183,9 @@ static void ZSTD_updatePrice(optState_t* optPtr, U32 litLength, const BYTE* lite
     }
 
     /* match Length */
-    {   const BYTE ML_deltaCode = 36;
-        const BYTE mlCode = (matchLength>127) ? (BYTE)ZSTD_highbit32(matchLength) + ML_deltaCode : ML_Code[matchLength];
+    {   U32 const mlBase = matchLength - MINMATCH;
+        const BYTE ML_deltaCode = 36;
+        const BYTE mlCode = (mlBase>127) ? (BYTE)ZSTD_highbit32(mlBase) + ML_deltaCode : ML_Code[mlBase];
         optPtr->matchLengthFreq[mlCode]++;
         optPtr->matchLengthSum++;
     }
@@ -465,7 +466,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                         goto _storeSequence;
                     }
                     do {
-                        U32 const repPrice = ZSTD_getPrice(optStatePtr, litlen, anchor, repCode - ll0, repLen - MINMATCH, ultra);
+                        U32 const repPrice = ZSTD_getPrice(optStatePtr, litlen, anchor, repCode - ll0, repLen, ultra);
                         if (repLen > last_pos || repPrice < opt[repLen].price)
                             SET_PRICE(repLen, repLen, repCode, litlen, repPrice);   /* note : macro modifies last_pos */
                         repLen--;
@@ -492,7 +493,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                                        : matches[matchNb-1].len+1;
                 U32 const end = matches[matchNb].len;
                 while (pos <= end) {
-                    U32 const matchPrice = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[matchNb].off-1, pos - MINMATCH, ultra);
+                    U32 const matchPrice = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[matchNb].off-1, pos, ultra);
                     if (pos > last_pos || matchPrice < opt[pos].price)
                         SET_PRICE(pos, pos, matches[matchNb].off, litlen, matchPrice);   /* note : macro modifies last_pos */
                     pos++;
@@ -566,12 +567,12 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                            if (opt[cur].mlen == 1) {
                                 litlen = opt[cur].litlen;
                                 if (cur > litlen) {
-                                    price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, inr-litlen, best_off, mlen - MINMATCH, ultra);
+                                    price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, inr-litlen, best_off, mlen, ultra);
                                 } else
-                                    price = ZSTD_getPrice(optStatePtr, litlen, anchor, best_off, mlen - MINMATCH, ultra);
+                                    price = ZSTD_getPrice(optStatePtr, litlen, anchor, best_off, mlen, ultra);
                             } else {
                                 litlen = 0;
-                                price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, best_off, mlen - MINMATCH, ultra);
+                                price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, best_off, mlen, ultra);
                             }
 
                             if (cur + mlen > last_pos || price <= opt[cur + mlen].price)
@@ -598,12 +599,12 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                     if (opt[cur].mlen == 1) {
                         litlen = opt[cur].litlen;
                         if (cur > litlen)
-                            price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, ip+cur-litlen, matches[u].off-1, mlen - MINMATCH, ultra);
+                            price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, ip+cur-litlen, matches[u].off-1, mlen, ultra);
                         else
-                            price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[u].off-1, mlen - MINMATCH, ultra);
+                            price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[u].off-1, mlen, ultra);
                     } else {
                         litlen = 0;
-                        price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, matches[u].off-1, mlen - MINMATCH, ultra);
+                        price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, matches[u].off-1, mlen, ultra);
                     }
 
                     if (cur + mlen > last_pos || (price < opt[cur + mlen].price))
@@ -657,7 +658,7 @@ _storeSequence:   /* cur, last_pos, best_mlen, best_off have to be set */
                 if (litLength==0) offset--;
             }
 
-            ZSTD_updatePrice(optStatePtr, litLength, anchor, offset, mlen-MINMATCH);
+            ZSTD_updatePrice(optStatePtr, litLength, anchor, offset, mlen);
             ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
             anchor = ip = ip + mlen;
         }
@@ -748,7 +749,7 @@ size_t ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
                     best_off = i - (ip==anchor);
                     litlen = opt[0].litlen;
                     do {
-                        price = ZSTD_getPrice(optStatePtr, litlen, anchor, best_off, mlen - MINMATCH, ultra);
+                        price = ZSTD_getPrice(optStatePtr, litlen, anchor, best_off, mlen, ultra);
                         if (mlen > last_pos || price < opt[mlen].price)
                             SET_PRICE(mlen, mlen, i, litlen, price);   /* note : macro modifies last_pos */
                         mlen--;
@@ -778,7 +779,7 @@ size_t ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
             best_mlen = matches[u].len;
             litlen = opt[0].litlen;
             while (mlen <= best_mlen) {
-                price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[u].off-1, mlen - MINMATCH, ultra);
+                price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[u].off-1, mlen, ultra);
                 if (mlen > last_pos || price < opt[mlen].price)
                     SET_PRICE(mlen, mlen, matches[u].off, litlen, price);
                 mlen++;
@@ -849,12 +850,12 @@ size_t ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
                             if (opt[cur].mlen == 1) {
                                 litlen = opt[cur].litlen;
                                 if (cur > litlen) {
-                                    price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, inr-litlen, best_off, mlen - MINMATCH, ultra);
+                                    price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, inr-litlen, best_off, mlen, ultra);
                                 } else
-                                    price = ZSTD_getPrice(optStatePtr, litlen, anchor, best_off, mlen - MINMATCH, ultra);
+                                    price = ZSTD_getPrice(optStatePtr, litlen, anchor, best_off, mlen, ultra);
                             } else {
                                 litlen = 0;
-                                price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, best_off, mlen - MINMATCH, ultra);
+                                price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, best_off, mlen, ultra);
                             }
 
                             if (cur + mlen > last_pos || price <= opt[cur + mlen].price)
@@ -881,12 +882,12 @@ size_t ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
                     if (opt[cur].mlen == 1) {
                         litlen = opt[cur].litlen;
                         if (cur > litlen)
-                            price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, ip+cur-litlen, matches[u].off-1, mlen - MINMATCH, ultra);
+                            price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, ip+cur-litlen, matches[u].off-1, mlen, ultra);
                         else
-                            price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[u].off-1, mlen - MINMATCH, ultra);
+                            price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[u].off-1, mlen, ultra);
                     } else {
                         litlen = 0;
-                        price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, matches[u].off-1, mlen - MINMATCH, ultra);
+                        price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, matches[u].off-1, mlen, ultra);
                     }
 
                     if (cur + mlen > last_pos || (price < opt[cur + mlen].price))
@@ -941,7 +942,7 @@ _storeSequence:   /* cur, last_pos, best_mlen, best_off have to be set */
                 if (litLength==0) offset--;
             }
 
-            ZSTD_updatePrice(optStatePtr, litLength, anchor, offset, mlen-MINMATCH);
+            ZSTD_updatePrice(optStatePtr, litLength, anchor, offset, mlen);
             ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
             anchor = ip = ip + mlen;
     }    }   /* for (cur=0; cur < last_pos; ) */

From 100d8ad6be8ecfe0ec1dc31f1567887e18c891cc Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 8 Nov 2017 12:33:06 -0800
Subject: [PATCH 042/145] lib/compress: created ZSTD_LLcode() and ZSTD_MLcode()

transform length into code.
Since transformation is needed in several places throughout the code,
better write the logic in one place.
---
 lib/compress/zstd_compress.c          |  6 +--
 lib/compress/zstd_compress_internal.h | 55 +++++++++++++++++----------
 lib/compress/zstd_opt.c               | 12 ++----
 3 files changed, 40 insertions(+), 33 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index a1162e3a4..582e3e50c 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -1248,8 +1248,6 @@ static size_t ZSTD_compressLiterals (ZSTD_entropyCTables_t * entropy,
 
 void ZSTD_seqToCodes(const seqStore_t* seqStorePtr)
 {
-    BYTE const LL_deltaCode = 19;
-    BYTE const ML_deltaCode = 36;
     const seqDef* const sequences = seqStorePtr->sequencesStart;
     BYTE* const llCodeTable = seqStorePtr->llCode;
     BYTE* const ofCodeTable = seqStorePtr->ofCode;
@@ -1259,9 +1257,9 @@ void ZSTD_seqToCodes(const seqStore_t* seqStorePtr)
     for (u=0; u<nbSeq; u++) {
         U32 const llv = sequences[u].litLength;
         U32 const mlv = sequences[u].matchLength;
-        llCodeTable[u] = (llv> 63) ? (BYTE)ZSTD_highbit32(llv) + LL_deltaCode : LL_Code[llv];
+        llCodeTable[u] = (BYTE)ZSTD_LLcode(llv);
         ofCodeTable[u] = (BYTE)ZSTD_highbit32(sequences[u].offset);
-        mlCodeTable[u] = (mlv>127) ? (BYTE)ZSTD_highbit32(mlv) + ML_deltaCode : ML_Code[mlv];
+        mlCodeTable[u] = (BYTE)ZSTD_MLcode(mlv);
     }
     if (seqStorePtr->longLengthID==1)
         llCodeTable[seqStorePtr->longLengthPos] = MaxLL;
diff --git a/lib/compress/zstd_compress_internal.h b/lib/compress/zstd_compress_internal.h
index 7501f7aae..e29a61b70 100644
--- a/lib/compress/zstd_compress_internal.h
+++ b/lib/compress/zstd_compress_internal.h
@@ -195,30 +195,43 @@ struct ZSTD_CCtx_s {
 };
 
 
-static const BYTE LL_Code[64] = {  0,  1,  2,  3,  4,  5,  6,  7,
-                                   8,  9, 10, 11, 12, 13, 14, 15,
-                                  16, 16, 17, 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 };
+MEM_STATIC U32 ZSTD_LLcode(U32 litLength)
+{
+    static const BYTE LL_Code[64] = {  0,  1,  2,  3,  4,  5,  6,  7,
+                                       8,  9, 10, 11, 12, 13, 14, 15,
+                                      16, 16, 17, 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 };
+    static const U32 LL_deltaCode = 19;
+    return (litLength > 63) ? ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength];
+}
 
-static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
-                                  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
-                                  32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37,
-                                  38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39,
-                                  40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
-                                  41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
-                                  42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
-                                  42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 };
+/* ZSTD_MLcode() :
+ * note : mlBase = matchLength - MINMATCH;
+ *        because it's the format it's stored in seqStore->sequences */
+MEM_STATIC U32 ZSTD_MLcode(U32 mlBase)
+{
+    static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
+                                      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+                                      32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37,
+                                      38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39,
+                                      40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+                                      41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+                                      42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+                                      42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 };
+    static const U32 ML_deltaCode = 36;
+    return (mlBase > 127) ? ZSTD_highbit32(mlBase) + ML_deltaCode : ML_Code[mlBase];
+}
 
 /*! ZSTD_storeSeq() :
  *  Store a sequence (literal length, literals, offset code and match length code) into seqStore_t.
  *  `offsetCode` : distance to match + 3 (values 1-3 are repCodes).
- *  `matchCode` : matchLength - MINMATCH
+ *  `mlBase` : matchLength - MINMATCH
 */
-MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const void* literals, U32 offsetCode, size_t matchCode)
+MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const void* literals, U32 offsetCode, size_t mlBase)
 {
 #if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 6)
     static const BYTE* g_start = NULL;
@@ -226,7 +239,7 @@ MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const v
     if (g_start==NULL) g_start = (const BYTE*)literals;  /* note : index only works for compression within a single segment */
     if ((pos > 0) && (pos < 1000000000))
         DEBUGLOG(6, "Cpos %6u :%5u literals & match %3u bytes at distance %6u",
-               pos, (U32)litLength, (U32)matchCode+MINMATCH, (U32)offsetCode);
+               pos, (U32)litLength, (U32)mlBase+MINMATCH, (U32)offsetCode);
 #endif
     /* copy Literals */
     assert(seqStorePtr->lit + litLength <= seqStorePtr->litStart + 128 KB);
@@ -245,12 +258,12 @@ MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const v
     seqStorePtr->sequences[0].offset = offsetCode + 1;
 
     /* match Length */
-    if (matchCode>0xFFFF) {
+    if (mlBase>0xFFFF) {
         assert(seqStorePtr->longLengthID == 0); /* there can only be a single long length */
         seqStorePtr->longLengthID = 2;
         seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
     }
-    seqStorePtr->sequences[0].matchLength = (U16)matchCode;
+    seqStorePtr->sequences[0].matchLength = (U16)mlBase;
 
     seqStorePtr->sequences++;
 }
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index dab53835a..5e42039ab 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -129,8 +129,7 @@ static U32 ZSTD_getLiteralPrice(optState_t* optPtr, U32 litLength, const BYTE* l
     }
 
     /* literal Length */
-    {   BYTE const LL_deltaCode = 19;
-        BYTE const llCode = (litLength>63) ? (BYTE)ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength];
+    {   U32 const llCode = ZSTD_LLcode(litLength);
         price += LL_bits[llCode] + optPtr->log2litLengthSum - ZSTD_highbit32(optPtr->litLengthFreq[llCode]+1);
     }
 
@@ -151,8 +150,7 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr, U32 litLength, const
     if (!ultra && offCode >= 20) price += (offCode-19)*2; /* handicap for long matches, to favor decompression speed */
 
     /* match Length */
-    {   BYTE const ML_deltaCode = 36;
-        BYTE const mlCode = (mlBase>127) ? (BYTE)ZSTD_highbit32(mlBase) + ML_deltaCode : ML_Code[mlBase];
+    {   U32 const mlCode = ZSTD_MLcode(mlBase);
         price += ML_bits[mlCode] + optPtr->log2matchLengthSum - ZSTD_highbit32(optPtr->matchLengthFreq[mlCode]+1);
     }
 
@@ -170,8 +168,7 @@ static void ZSTD_updatePrice(optState_t* optPtr, U32 litLength, const BYTE* lite
         optPtr->litFreq[literals[u]] += ZSTD_LITFREQ_ADD;
 
     /* literal Length */
-    {   const BYTE LL_deltaCode = 19;
-        const BYTE llCode = (litLength>63) ? (BYTE)ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength];
+    {   const U32 llCode = ZSTD_LLcode(litLength);
         optPtr->litLengthFreq[llCode]++;
         optPtr->litLengthSum++;
     }
@@ -184,8 +181,7 @@ static void ZSTD_updatePrice(optState_t* optPtr, U32 litLength, const BYTE* lite
 
     /* match Length */
     {   U32 const mlBase = matchLength - MINMATCH;
-        const BYTE ML_deltaCode = 36;
-        const BYTE mlCode = (mlBase>127) ? (BYTE)ZSTD_highbit32(mlBase) + ML_deltaCode : ML_Code[mlBase];
+        U32 const mlCode = ZSTD_MLcode(mlBase);
         optPtr->matchLengthFreq[mlCode]++;
         optPtr->matchLengthSum++;
     }

From eb47705b189f942096ba82a251902a2b474a39b3 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Thu, 9 Nov 2017 12:46:34 -0800
Subject: [PATCH 043/145] reduced scope of multiple variables

renamed some variables for better understanding
---
 lib/compress/zstd_opt.c | 332 ++++++++++++++++++++--------------------
 1 file changed, 166 insertions(+), 166 deletions(-)

diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index 5e42039ab..26a1a1a85 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -100,7 +100,7 @@ static U32 ZSTD_getLiteralPrice(optState_t* optPtr, U32 litLength, const BYTE* l
     U32 price;
 
     if (optPtr->staticPrices)
-        return ZSTD_highbit32((U32)litLength+1) + (litLength*6);  /* 6 bit per literal - no real estimation */
+        return ZSTD_highbit32((U32)litLength+1) + (litLength*6);  /* 6 bit per literal - no statistic used */
 
     if (litLength == 0)
         return optPtr->log2litLengthSum - ZSTD_highbit32(optPtr->litLengthFreq[0]+1);
@@ -414,8 +414,8 @@ FORCE_INLINE_TEMPLATE
 size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                                       const void* src, size_t srcSize, const int ultra)
 {
-    seqStore_t* seqStorePtr = &(ctx->seqStore);
-    optState_t* optStatePtr = &(ctx->optState);
+    seqStore_t* const seqStorePtr = &(ctx->seqStore);
+    optState_t* const optStatePtr = &(ctx->optState);
     const BYTE* const istart = (const BYTE*)src;
     const BYTE* ip = istart;
     const BYTE* anchor = istart;
@@ -441,223 +441,223 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
 
     /* Match Loop */
     while (ip < ilimit) {
-        U32 cur, match_num, last_pos = 0, litlen, price;
-        U32 u, mlen, best_mlen, best_off, litLength, offset;
+        U32 cur, last_pos = 0;
+        U32 best_mlen, best_off;
+        U32 const initLL = (U32)(ip - anchor);
         memset(opt, 0, sizeof(ZSTD_optimal_t));
-        litlen = (U32)(ip - anchor);
 
         /* check repCode */
-        {   U32 const ll0 = (ip==anchor);
+        {   U32 const ll0 = !initLL;
             U32 const lastR = ZSTD_REP_CHECK + ll0;
             U32 repCode;
             for (repCode = ll0; repCode < lastR; repCode++) {
                 S32 const repOffset = (repCode==ZSTD_REP_MOVE_OPT) ? (rep[0] - 1) : rep[repCode];
                 if ( (repOffset > 0)
-                  && (repOffset < (S32)(ip-prefixStart))  /* only check within current mem segment */
+                  && (repOffset < (S32)(ip-prefixStart))  /* within current mem segment */
                   && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repOffset, minMatch))) {
                     U32 repLen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repOffset, iend) + minMatch;
                     if (repLen > sufficient_len) {
                         /* large repMatch => immediate encoding */
                         best_mlen = repLen; best_off = repCode; cur = 0; last_pos = 1;
-                        goto _storeSequence;
+                        goto _shortestPath;
                     }
                     do {
-                        U32 const repPrice = ZSTD_getPrice(optStatePtr, litlen, anchor, repCode - ll0, repLen, ultra);
+                        U32 const repPrice = ZSTD_getPrice(optStatePtr, initLL, anchor, repCode - ll0, repLen, ultra);
                         if (repLen > last_pos || repPrice < opt[repLen].price)
-                            SET_PRICE(repLen, repLen, repCode, litlen, repPrice);   /* note : macro modifies last_pos */
+                            SET_PRICE(repLen, repLen, repCode, initLL, repPrice);   /* note : macro modifies last_pos */
                         repLen--;
                     } while (repLen >= minMatch);
         }   }   }
 
-        match_num = ZSTD_BtGetAllMatches_selectMLS(ctx, ip, iend, maxSearches, mls, matches, minMatch);
+        {   U32 const nb_matches = ZSTD_BtGetAllMatches_selectMLS(ctx, ip, iend, maxSearches, mls, matches, minMatch);
 
-        if (!last_pos /*no repCode*/ && !match_num /*no match*/) { ip++; continue; }
+            if (!last_pos /*no repCode*/ && !nb_matches /*no match*/) { ip++; continue; }
 
-        if (match_num && (matches[match_num-1].len > sufficient_len)) {
-            /* large match => immediate encoding */
-            best_mlen = matches[match_num-1].len;
-            best_off = matches[match_num-1].off;
-            cur = 0;
-            last_pos = 1;
-            goto _storeSequence;
-        }
+            if (nb_matches && (matches[nb_matches-1].len > sufficient_len)) {
+                /* large match => immediate encoding */
+                best_mlen = matches[nb_matches-1].len;
+                best_off = matches[nb_matches-1].off;
+                cur = 0;
+                last_pos = 1;
+                goto _shortestPath;
+            }
 
-        /* set prices for first matches from position == 0 */
-        {   U32 matchNb;
-            for (matchNb = 0; matchNb < match_num; matchNb++) {
-                U32 pos = (matchNb==0) ? (last_pos /*some repCode (assumed cheaper)*/ ? last_pos : minMatch)
-                                       : matches[matchNb-1].len+1;
-                U32 const end = matches[matchNb].len;
-                while (pos <= end) {
-                    U32 const matchPrice = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[matchNb].off-1, pos, ultra);
-                    if (pos > last_pos || matchPrice < opt[pos].price)
-                        SET_PRICE(pos, pos, matches[matchNb].off, litlen, matchPrice);   /* note : macro modifies last_pos */
-                    pos++;
-        }   }   }
+            /* set prices for first matches from position == 0 */
+            {   U32 matchNb;
+                U32 pos = last_pos /*some repCode (assumed cheaper)*/ ? last_pos : minMatch;
+                for (matchNb = 0; matchNb < nb_matches; matchNb++) {
+                    U32 const end = matches[matchNb].len;
+                    while (pos <= end) {
+                        U32 const matchPrice = ZSTD_getPrice(optStatePtr, initLL, anchor, matches[matchNb].off-1, pos, ultra);
+                        if (pos > last_pos || matchPrice < opt[pos].price)
+                            SET_PRICE(pos, pos, matches[matchNb].off, initLL, matchPrice);   /* note : macro modifies last_pos */
+                        pos++;
+        }   }   }   }
 
         if (last_pos < minMatch) { ip++; continue; }
 
         /* initialize opt[0] */
         { U32 i ; for (i=0; i<ZSTD_REP_NUM; i++) opt[0].rep[i] = rep[i]; }
         opt[0].mlen = 1;
-        opt[0].litlen = litlen;
+        opt[0].litlen = initLL;
 
-         /* check further positions */
+        /* check further positions */
         for (cur = 1; cur <= last_pos; cur++) {
-           const BYTE* const inr = ip + cur;
+            const BYTE* const inr = ip + cur;
+            assert(cur < ZSTD_OPT_NUM);
 
-           if (opt[cur-1].mlen == 1) {
-                litlen = opt[cur-1].litlen + 1;
+            /* Fix current position with one literal if cheaper */
+            {   U32 const litlen = (opt[cur-1].mlen == 1) ? opt[cur-1].litlen + 1 : 1;
+                U32 price;
                 if (cur > litlen) {
                     price = opt[cur - litlen].price + ZSTD_getLiteralPrice(optStatePtr, litlen, inr-litlen);
-                } else
+                } else {
                     price = ZSTD_getLiteralPrice(optStatePtr, litlen, anchor);
-           } else {
-                litlen = 1;
-                price = opt[cur - 1].price + ZSTD_getLiteralPrice(optStatePtr, litlen, inr-1);
-           }
-
-           if (cur > last_pos || price <= opt[cur].price)
-                SET_PRICE(cur, 1, 0, litlen, price);  /* note : macro modifies last_pos */
-
-           if (cur == last_pos) break;
-
-           if (inr > ilimit)  /* last match must start at a minimum distance of 8 from oend */
-               continue;
-
-           mlen = opt[cur].mlen;
-           if (opt[cur].off > ZSTD_REP_MOVE_OPT) {
-                opt[cur].rep[2] = opt[cur-mlen].rep[1];
-                opt[cur].rep[1] = opt[cur-mlen].rep[0];
-                opt[cur].rep[0] = opt[cur].off - ZSTD_REP_MOVE_OPT;
-           } else {
-                opt[cur].rep[2] = (opt[cur].off > 1) ? opt[cur-mlen].rep[1] : opt[cur-mlen].rep[2];
-                opt[cur].rep[1] = (opt[cur].off > 0) ? opt[cur-mlen].rep[0] : opt[cur-mlen].rep[1];
-                /* If opt[cur].off == ZSTD_REP_MOVE_OPT, then mlen != 1.
-                 * offset ZSTD_REP_MOVE_OPT is used for the special case
-                 * litLength == 0, where offset 0 means something special.
-                 * mlen == 1 means the previous byte was stored as a literal,
-                 * so they are mutually exclusive.
-                 */
-                assert(!(opt[cur].off == ZSTD_REP_MOVE_OPT && mlen == 1));
-                opt[cur].rep[0] = (opt[cur].off == ZSTD_REP_MOVE_OPT) ? (opt[cur-mlen].rep[0] - 1) : (opt[cur-mlen].rep[opt[cur].off]);
-           }
-
-            best_mlen = minMatch;
-            {   U32 i, last_i = ZSTD_REP_CHECK + (mlen != 1);
-                for (i=(opt[cur].mlen != 1); i<last_i; i++) {  /* check rep */
-                    const S32 repCur = (i==ZSTD_REP_MOVE_OPT) ? (opt[cur].rep[0] - 1) : opt[cur].rep[i];
-                    if ( (repCur > 0) && (repCur < (S32)(inr-prefixStart))
-                       && (ZSTD_readMINMATCH(inr, minMatch) == ZSTD_readMINMATCH(inr - repCur, minMatch))) {
-                       mlen = (U32)ZSTD_count(inr+minMatch, inr+minMatch - repCur, iend) + minMatch;
-
-                       if (mlen > sufficient_len || cur + mlen >= ZSTD_OPT_NUM) {
-                            best_mlen = mlen; best_off = i; last_pos = cur + 1;
-                            goto _storeSequence;
-                       }
-
-                       best_off = i - (opt[cur].mlen != 1);
-                       if (mlen > best_mlen) best_mlen = mlen;
-
-                       do {
-                           if (opt[cur].mlen == 1) {
-                                litlen = opt[cur].litlen;
-                                if (cur > litlen) {
-                                    price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, inr-litlen, best_off, mlen, ultra);
-                                } else
-                                    price = ZSTD_getPrice(optStatePtr, litlen, anchor, best_off, mlen, ultra);
-                            } else {
-                                litlen = 0;
-                                price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, best_off, mlen, ultra);
-                            }
-
-                            if (cur + mlen > last_pos || price <= opt[cur + mlen].price)
-                                SET_PRICE(cur + mlen, mlen, i, litlen, price);  /* note : macro modifies last_pos */
-                            mlen--;
-                        } while (mlen >= minMatch);
-            }   }   }
-
-            match_num = ZSTD_BtGetAllMatches_selectMLS(ctx, inr, iend, maxSearches, mls, matches, best_mlen);
-
-            if (match_num > 0 && (matches[match_num-1].len > sufficient_len || cur + matches[match_num-1].len >= ZSTD_OPT_NUM)) {
-                best_mlen = matches[match_num-1].len;
-                best_off = matches[match_num-1].off;
-                last_pos = cur + 1;
-                goto _storeSequence;
+                }
+                if (cur > last_pos || price <= opt[cur].price)
+                    SET_PRICE(cur, 1, 0, litlen, price);  /* note : macro modifies last_pos */
             }
 
-            /* set prices using matches at position = cur */
-            for (u = 0; u < match_num; u++) {
-                mlen = (u>0) ? matches[u-1].len+1 : best_mlen;
-                best_mlen = matches[u].len;
+            if (cur == last_pos) break;
 
-                while (mlen <= best_mlen) {
-                    if (opt[cur].mlen == 1) {
-                        litlen = opt[cur].litlen;
+            /* last match must start at a minimum distance of 8 from oend */
+            if (inr > ilimit) continue;
+
+            /* update repcodes */
+            {   U32 const mlen = opt[cur].mlen;
+                if (opt[cur].off > ZSTD_REP_MOVE_OPT) {
+                    opt[cur].rep[2] = opt[cur-mlen].rep[1];
+                    opt[cur].rep[1] = opt[cur-mlen].rep[0];
+                    opt[cur].rep[0] = opt[cur].off - ZSTD_REP_MOVE_OPT;
+                } else {
+                    opt[cur].rep[2] = (opt[cur].off > 1) ? opt[cur-mlen].rep[1] : opt[cur-mlen].rep[2];
+                    opt[cur].rep[1] = (opt[cur].off > 0) ? opt[cur-mlen].rep[0] : opt[cur-mlen].rep[1];
+                    /* If opt[cur].off == ZSTD_REP_MOVE_OPT, then mlen != 1.
+                     * offset ZSTD_REP_MOVE_OPT is used for the special case
+                     * litLength == 0, where offset 0 means something special.
+                     * mlen == 1 means the previous byte was stored as a literal,
+                     * so they are mutually exclusive.
+                     */
+                    assert(!(opt[cur].off == ZSTD_REP_MOVE_OPT && mlen == 1));
+                    opt[cur].rep[0] = (opt[cur].off == ZSTD_REP_MOVE_OPT) ? (opt[cur-mlen].rep[0] - 1) : (opt[cur-mlen].rep[opt[cur].off]);
+            }   }
+
+            best_mlen = minMatch;
+            {   U32 const ll0 = (opt[cur].mlen != 1);
+                U32 const lastR = ZSTD_REP_CHECK + ll0;
+                U32 repCode4;  /* universal referential */
+                for (repCode4=ll0; repCode4<lastR; repCode4++) {  /* check rep */
+                    const S32 repCur = (repCode4==ZSTD_REP_MOVE_OPT) ? (opt[cur].rep[0] - 1) : opt[cur].rep[repCode4];
+                    if ( (repCur > 0) && (repCur < (S32)(inr-prefixStart))  /* within current mem segment */
+                      && (ZSTD_readMINMATCH(inr, minMatch) == ZSTD_readMINMATCH(inr - repCur, minMatch))) {
+                        U32 matchLength = (U32)ZSTD_count(inr+minMatch, inr+minMatch - repCur, iend) + minMatch;
+                        U32 const repCode3 = repCode4 - ll0;  /* contextual referential, depends on ll0 */
+                        assert(repCode3 < 3);
+
+                        if (matchLength > sufficient_len || cur + matchLength >= ZSTD_OPT_NUM) {
+                            best_mlen = matchLength;
+                            best_off = repCode4;
+                            last_pos = cur + 1;
+                            goto _shortestPath;
+                        }
+
+                        if (matchLength > best_mlen) best_mlen = matchLength;
+
+                        do {
+                            U32 const litlen = ll0 ? 0 : opt[cur].litlen;
+                            U32 price;
+                            if (cur > litlen) {
+                                price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, inr-litlen, repCode3, matchLength, ultra);
+                            } else {
+                                price = ZSTD_getPrice(optStatePtr, litlen, anchor, repCode3, matchLength, ultra);
+                            }
+
+                            if (cur + matchLength > last_pos || price <= opt[cur + matchLength].price)
+                                SET_PRICE(cur + matchLength, matchLength, repCode4, litlen, price);  /* note : macro modifies last_pos */
+                            matchLength--;
+                        } while (matchLength >= minMatch);
+            }   }   }
+
+            {   U32 const nb_matches = ZSTD_BtGetAllMatches_selectMLS(ctx, inr, iend, maxSearches, mls, matches, best_mlen /*largest repLength*/);   /* search for matches larger than repcodes */
+                U32 matchNb;
+
+                if (nb_matches > 0 && (matches[nb_matches-1].len > sufficient_len || cur + matches[nb_matches-1].len >= ZSTD_OPT_NUM)) {
+                    best_mlen = matches[nb_matches-1].len;
+                    best_off = matches[nb_matches-1].off;
+                    last_pos = cur + 1;
+                    goto _shortestPath;
+                }
+
+                /* set prices using matches at position = cur */
+                for (matchNb = 0; matchNb < nb_matches; matchNb++) {
+                    U32 mlen = (matchNb>0) ? matches[matchNb-1].len+1 : best_mlen;
+                    U32 const lastML = matches[matchNb].len;
+
+                    while (mlen <= lastML) {
+                        U32 const litlen = (opt[cur].mlen == 1) ? opt[cur].litlen : 0;
+                        U32 price;
                         if (cur > litlen)
-                            price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, ip+cur-litlen, matches[u].off-1, mlen, ultra);
+                            price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, ip+cur-litlen, matches[matchNb].off-1, mlen, ultra);
                         else
-                            price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[u].off-1, mlen, ultra);
-                    } else {
-                        litlen = 0;
-                        price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, matches[u].off-1, mlen, ultra);
-                    }
+                            price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[matchNb].off-1, mlen, ultra);
 
-                    if (cur + mlen > last_pos || (price < opt[cur + mlen].price))
-                        SET_PRICE(cur + mlen, mlen, matches[u].off, litlen, price);  /* note : macro modifies last_pos */
+                        if (cur + mlen > last_pos || (price < opt[cur + mlen].price))
+                            SET_PRICE(cur + mlen, mlen, matches[matchNb].off, litlen, price);  /* note : macro modifies last_pos */
 
-                    mlen++;
-        }   }   }
+                        mlen++;
+        }   }   }   }
 
         best_mlen = opt[last_pos].mlen;
         best_off = opt[last_pos].off;
         cur = last_pos - best_mlen;
 
-        /* store sequence */
-_storeSequence:   /* cur, last_pos, best_mlen, best_off have to be set */
+_shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
         opt[0].mlen = 1;
 
-        while (1) {
-            mlen = opt[cur].mlen;
-            offset = opt[cur].off;
-            opt[cur].mlen = best_mlen;
-            opt[cur].off = best_off;
-            best_mlen = mlen;
-            best_off = offset;
-            if (mlen > cur) break;
-            cur -= mlen;
-        }
+        /* reverse traversal */
+        {   U32 selected_matchLength = best_mlen;
+            U32 selectedOffset = best_off;
+            U32 pos = cur;
+            while (1) {
+                U32 const mlen = opt[pos].mlen;
+                U32 const off = opt[pos].off;
+                opt[pos].mlen = selected_matchLength;
+                opt[pos].off = selectedOffset;
+                selected_matchLength = mlen;
+                selectedOffset = off;
+                if (mlen > pos) break;
+                pos -= mlen;
+        }   }
 
-        for (u = 0; u <= last_pos;) {
-            u += opt[u].mlen;
-        }
+        /* save sequences */
+        {   U32 pos;
+            for (pos=0; pos < last_pos; ) {
+                U32 const litLength = (U32)(ip - anchor);
+                U32 const mlen = opt[pos].mlen;
+                U32 offset = opt[pos].off;
+                if (mlen == 1) { ip++; pos++; continue; }
+                pos += mlen;
 
-        for (cur=0; cur < last_pos; ) {
-            mlen = opt[cur].mlen;
-            if (mlen == 1) { ip++; cur++; continue; }
-            offset = opt[cur].off;
-            cur += mlen;
-            litLength = (U32)(ip - anchor);
-
-            if (offset > ZSTD_REP_MOVE_OPT) {
-                rep[2] = rep[1];
-                rep[1] = rep[0];
-                rep[0] = offset - ZSTD_REP_MOVE_OPT;
-                offset--;
-            } else {
-                if (offset != 0) {
-                    best_off = (offset==ZSTD_REP_MOVE_OPT) ? (rep[0] - 1) : (rep[offset]);
-                    if (offset != 1) rep[2] = rep[1];
+                /* repcodes update */
+                if (offset > ZSTD_REP_MOVE_OPT) {  /* full offset */
+                    rep[2] = rep[1];
                     rep[1] = rep[0];
-                    rep[0] = best_off;
+                    rep[0] = offset - ZSTD_REP_MOVE_OPT;
+                    offset--;
+                } else {   /* repcode */
+                    if (offset != 0) {
+                        U32 const currentOffset = (offset==ZSTD_REP_MOVE_OPT) ? (rep[0] - 1) : rep[offset];
+                        if (offset != 1) rep[2] = rep[1];
+                        rep[1] = rep[0];
+                        rep[0] = currentOffset;
+                    }
+                    if (litLength==0) offset--;
                 }
-                if (litLength==0) offset--;
-            }
 
-            ZSTD_updatePrice(optStatePtr, litLength, anchor, offset, mlen);
-            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
-            anchor = ip = ip + mlen;
-        }
+                ZSTD_updatePrice(optStatePtr, litLength, anchor, offset, mlen);
+                ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
+                anchor = ip = ip + mlen;
+        }   }
     }   /* for (cur=0; cur < last_pos; ) */
 
     /* Save reps for next block */

From 72c0f4574cfef1d5d5f35fc7277ee353793956ab Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 10 Nov 2017 09:39:11 -0800
Subject: [PATCH 044/145] cmake: fixed lib/CMakeLists.txt

changed file name from zstd_compress.h to zstd_compress_internal.h
---
 build/cmake/lib/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build/cmake/lib/CMakeLists.txt b/build/cmake/lib/CMakeLists.txt
index f5d2eff92..fd20bdb87 100644
--- a/build/cmake/lib/CMakeLists.txt
+++ b/build/cmake/lib/CMakeLists.txt
@@ -63,7 +63,7 @@ SET(Headers
         ${LIBRARY_DIR}/common/huf.h
         ${LIBRARY_DIR}/common/mem.h
         ${LIBRARY_DIR}/common/zstd_internal.h
-        ${LIBRARY_DIR}/compress/zstd_compress.h
+        ${LIBRARY_DIR}/compress/zstd_compress_internal.h
         ${LIBRARY_DIR}/compress/zstd_fast.h
         ${LIBRARY_DIR}/compress/zstd_double_fast.h
         ${LIBRARY_DIR}/compress/zstd_lazy.h

From 9a11f70dc37099a3ea9a76fc16691e91ffc2c450 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Mon, 13 Nov 2017 02:19:36 -0800
Subject: [PATCH 045/145] merged repcode search into BT match search

this version has same speed as branch `opt`
which is itself 5-10% slower than branch `dev`
(no identified reason)

It does not compress exactly the same as `opt` or `dev`,
maybe because it doesn't stop search after repcodes,
leading to sometimes better compression, sometimes worse
(by a small margin).

warning : _extDict path does not work for the time being
This means that benchmark module works,
but file module will fail with large files (and high compression level).
Objective is to fuse _extDict path into current one,
in order to have a single parser to maintain.
---
 lib/common/zstd_common.c              |  14 +-
 lib/common/zstd_internal.h            |  13 +-
 lib/compress/zstd_compress.c          |  18 +-
 lib/compress/zstd_compress_internal.h |   9 +-
 lib/compress/zstd_opt.c               | 315 ++++++++++++++------------
 programs/bench.c                      |   2 +
 6 files changed, 197 insertions(+), 174 deletions(-)

diff --git a/lib/common/zstd_common.c b/lib/common/zstd_common.c
index c2041053b..bccc94889 100644
--- a/lib/common/zstd_common.c
+++ b/lib/common/zstd_common.c
@@ -31,21 +31,27 @@ const char* ZSTD_versionString(void) { return ZSTD_VERSION_STRING; }
 *  ZSTD Error Management
 ******************************************/
 /*! ZSTD_isError() :
-*   tells if a return value is an error code */
+ *  tells if a return value is an error code */
 unsigned ZSTD_isError(size_t code) { return ERR_isError(code); }
 
 /*! ZSTD_getErrorName() :
-*   provides error code string from function result (useful for debugging) */
+ *  provides error code string from function result (useful for debugging) */
 const char* ZSTD_getErrorName(size_t code) { return ERR_getErrorName(code); }
 
 /*! ZSTD_getError() :
-*   convert a `size_t` function result into a proper ZSTD_errorCode enum */
+ *  convert a `size_t` function result into a proper ZSTD_errorCode enum */
 ZSTD_ErrorCode ZSTD_getErrorCode(size_t code) { return ERR_getErrorCode(code); }
 
 /*! ZSTD_getErrorString() :
-*   provides error code string from enum */
+ *  provides error code string from enum */
 const char* ZSTD_getErrorString(ZSTD_ErrorCode code) { return ERR_getErrorString(code); }
 
+/*! g_debuglog_enable :
+ *  turn on/off debug traces (global switch) */
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 2)
+int g_debuglog_enable = 1;
+#endif
+
 
 /*=**************************************************************
 *  Custom allocator
diff --git a/lib/common/zstd_internal.h b/lib/common/zstd_internal.h
index 218cbc204..cc5f8e897 100644
--- a/lib/common/zstd_internal.h
+++ b/lib/common/zstd_internal.h
@@ -54,6 +54,7 @@ extern "C" {
 
 #if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=2)
 #  include <stdio.h>
+extern int g_debuglog_enable;
 /* recommended values for ZSTD_DEBUG display levels :
  * 1 : no display, enables assert() only
  * 2 : reserved for currently active debugging path
@@ -61,11 +62,11 @@ extern "C" {
  * 4 : events once per frame
  * 5 : events once per block
  * 6 : events once per sequence (*very* verbose) */
-#  define DEBUGLOG(l, ...) {                         \
-                if (l<=ZSTD_DEBUG) {                 \
-                    fprintf(stderr, __FILE__ ": ");  \
-                    fprintf(stderr, __VA_ARGS__);    \
-                    fprintf(stderr, " \n");          \
+#  define DEBUGLOG(l, ...) {                                 \
+                if ((g_debuglog_enable) & (l<=ZSTD_DEBUG)) { \
+                    fprintf(stderr, __FILE__ ": ");          \
+                    fprintf(stderr, __VA_ARGS__);            \
+                    fprintf(stderr, " \n");                  \
             }   }
 #else
 #  define DEBUGLOG(l, ...)      {}    /* disabled */
@@ -89,9 +90,7 @@ extern "C" {
 #define ZSTD_OPT_NUM    (1<<12)
 
 #define ZSTD_REP_NUM      3                 /* number of repcodes */
-#define ZSTD_REP_CHECK    (ZSTD_REP_NUM)    /* number of repcodes to check by the optimal parser */
 #define ZSTD_REP_MOVE     (ZSTD_REP_NUM-1)
-#define ZSTD_REP_MOVE_OPT (ZSTD_REP_NUM)
 static const U32 repStartValue[ZSTD_REP_NUM] = { 1, 4, 8 };
 
 #define KB *(1 <<10)
diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 582e3e50c..0045217ba 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -42,17 +42,6 @@ size_t ZSTD_compressBound(size_t srcSize) {
 }
 
 
-/*-*************************************
-*  Sequence storage
-***************************************/
-static void ZSTD_resetSeqStore(seqStore_t* ssPtr)
-{
-    ssPtr->lit = ssPtr->litStart;
-    ssPtr->sequences = ssPtr->sequencesStart;
-    ssPtr->longLengthID = 0;
-}
-
-
 /*-*************************************
 *  Context memory management
 ***************************************/
@@ -1606,6 +1595,13 @@ static void ZSTD_storeLastLiterals(seqStore_t* seqStorePtr,
     seqStorePtr->lit += lastLLSize;
 }
 
+static void ZSTD_resetSeqStore(seqStore_t* ssPtr)
+{
+    ssPtr->lit = ssPtr->litStart;
+    ssPtr->sequences = ssPtr->sequencesStart;
+    ssPtr->longLengthID = 0;
+}
+
 static size_t ZSTD_compressBlock_internal(ZSTD_CCtx* zc, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
 {
     DEBUGLOG(5, "ZSTD_compressBlock_internal : dstCapacity = %u", (U32)dstCapacity);
diff --git a/lib/compress/zstd_compress_internal.h b/lib/compress/zstd_compress_internal.h
index e29a61b70..c32626e58 100644
--- a/lib/compress/zstd_compress_internal.h
+++ b/lib/compress/zstd_compress_internal.h
@@ -233,13 +233,14 @@ MEM_STATIC U32 ZSTD_MLcode(U32 mlBase)
 */
 MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const void* literals, U32 offsetCode, size_t mlBase)
 {
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 6)
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 2)
     static const BYTE* g_start = NULL;
-    U32 const pos = (U32)((const BYTE*)literals - g_start);
     if (g_start==NULL) g_start = (const BYTE*)literals;  /* note : index only works for compression within a single segment */
-    if ((pos > 0) && (pos < 1000000000))
-        DEBUGLOG(6, "Cpos %6u :%5u literals & match %3u bytes at distance %6u",
+    {   U32 const pos = (U32)((const BYTE*)literals - g_start);
+        g_debuglog_enable = ((pos >= 1622540) & (pos < 1622575));
+        DEBUGLOG(2, "Cpos%7u :%3u literals, match%3u bytes at distance%7u",
                pos, (U32)litLength, (U32)mlBase+MINMATCH, (U32)offsetCode);
+    }
 #endif
     /* copy Literals */
     assert(seqStorePtr->lit + litLength <= seqStorePtr->litStart + 128 KB);
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index 26a1a1a85..0e8af45d5 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -17,6 +17,10 @@
 #define ZSTD_FREQ_DIV       4   /* log factor when using previous stats to init next stats */
 #define ZSTD_MAX_PRICE     (1<<30)
 
+#define ZSTD_REP_CHECK    (ZSTD_REP_NUM)    /* number of repcodes to check by the optimal parser */
+#define ZSTD_REP_MOVE_OPT (ZSTD_REP_NUM)
+
+
 /*-*************************************
 *  Price functions for optimal parser
 ***************************************/
@@ -95,7 +99,7 @@ static void ZSTD_rescaleFreqs(optState_t* optPtr, const BYTE* src, size_t srcSiz
 }
 
 
-static U32 ZSTD_getLiteralPrice(optState_t* optPtr, U32 litLength, const BYTE* literals)
+static U32 ZSTD_getLiteralPrice(optState_t* optPtr, U32 const litLength, const BYTE* literals)
 {
     U32 price;
 
@@ -154,7 +158,9 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr, U32 litLength, const
         price += ML_bits[mlCode] + optPtr->log2matchLengthSum - ZSTD_highbit32(optPtr->matchLengthFreq[mlCode]+1);
     }
 
-    return price + ZSTD_getLiteralPrice(optPtr, litLength, literals) + optPtr->factor;
+    price += ZSTD_getLiteralPrice(optPtr, litLength, literals) + optPtr->factor;
+    DEBUGLOG(7, "ZSTD_getPrice(ll:%u, ml:%u) = %u", litLength, matchLength, price);
+    return price;
 }
 
 
@@ -190,17 +196,6 @@ static void ZSTD_updatePrice(optState_t* optPtr, U32 litLength, const BYTE* lite
 }
 
 
-/* update opt[pos] and last_pos */
-#define SET_PRICE(pos, mlen_, offset_, litlen_, price_)   \
-    {                                                     \
-        while (last_pos < pos)  { opt[last_pos+1].price = ZSTD_MAX_PRICE; last_pos++; } \
-        opt[pos].mlen = mlen_;                            \
-        opt[pos].off = offset_;                           \
-        opt[pos].litlen = litlen_;                        \
-        opt[pos].price = price_;                          \
-    }
-
-
 /* function safe only for comparisons */
 static U32 ZSTD_readMINMATCH(const void* memPtr, U32 length)
 {
@@ -242,13 +237,15 @@ static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* zc, const BYTE* ip)
 static U32 ZSTD_insertBtAndGetAllMatches (
                         ZSTD_CCtx* zc,
                         const BYTE* const ip, const BYTE* const iLimit,
-                        U32 nbCompares, const U32 mls,
-                        U32 extDict, ZSTD_match_t* matches, const U32 minMatchLen)
+                        U32 nbCompares, U32 const mls, U32 const extDict,
+                        U32 rep[ZSTD_REP_NUM], U32 const ll0,
+                        ZSTD_match_t* matches, const U32 minMatchLen)
 {
     const BYTE* const base = zc->base;
     const U32 current = (U32)(ip-base);
     const U32 hashLog = zc->appliedParams.cParams.hashLog;
     const size_t h  = ZSTD_hashPtr(ip, hashLog, mls);
+    U32 const minMatch = (mls==3) ? 3 : 4;
     U32* const hashTable = zc->hashTable;
     U32 matchIndex  = hashTable[h];
     U32* const bt   = zc->chainTable;
@@ -267,14 +264,33 @@ static U32 ZSTD_insertBtAndGetAllMatches (
     U32 dummy32;   /* to be nullified at the end */
     U32 mnum = 0;
 
-    const U32 minMatch = (mls == 3) ? 3 : 4;
     size_t bestLength = minMatchLen-1;
 
-    if (minMatch == 3) { /* HC3 match finder */
+    /* check repCode */
+    {   U32 const lastR = ZSTD_REP_NUM + ll0;
+        U32 repCode;
+        for (repCode = ll0; repCode < lastR; repCode++) {
+            S32 const repOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
+            if ( (repOffset > 0)
+              && (repOffset < (S32)(ip-prefixStart))  /* within current mem segment */
+              && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repOffset, minMatch))) {
+                U32 const repLen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repOffset, iLimit) + minMatch;
+                /* save better solution */
+                if (repLen > bestLength) {
+                    bestLength = repLen;
+                    matches[mnum].off = repCode - ll0;
+                    matches[mnum].len = (U32)repLen;
+                    mnum++;
+                    if (repLen > ZSTD_OPT_NUM) goto update;
+                    if (ip+repLen == iLimit) goto update; /* best possible, and avoid read overflow*/
+                }
+    }   }   }
+
+    if (mls == 3) { /* HC3 match finder */
         U32 const matchIndex3 = ZSTD_insertAndFindFirstIndexHash3 (zc, ip);
         if (matchIndex3>windowLow && (current - matchIndex3 < (1<<18))) {
             const BYTE* match;
-            size_t currentMl=0;
+            size_t currentMl = 0;
             if ((!extDict) || matchIndex3 >= dictLimit) {
                 match = base + matchIndex3;
                 if (match[bestLength] == ip[bestLength]) currentMl = ZSTD_count(ip, match, iLimit);
@@ -287,7 +303,7 @@ static U32 ZSTD_insertBtAndGetAllMatches (
             /* save best solution */
             if (currentMl > bestLength) {
                 bestLength = currentMl;
-                matches[mnum].off = ZSTD_REP_MOVE_OPT + current - matchIndex3;
+                matches[mnum].off = ZSTD_REP_MOVE + current - matchIndex3;
                 matches[mnum].len = (U32)currentMl;
                 mnum++;
                 if (currentMl > ZSTD_OPT_NUM) goto update;
@@ -318,12 +334,12 @@ static U32 ZSTD_insertBtAndGetAllMatches (
         if (matchLength > bestLength) {
             if (matchLength > matchEndIdx - matchIndex) matchEndIdx = matchIndex + (U32)matchLength;
             bestLength = matchLength;
-            matches[mnum].off = ZSTD_REP_MOVE_OPT + current - matchIndex;
+            matches[mnum].off = ZSTD_REP_MOVE + current - matchIndex;
             matches[mnum].len = (U32)matchLength;
             mnum++;
             if (matchLength > ZSTD_OPT_NUM) break;
             if (ip+matchLength == iLimit)   /* equal : no way to know if inf or sup */
-                break;   /* drop, to guarantee consistency (miss a little bit of compression) */
+                break;   /* drop, to preserve bt consistency (miss a little bit of compression) */
         }
 
         if (match[matchLength] < ip[matchLength]) {
@@ -345,7 +361,7 @@ static U32 ZSTD_insertBtAndGetAllMatches (
     *smallerPtr = *largerPtr = 0;
 
 update:
-    zc->nextToUpdate = (matchEndIdx > current + 8) ? matchEndIdx - 8 : current+1;
+    zc->nextToUpdate = (matchEndIdx > current + 8) ? matchEndIdx - 8 : current+1;  /* skip repetitive patterns */
     return mnum;
 }
 
@@ -354,27 +370,31 @@ update:
 static U32 ZSTD_BtGetAllMatches (
                         ZSTD_CCtx* zc,
                         const BYTE* const ip, const BYTE* const iLimit,
-                        const U32 maxNbAttempts, const U32 mls, ZSTD_match_t* matches, const U32 minMatchLen)
+                        const U32 maxNbAttempts, const U32 mls,
+                        U32 rep[ZSTD_REP_NUM], U32 const ll0,
+                        ZSTD_match_t* matches, const U32 minMatchLen)
 {
     if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */
     ZSTD_updateTree(zc, ip, iLimit, maxNbAttempts, mls);
-    return ZSTD_insertBtAndGetAllMatches(zc, ip, iLimit, maxNbAttempts, mls, 0, matches, minMatchLen);
+    return ZSTD_insertBtAndGetAllMatches(zc, ip, iLimit, maxNbAttempts, mls, 0, rep, ll0, matches, minMatchLen);
 }
 
 
 static U32 ZSTD_BtGetAllMatches_selectMLS (
                         ZSTD_CCtx* zc,   /* Index table will be updated */
                         const BYTE* ip, const BYTE* const iHighLimit,
-                        const U32 maxNbAttempts, const U32 matchLengthSearch, ZSTD_match_t* matches, const U32 minMatchLen)
+                        const U32 maxNbAttempts, const U32 matchLengthSearch,
+                        U32 rep[ZSTD_REP_NUM], U32 const ll0,
+                        ZSTD_match_t* matches, const U32 minMatchLen)
 {
     switch(matchLengthSearch)
     {
-    case 3 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 3, matches, minMatchLen);
+    case 3 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 3, rep, ll0, matches, minMatchLen);
     default :
-    case 4 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 4, matches, minMatchLen);
-    case 5 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 5, matches, minMatchLen);
+    case 4 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 4, rep, ll0, matches, minMatchLen);
+    case 5 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 5, rep, ll0, matches, minMatchLen);
     case 7 :
-    case 6 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 6, matches, minMatchLen);
+    case 6 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 6, rep, ll0, matches, minMatchLen);
     }
 }
 
@@ -382,27 +402,31 @@ static U32 ZSTD_BtGetAllMatches_selectMLS (
 static U32 ZSTD_BtGetAllMatches_extDict (
                         ZSTD_CCtx* zc,
                         const BYTE* const ip, const BYTE* const iLimit,
-                        const U32 maxNbAttempts, const U32 mls, ZSTD_match_t* matches, const U32 minMatchLen)
+                        const U32 maxNbAttempts, const U32 mls,
+                        U32 rep[ZSTD_REP_NUM], U32 const ll0,
+                        ZSTD_match_t* matches, const U32 minMatchLen)
 {
     if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */
     ZSTD_updateTree_extDict(zc, ip, iLimit, maxNbAttempts, mls);
-    return ZSTD_insertBtAndGetAllMatches(zc, ip, iLimit, maxNbAttempts, mls, 1, matches, minMatchLen);
+    return ZSTD_insertBtAndGetAllMatches(zc, ip, iLimit, maxNbAttempts, mls, 1, rep, ll0, matches, minMatchLen);
 }
 
 
 static U32 ZSTD_BtGetAllMatches_selectMLS_extDict (
                         ZSTD_CCtx* zc,   /* Index table will be updated */
                         const BYTE* ip, const BYTE* const iHighLimit,
-                        const U32 maxNbAttempts, const U32 matchLengthSearch, ZSTD_match_t* matches, const U32 minMatchLen)
+                        const U32 maxNbAttempts, const U32 matchLengthSearch,
+                        U32 rep[ZSTD_REP_NUM], U32 const ll0,
+                        ZSTD_match_t* matches, const U32 minMatchLen)
 {
     switch(matchLengthSearch)
     {
-    case 3 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 3, matches, minMatchLen);
+    case 3 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 3, rep, ll0, matches, minMatchLen);
     default :
-    case 4 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 4, matches, minMatchLen);
-    case 5 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 5, matches, minMatchLen);
+    case 4 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 4, rep, ll0, matches, minMatchLen);
+    case 5 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 5, rep, ll0, matches, minMatchLen);
     case 7 :
-    case 6 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 6, matches, minMatchLen);
+    case 6 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 6, rep, ll0, matches, minMatchLen);
     }
 }
 
@@ -410,6 +434,42 @@ static U32 ZSTD_BtGetAllMatches_selectMLS_extDict (
 /*-*******************************
 *  Optimal parser
 *********************************/
+typedef struct repcodes_s {
+    U32 rep[3];
+} repcodes_t;
+
+repcodes_t ZSTD_updateRep(U32 const rep[3], U32 const offset, U32 const ll0)
+{
+    repcodes_t newReps;
+    if (offset >= ZSTD_REP_NUM) {  /* full offset */
+        newReps.rep[2] = rep[1];
+        newReps.rep[1] = rep[0];
+        newReps.rep[0] = offset - ZSTD_REP_MOVE;
+    } else {   /* repcode */
+        U32 const repCode = offset + ll0;
+        if (repCode > 0) {  /* note : if repCode==0, no change */
+            U32 const currentOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
+            newReps.rep[2] = (repCode >= 2) ? rep[1] : rep[2];
+            newReps.rep[1] = rep[0];
+            newReps.rep[0] = currentOffset;
+        } else {   /* repCode == 0 */
+            memcpy(&newReps, rep, sizeof(newReps));
+        }
+    }
+    return newReps;
+}
+
+/* update opt[pos] and last_pos */
+#define SET_PRICE(pos, mlen_, offset_, litlen_, price_, rep_) \
+    {                                                         \
+        while (last_pos < pos)  { opt[last_pos+1].price = ZSTD_MAX_PRICE; last_pos++; } \
+        opt[pos].mlen = mlen_;                                \
+        opt[pos].off = offset_;                               \
+        opt[pos].litlen = litlen_;                            \
+        opt[pos].price = price_;                              \
+        memcpy(opt[pos].rep, &rep_, sizeof(rep_));            \
+    }
+
 FORCE_INLINE_TEMPLATE
 size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                                       const void* src, size_t srcSize, const int ultra)
@@ -444,57 +504,49 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
         U32 cur, last_pos = 0;
         U32 best_mlen, best_off;
         U32 const initLL = (U32)(ip - anchor);
+
+        /* find first match */
         memset(opt, 0, sizeof(ZSTD_optimal_t));
 
-        /* check repCode */
         {   U32 const ll0 = !initLL;
-            U32 const lastR = ZSTD_REP_CHECK + ll0;
-            U32 repCode;
-            for (repCode = ll0; repCode < lastR; repCode++) {
-                S32 const repOffset = (repCode==ZSTD_REP_MOVE_OPT) ? (rep[0] - 1) : rep[repCode];
-                if ( (repOffset > 0)
-                  && (repOffset < (S32)(ip-prefixStart))  /* within current mem segment */
-                  && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repOffset, minMatch))) {
-                    U32 repLen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repOffset, iend) + minMatch;
-                    if (repLen > sufficient_len) {
-                        /* large repMatch => immediate encoding */
-                        best_mlen = repLen; best_off = repCode; cur = 0; last_pos = 1;
-                        goto _shortestPath;
-                    }
-                    do {
-                        U32 const repPrice = ZSTD_getPrice(optStatePtr, initLL, anchor, repCode - ll0, repLen, ultra);
-                        if (repLen > last_pos || repPrice < opt[repLen].price)
-                            SET_PRICE(repLen, repLen, repCode, initLL, repPrice);   /* note : macro modifies last_pos */
-                        repLen--;
-                    } while (repLen >= minMatch);
-        }   }   }
+            U32 const nb_matches = ZSTD_BtGetAllMatches_selectMLS(ctx, ip, iend, maxSearches, mls, rep, ll0, matches, minMatch);
 
-        {   U32 const nb_matches = ZSTD_BtGetAllMatches_selectMLS(ctx, ip, iend, maxSearches, mls, matches, minMatch);
+            if (!nb_matches /*no match*/) { ip++; continue; }
+            DEBUGLOG(7, "found %u matches of maxLength=%u and offset=%u at cPos=%u => start new serie",
+                        nb_matches, matches[nb_matches-1].len, matches[nb_matches-1].off, (U32)(ip-prefixStart));
 
-            if (!last_pos /*no repCode*/ && !nb_matches /*no match*/) { ip++; continue; }
-
-            if (nb_matches && (matches[nb_matches-1].len > sufficient_len)) {
-                /* large match => immediate encoding */
+            if (matches[nb_matches-1].len > sufficient_len) {
                 best_mlen = matches[nb_matches-1].len;
                 best_off = matches[nb_matches-1].off;
+                DEBUGLOG(7, "large match (%u>%u), immediate encoding",
+                            best_mlen, sufficient_len);
                 cur = 0;
                 last_pos = 1;
                 goto _shortestPath;
             }
 
             /* set prices for first matches from position == 0 */
-            {   U32 matchNb;
-                U32 pos = last_pos /*some repCode (assumed cheaper)*/ ? last_pos : minMatch;
+            {   U32 pos = minMatch;
+                U32 matchNb;
                 for (matchNb = 0; matchNb < nb_matches; matchNb++) {
+                    U32 const offset = matches[matchNb].off;
                     U32 const end = matches[matchNb].len;
+                    repcodes_t repMatch = ZSTD_updateRep(rep, offset, ll0);
+                    DEBUGLOG(7, "match %u: starting reps=%u,%u,%u ==> %u,%u,%u",
+                                matchNb, rep[0], rep[1], rep[2], repMatch.rep[0], repMatch.rep[1], repMatch.rep[2])
                     while (pos <= end) {
-                        U32 const matchPrice = ZSTD_getPrice(optStatePtr, initLL, anchor, matches[matchNb].off-1, pos, ultra);
-                        if (pos > last_pos || matchPrice < opt[pos].price)
-                            SET_PRICE(pos, pos, matches[matchNb].off, initLL, matchPrice);   /* note : macro modifies last_pos */
+                        U32 const matchPrice = ZSTD_getPrice(optStatePtr, initLL, anchor, offset, pos, ultra);
+                        if (pos > last_pos || matchPrice < opt[pos].price) {
+                            DEBUGLOG(7, "rPos:%u => set initial price : %u",
+                                        pos, matchPrice);
+                            DEBUGLOG(7, "transferring rep:%u,%u,%u",
+                                        repMatch.rep[0], repMatch.rep[1], repMatch.rep[2]);
+                            SET_PRICE(pos, pos, offset, initLL, matchPrice, repMatch);   /* note : macro modifies last_pos */
+                        }
                         pos++;
         }   }   }   }
 
-        if (last_pos < minMatch) { ip++; continue; }
+        assert(last_pos >= minMatch);
 
         /* initialize opt[0] */
         { U32 i ; for (i=0; i<ZSTD_REP_NUM; i++) opt[0].rep[i] = rep[i]; }
@@ -514,74 +566,28 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                 } else {
                     price = ZSTD_getLiteralPrice(optStatePtr, litlen, anchor);
                 }
-                if (cur > last_pos || price <= opt[cur].price)
-                    SET_PRICE(cur, 1, 0, litlen, price);  /* note : macro modifies last_pos */
-            }
+                if (price <= opt[cur].price) {
+                    DEBUGLOG(7, "rPos:%u : better price (%u<%u) using literal",
+                                cur, price, opt[cur].price);
+                    DEBUGLOG(7, "transferring rep:%u,%u,%u",
+                                opt[cur-1].rep[0], opt[cur-1].rep[1], opt[cur-1].rep[2]);
+                    SET_PRICE(cur, 1, 0, litlen, price, opt[cur-1].rep);  /* note : macro modifies last_pos */
+            }   }
 
             if (cur == last_pos) break;
 
             /* last match must start at a minimum distance of 8 from oend */
             if (inr > ilimit) continue;
 
-            /* update repcodes */
-            {   U32 const mlen = opt[cur].mlen;
-                if (opt[cur].off > ZSTD_REP_MOVE_OPT) {
-                    opt[cur].rep[2] = opt[cur-mlen].rep[1];
-                    opt[cur].rep[1] = opt[cur-mlen].rep[0];
-                    opt[cur].rep[0] = opt[cur].off - ZSTD_REP_MOVE_OPT;
-                } else {
-                    opt[cur].rep[2] = (opt[cur].off > 1) ? opt[cur-mlen].rep[1] : opt[cur-mlen].rep[2];
-                    opt[cur].rep[1] = (opt[cur].off > 0) ? opt[cur-mlen].rep[0] : opt[cur-mlen].rep[1];
-                    /* If opt[cur].off == ZSTD_REP_MOVE_OPT, then mlen != 1.
-                     * offset ZSTD_REP_MOVE_OPT is used for the special case
-                     * litLength == 0, where offset 0 means something special.
-                     * mlen == 1 means the previous byte was stored as a literal,
-                     * so they are mutually exclusive.
-                     */
-                    assert(!(opt[cur].off == ZSTD_REP_MOVE_OPT && mlen == 1));
-                    opt[cur].rep[0] = (opt[cur].off == ZSTD_REP_MOVE_OPT) ? (opt[cur-mlen].rep[0] - 1) : (opt[cur-mlen].rep[opt[cur].off]);
-            }   }
-
-            best_mlen = minMatch;
-            {   U32 const ll0 = (opt[cur].mlen != 1);
-                U32 const lastR = ZSTD_REP_CHECK + ll0;
-                U32 repCode4;  /* universal referential */
-                for (repCode4=ll0; repCode4<lastR; repCode4++) {  /* check rep */
-                    const S32 repCur = (repCode4==ZSTD_REP_MOVE_OPT) ? (opt[cur].rep[0] - 1) : opt[cur].rep[repCode4];
-                    if ( (repCur > 0) && (repCur < (S32)(inr-prefixStart))  /* within current mem segment */
-                      && (ZSTD_readMINMATCH(inr, minMatch) == ZSTD_readMINMATCH(inr - repCur, minMatch))) {
-                        U32 matchLength = (U32)ZSTD_count(inr+minMatch, inr+minMatch - repCur, iend) + minMatch;
-                        U32 const repCode3 = repCode4 - ll0;  /* contextual referential, depends on ll0 */
-                        assert(repCode3 < 3);
-
-                        if (matchLength > sufficient_len || cur + matchLength >= ZSTD_OPT_NUM) {
-                            best_mlen = matchLength;
-                            best_off = repCode4;
-                            last_pos = cur + 1;
-                            goto _shortestPath;
-                        }
-
-                        if (matchLength > best_mlen) best_mlen = matchLength;
-
-                        do {
-                            U32 const litlen = ll0 ? 0 : opt[cur].litlen;
-                            U32 price;
-                            if (cur > litlen) {
-                                price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, inr-litlen, repCode3, matchLength, ultra);
-                            } else {
-                                price = ZSTD_getPrice(optStatePtr, litlen, anchor, repCode3, matchLength, ultra);
-                            }
-
-                            if (cur + matchLength > last_pos || price <= opt[cur + matchLength].price)
-                                SET_PRICE(cur + matchLength, matchLength, repCode4, litlen, price);  /* note : macro modifies last_pos */
-                            matchLength--;
-                        } while (matchLength >= minMatch);
-            }   }   }
-
-            {   U32 const nb_matches = ZSTD_BtGetAllMatches_selectMLS(ctx, inr, iend, maxSearches, mls, matches, best_mlen /*largest repLength*/);   /* search for matches larger than repcodes */
+            {   U32 const ll0_cur = (opt[cur].mlen != 1);
+                U32 const nb_matches = ZSTD_BtGetAllMatches_selectMLS(ctx, inr, iend, maxSearches, mls, opt[cur].rep, ll0_cur, matches, minMatch);
                 U32 matchNb;
+                if (!nb_matches) continue;
 
-                if (nb_matches > 0 && (matches[nb_matches-1].len > sufficient_len || cur + matches[nb_matches-1].len >= ZSTD_OPT_NUM)) {
+                DEBUGLOG(7, "rPos:%u, found %u matches, of maxLength=%u",
+                            cur, nb_matches, matches[nb_matches-1].len);
+                if ( (matches[nb_matches-1].len > sufficient_len)
+                  || (cur + matches[nb_matches-1].len >= ZSTD_OPT_NUM) ) {
                     best_mlen = matches[nb_matches-1].len;
                     best_off = matches[nb_matches-1].off;
                     last_pos = cur + 1;
@@ -590,19 +596,27 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
 
                 /* set prices using matches at position = cur */
                 for (matchNb = 0; matchNb < nb_matches; matchNb++) {
-                    U32 mlen = (matchNb>0) ? matches[matchNb-1].len+1 : best_mlen;
+                    U32 mlen = (matchNb>0) ? matches[matchNb-1].len+1 : minMatch;
                     U32 const lastML = matches[matchNb].len;
+                    U32 const offset = matches[matchNb].off;
+                    U32 const litlen = (opt[cur].mlen == 1) ? opt[cur].litlen : 0;
+                    repcodes_t const repMatch = ZSTD_updateRep(opt[cur].rep, offset, ll0_cur);
+
+                    DEBUGLOG(7, "testing match %u => offCode=%u, mlen=%u, llen=%u",
+                                matchNb, matches[matchNb].off, lastML, litlen);
 
                     while (mlen <= lastML) {
-                        U32 const litlen = (opt[cur].mlen == 1) ? opt[cur].litlen : 0;
                         U32 price;
                         if (cur > litlen)
-                            price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, ip+cur-litlen, matches[matchNb].off-1, mlen, ultra);
+                            price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, ip+cur-litlen, offset, mlen, ultra);
                         else
-                            price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[matchNb].off-1, mlen, ultra);
+                            price = ZSTD_getPrice(optStatePtr, litlen, anchor, offset, mlen, ultra);
 
-                        if (cur + mlen > last_pos || (price < opt[cur + mlen].price))
-                            SET_PRICE(cur + mlen, mlen, matches[matchNb].off, litlen, price);  /* note : macro modifies last_pos */
+                        if (cur + mlen > last_pos || (price < opt[cur + mlen].price)) {
+                            DEBUGLOG(7, "rPos:%u => new better price (%u<%u)",
+                                        cur+mlen, price, opt[cur+mlen].price);
+                            SET_PRICE(cur + mlen, mlen, offset, litlen, price, repMatch);  /* note : macro modifies last_pos */
+                        }
 
                         mlen++;
         }   }   }   }
@@ -610,11 +624,15 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
         best_mlen = opt[last_pos].mlen;
         best_off = opt[last_pos].off;
         cur = last_pos - best_mlen;
+        DEBUGLOG(7, "Preparing path selection : last_pos:%u, cur:%u, best_mlen:%u",
+                    last_pos, cur, best_mlen);
 
 _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
         opt[0].mlen = 1;
 
         /* reverse traversal */
+        DEBUGLOG(7, "start reverse traversal (last_pos:%u, cur:%u)",
+                    last_pos, cur);
         {   U32 selected_matchLength = best_mlen;
             U32 selectedOffset = best_off;
             U32 pos = cur;
@@ -639,23 +657,24 @@ _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
                 pos += mlen;
 
                 /* repcodes update */
-                if (offset > ZSTD_REP_MOVE_OPT) {  /* full offset */
+                if (offset >= ZSTD_REP_NUM) {  /* full offset */
                     rep[2] = rep[1];
                     rep[1] = rep[0];
-                    rep[0] = offset - ZSTD_REP_MOVE_OPT;
-                    offset--;
+                    rep[0] = offset - ZSTD_REP_MOVE;
                 } else {   /* repcode */
-                    if (offset != 0) {
-                        U32 const currentOffset = (offset==ZSTD_REP_MOVE_OPT) ? (rep[0] - 1) : rep[offset];
-                        if (offset != 1) rep[2] = rep[1];
+                    U32 const repCode = offset + (litLength==0);
+                    if (repCode) {  /* note : if repCode==0, no change */
+                        U32 const currentOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
+                        if (repCode >= 2) rep[2] = rep[1];
                         rep[1] = rep[0];
                         rep[0] = currentOffset;
                     }
-                    if (litLength==0) offset--;
                 }
 
                 ZSTD_updatePrice(optStatePtr, litLength, anchor, offset, mlen);
                 ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
+                DEBUGLOG(7, "seq: ll:%u,ml:%u,off:%u - rep:%u,%u,%u",
+                            litLength, mlen, offset, rep[0], rep[1], rep[2]);
                 anchor = ip = ip + mlen;
         }   }
     }   /* for (cur=0; cur < last_pos; ) */
@@ -747,12 +766,12 @@ size_t ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
                     do {
                         price = ZSTD_getPrice(optStatePtr, litlen, anchor, best_off, mlen, ultra);
                         if (mlen > last_pos || price < opt[mlen].price)
-                            SET_PRICE(mlen, mlen, i, litlen, price);   /* note : macro modifies last_pos */
+                            SET_PRICE(mlen, mlen, i, litlen, price, rep);   /* note : macro modifies last_pos */
                         mlen--;
                     } while (mlen >= minMatch);
         }   }   }
 
-        match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, ip, iend, maxSearches, mls, matches, minMatch);  /* first search (depth 0) */
+        match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, ip, iend, maxSearches, mls, rep, (ip == anchor), matches, minMatch);  /* first search (depth 0) */
 
         if (!last_pos && !match_num) { ip++; continue; }
 
@@ -777,7 +796,7 @@ size_t ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
             while (mlen <= best_mlen) {
                 price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[u].off-1, mlen, ultra);
                 if (mlen > last_pos || price < opt[mlen].price)
-                    SET_PRICE(mlen, mlen, matches[u].off, litlen, price);
+                    SET_PRICE(mlen, mlen, matches[u].off, litlen, price, rep);
                 mlen++;
         }   }
 
@@ -801,7 +820,7 @@ size_t ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
             }
 
             if (cur > last_pos || price <= opt[cur].price)
-                SET_PRICE(cur, 1, 0, litlen, price);
+                SET_PRICE(cur, 1, 0, litlen, price, rep);
 
             if (cur == last_pos) break;
 
@@ -855,12 +874,12 @@ size_t ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
                             }
 
                             if (cur + mlen > last_pos || price <= opt[cur + mlen].price)
-                                SET_PRICE(cur + mlen, mlen, i, litlen, price);
+                                SET_PRICE(cur + mlen, mlen, i, litlen, price, rep);
                             mlen--;
                         } while (mlen >= minMatch);
             }   }   }
 
-            match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, inr, iend, maxSearches, mls, matches, minMatch);
+            match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, inr, iend, maxSearches, mls, opt[cur].rep, (mlen != 1), matches, minMatch);
 
             if (match_num > 0 && (matches[match_num-1].len > sufficient_len || cur + matches[match_num-1].len >= ZSTD_OPT_NUM)) {
                 best_mlen = matches[match_num-1].len;
@@ -887,7 +906,7 @@ size_t ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
                     }
 
                     if (cur + mlen > last_pos || (price < opt[cur + mlen].price))
-                        SET_PRICE(cur + mlen, mlen, matches[u].off, litlen, price);
+                        SET_PRICE(cur + mlen, mlen, matches[u].off, litlen, price, rep);
 
                     mlen++;
         }   }   }   /* for (cur = 1; cur <= last_pos; cur++) */
diff --git a/programs/bench.c b/programs/bench.c
index 5093f110d..6525f3371 100644
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -416,10 +416,12 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
                             DISPLAY("(sample %u, block %u, pos %u) \n", segNb, bNb, pos);
                             if (u>5) {
                                 int n;
+                                DISPLAY("origin: ");
                                 for (n=-5; n<0; n++) DISPLAY("%02X ", ((const BYTE*)srcBuffer)[u+n]);
                                 DISPLAY(" :%02X:  ", ((const BYTE*)srcBuffer)[u]);
                                 for (n=1; n<3; n++) DISPLAY("%02X ", ((const BYTE*)srcBuffer)[u+n]);
                                 DISPLAY(" \n");
+                                DISPLAY("decode: ");
                                 for (n=-5; n<0; n++) DISPLAY("%02X ", ((const BYTE*)resultBuffer)[u+n]);
                                 DISPLAY(" :%02X:  ", ((const BYTE*)resultBuffer)[u]);
                                 for (n=1; n<3; n++) DISPLAY("%02X ", ((const BYTE*)resultBuffer)[u+n]);

From 4202b2e8a6ba37158b2ec1672a00519c9bc507a6 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 14 Nov 2017 18:08:17 -0800
Subject: [PATCH 046/145] merged rep search into btMatchSearch

but there is a tree corruption somewhere ...
bug hunt ongoing
---
 lib/common/zstd_internal.h            |   7 +-
 lib/compress/zstd_compress.c          |   2 +-
 lib/compress/zstd_compress_internal.h |   4 +-
 lib/compress/zstd_lazy.c              |  10 +-
 lib/compress/zstd_opt.c               | 685 +++++++++-----------------
 5 files changed, 261 insertions(+), 447 deletions(-)

diff --git a/lib/common/zstd_internal.h b/lib/common/zstd_internal.h
index cc5f8e897..ce2b85b4c 100644
--- a/lib/common/zstd_internal.h
+++ b/lib/common/zstd_internal.h
@@ -62,6 +62,10 @@ extern int g_debuglog_enable;
  * 4 : events once per frame
  * 5 : events once per block
  * 6 : events once per sequence (*very* verbose) */
+#  define RAWLOG(l, ...) {                                 \
+                if ((g_debuglog_enable) & (l<=ZSTD_DEBUG)) { \
+                    fprintf(stderr, __VA_ARGS__);            \
+            }   }
 #  define DEBUGLOG(l, ...) {                                 \
                 if ((g_debuglog_enable) & (l<=ZSTD_DEBUG)) { \
                     fprintf(stderr, __FILE__ ": ");          \
@@ -69,7 +73,8 @@ extern int g_debuglog_enable;
                     fprintf(stderr, " \n");                  \
             }   }
 #else
-#  define DEBUGLOG(l, ...)      {}    /* disabled */
+#  define RAWLOG(l, ...)      {}    /* disabled */
+#  define DEBUGLOG(l, ...)    {}    /* disabled */
 #endif
 
 
diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 0045217ba..f49e14b38 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -1386,7 +1386,7 @@ size_t ZSTD_encodeSequences(
             U32  const llBits = LL_bits[llCode];
             U32  const ofBits = ofCode;
             U32  const mlBits = ML_bits[mlCode];
-            DEBUGLOG(6, "encoding: litlen:%u - matchlen:%u - offCode:%u",
+            DEBUGLOG(6, "encoding: litlen:%2u - matchlen:%2u - offCode:%7u",
                         sequences[n].litLength,
                         sequences[n].matchLength + MINMATCH,
                         sequences[n].offset);                               /* 32b*/  /* 64b*/
diff --git a/lib/compress/zstd_compress_internal.h b/lib/compress/zstd_compress_internal.h
index c32626e58..b97cae141 100644
--- a/lib/compress/zstd_compress_internal.h
+++ b/lib/compress/zstd_compress_internal.h
@@ -237,8 +237,8 @@ MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const v
     static const BYTE* g_start = NULL;
     if (g_start==NULL) g_start = (const BYTE*)literals;  /* note : index only works for compression within a single segment */
     {   U32 const pos = (U32)((const BYTE*)literals - g_start);
-        g_debuglog_enable = ((pos >= 1622540) & (pos < 1622575));
-        DEBUGLOG(2, "Cpos%7u :%3u literals, match%3u bytes at distance%7u",
+        g_debuglog_enable = ((pos >= 3670500) & (pos < 3673800));
+        DEBUGLOG(2, "Cpos%7u :%3u literals, match%3u bytes at dist.code%7u",
                pos, (U32)litLength, (U32)mlBase+MINMATCH, (U32)offsetCode);
     }
 #endif
diff --git a/lib/compress/zstd_lazy.c b/lib/compress/zstd_lazy.c
index d80e06f7d..bd6fd7470 100644
--- a/lib/compress/zstd_lazy.c
+++ b/lib/compress/zstd_lazy.c
@@ -157,6 +157,9 @@ static size_t ZSTD_insertBtAndFindBestMatch (
         size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
         const BYTE* match;
 
+        DEBUGLOG(8, "index%7u evaluated during insertion of %u (presumed min matchLength:%3u) ",
+                    matchIndex, current, (U32)matchLength);
+
         if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
             match = base + matchIndex;
             if (match[matchLength] == ip[matchLength])
@@ -173,8 +176,11 @@ static size_t ZSTD_insertBtAndFindBestMatch (
                 matchEndIdx = matchIndex + (U32)matchLength;
             if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(current-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) )
                 bestLength = matchLength, *offsetPtr = ZSTD_REP_MOVE + current - matchIndex;
-            if (ip+matchLength == iend)   /* equal : no way to know if inf or sup */
+            if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */
+                DEBUGLOG(8, "index %u has equal value at length %u as src : cannot determine > or <",
+                            matchIndex, (U32)matchLength);
                 break;   /* drop, to guarantee consistency (miss a little bit of compression) */
+            }
         }
 
         if (match[matchLength] < ip[matchLength]) {
@@ -195,7 +201,7 @@ static size_t ZSTD_insertBtAndFindBestMatch (
 
     *smallerPtr = *largerPtr = 0;
 
-    zc->nextToUpdate = (matchEndIdx > current + 8) ? matchEndIdx - 8 : current+1;
+    zc->nextToUpdate = (matchEndIdx > current + 8) ? matchEndIdx - 8 : current+1;   /* skip repetitive patterns */
     return bestLength;
 }
 
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index 0e8af45d5..ad3cb6c6a 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -17,9 +17,6 @@
 #define ZSTD_FREQ_DIV       4   /* log factor when using previous stats to init next stats */
 #define ZSTD_MAX_PRICE     (1<<30)
 
-#define ZSTD_REP_CHECK    (ZSTD_REP_NUM)    /* number of repcodes to check by the optimal parser */
-#define ZSTD_REP_MOVE_OPT (ZSTD_REP_NUM)
-
 
 /*-*************************************
 *  Price functions for optimal parser
@@ -147,11 +144,11 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr, U32 litLength, const
     U32 const mlBase = matchLength - MINMATCH;
     U32 price;
 
-    if (optPtr->staticPrices)
+    if (optPtr->staticPrices)  /* fixed scheme, do not use statistics */
         return ZSTD_getLiteralPrice(optPtr, litLength, literals) + ZSTD_highbit32((U32)mlBase+1) + 16 + offCode;
 
     price = offCode + optPtr->log2offCodeSum - ZSTD_highbit32(optPtr->offCodeFreq[offCode]+1);
-    if (!ultra && offCode >= 20) price += (offCode-19)*2; /* handicap for long matches, to favor decompression speed */
+    if (!ultra /*static*/ && offCode >= 20) price += (offCode-19)*2; /* handicap for long matches, favor decompression speed */
 
     /* match Length */
     {   U32 const mlCode = ZSTD_MLcode(mlBase);
@@ -159,7 +156,7 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr, U32 litLength, const
     }
 
     price += ZSTD_getLiteralPrice(optPtr, litLength, literals) + optPtr->factor;
-    DEBUGLOG(7, "ZSTD_getPrice(ll:%u, ml:%u) = %u", litLength, matchLength, price);
+    DEBUGLOG(8, "ZSTD_getPrice(ll:%u, ml:%u) = %u", litLength, matchLength, price);
     return price;
 }
 
@@ -197,7 +194,7 @@ static void ZSTD_updatePrice(optState_t* optPtr, U32 litLength, const BYTE* lite
 
 
 /* function safe only for comparisons */
-static U32 ZSTD_readMINMATCH(const void* memPtr, U32 length)
+MEM_STATIC U32 ZSTD_readMINMATCH(const void* memPtr, U32 length)
 {
     switch (length)
     {
@@ -236,8 +233,8 @@ static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* zc, const BYTE* ip)
 ***************************************/
 static U32 ZSTD_insertBtAndGetAllMatches (
                         ZSTD_CCtx* zc,
-                        const BYTE* const ip, const BYTE* const iLimit,
-                        U32 nbCompares, U32 const mls, U32 const extDict,
+                        const BYTE* const ip, const BYTE* const iLimit, const int extDict,
+                        U32 nbCompares, U32 const mls,
                         U32 rep[ZSTD_REP_NUM], U32 const ll0,
                         ZSTD_match_t* matches, const U32 minMatchLen)
 {
@@ -260,14 +257,26 @@ static U32 ZSTD_insertBtAndGetAllMatches (
     const U32 windowLow = zc->lowLimit;
     U32* smallerPtr = bt + 2*(current&btMask);
     U32* largerPtr  = bt + 2*(current&btMask) + 1;
-    U32 matchEndIdx = current+8;
+    U32 matchEndIdx = current+8;   /* farthest referenced position of any match => detects repetitive patterns */
     U32 dummy32;   /* to be nullified at the end */
     U32 mnum = 0;
 
     size_t bestLength = minMatchLen-1;
 
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 8)
+    static const BYTE* g_start = NULL;
+    if (g_start==NULL) g_start = base;  /* note : index only works for compression within a single segment */
+    {   U32 const pos = (U32)(ip - g_start);
+        g_debuglog_enable = (pos==3673728);
+    }
+    if (current == 8793162) g_debuglog_enable = 1;
+#endif
+
+
     /* check repCode */
-    {   U32 const lastR = ZSTD_REP_NUM + ll0;
+#if 0
+    if (!extDict) /*static*/ {
+        U32 const lastR = ZSTD_REP_NUM + ll0;
         U32 repCode;
         for (repCode = ll0; repCode < lastR; repCode++) {
             S32 const repOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
@@ -275,158 +284,221 @@ static U32 ZSTD_insertBtAndGetAllMatches (
               && (repOffset < (S32)(ip-prefixStart))  /* within current mem segment */
               && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repOffset, minMatch))) {
                 U32 const repLen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repOffset, iLimit) + minMatch;
-                /* save better solution */
+                /* save longer solution */
                 if (repLen > bestLength) {
+                    DEBUGLOG(8, "current %u : found rep%u match of size%3u",
+                                current, repCode - ll0, repLen);
                     bestLength = repLen;
                     matches[mnum].off = repCode - ll0;
                     matches[mnum].len = (U32)repLen;
                     mnum++;
-                    if (repLen > ZSTD_OPT_NUM) goto update;
-                    if (ip+repLen == iLimit) goto update; /* best possible, and avoid read overflow*/
-                }
-    }   }   }
+                    if ( (repLen > ZSTD_OPT_NUM)
+                      || (ip+repLen == iLimit) ) {  /* best possible */
+                        return mnum;
+        }   }   }   }
+    } else {   /* extDict */
+        U32 const lastR = ZSTD_REP_NUM + ll0;
+        U32 repCode;
+        for (repCode=ll0; repCode<lastR; repCode++) {
+            const S32 repCur = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
+            const U32 repIndex = (U32)(current - repCur);
+            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
+            const BYTE* const repMatch = repBase + repIndex;
+            if ( (repCur > 0 && repCur <= (S32)current)
+               && (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex>windowLow))  /* intentional overflow */
+               && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {
+                /* repcode detected we should take it */
+                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iLimit;
+                U32 const repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, repEnd, prefixStart) + minMatch;
 
-    if (mls == 3) { /* HC3 match finder */
+                /* save longer solution */
+                if (repLen > bestLength) {
+                    DEBUGLOG(8, "current %u : found rep%u match of size%3u",
+                                current, repCode - ll0, repLen);
+                    bestLength = repLen;
+                    matches[mnum].off = repCode - ll0;
+                    matches[mnum].len = (U32)repLen;
+                    mnum++;
+                    if ( (repLen > ZSTD_OPT_NUM)
+                      || (ip+repLen == iLimit) ) {  /* best possible */
+                        return mnum;
+        }   }   }   }
+    }
+#else
+    (void)ll0; (void)rep; (void)minMatch;
+#endif
+
+#if 1
+    /* HC3 match finder */
+    if ((mls == 3) /*static*/ && (bestLength < mls)) {
         U32 const matchIndex3 = ZSTD_insertAndFindFirstIndexHash3 (zc, ip);
-        if (matchIndex3>windowLow && (current - matchIndex3 < (1<<18))) {
-            const BYTE* match;
-            size_t currentMl = 0;
-            if ((!extDict) || matchIndex3 >= dictLimit) {
-                match = base + matchIndex3;
-                if (match[bestLength] == ip[bestLength]) currentMl = ZSTD_count(ip, match, iLimit);
+        if ((matchIndex3>windowLow)
+          & (current - matchIndex3 < (1<<18)) /*heuristic : longer distance likely too expensive*/ ) {
+            size_t mlen;
+            if ((!extDict) /*static*/ || (matchIndex3 >= dictLimit)) {
+                const BYTE* const match = base + matchIndex3;
+                mlen = ZSTD_count(ip, match, iLimit);
             } else {
-                match = dictBase + matchIndex3;
-                if (ZSTD_readMINMATCH(match, MINMATCH) == ZSTD_readMINMATCH(ip, MINMATCH))    /* assumption : matchIndex3 <= dictLimit-4 (by table construction) */
-                    currentMl = ZSTD_count_2segments(ip+MINMATCH, match+MINMATCH, iLimit, dictEnd, prefixStart) + MINMATCH;
+                const BYTE* const match = dictBase + matchIndex3;
+                mlen = ZSTD_count_2segments(ip, match, iLimit, dictEnd, prefixStart);
             }
 
             /* save best solution */
-            if (currentMl > bestLength) {
-                bestLength = currentMl;
-                matches[mnum].off = ZSTD_REP_MOVE + current - matchIndex3;
-                matches[mnum].len = (U32)currentMl;
-                mnum++;
-                if (currentMl > ZSTD_OPT_NUM) goto update;
-                if (ip+currentMl == iLimit) goto update; /* best possible, and avoid read overflow*/
-            }
-        }
-    }
+            if (mlen >= mls /* == 3 > bestLength */) {
+                DEBUGLOG(8, "current %u : found short match of size%3u at distance%7u",
+                            current, (U32)mlen, current - matchIndex3);
+                bestLength = mlen;
+                assert(current > matchIndex3);
+                assert(mnum==0);  /* no prior solution */
+                matches[0].off = (current - matchIndex3) + ZSTD_REP_MOVE;
+                matches[0].len = (U32)mlen;
+                mnum=1;
+                if ( (mlen > ZSTD_OPT_NUM)
+                  || (ip+mlen == iLimit) ) {  /* best possible */
+                    return mnum;
+    }   }   }   }
+#endif
 
     hashTable[h] = current;   /* Update Hash Table */
 
     while (nbCompares-- && (matchIndex > windowLow)) {
-        U32* nextPtr = bt + 2*(matchIndex & btMask);
+        U32* const nextPtr = bt + 2*(matchIndex & btMask);
         size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
         const BYTE* match;
-
+        assert(current > matchIndex);
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=8)
+        if (matchIndex==5189477) g_debuglog_enable = 1;
+        DEBUGLOG(8, "candidate match at index:%7u; presumed min matchLength:%3u ",
+                    matchIndex, (U32)matchLength);
+#endif
         if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
             match = base + matchIndex;
             if (match[matchLength] == ip[matchLength]) {
                 matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iLimit) +1;
             }
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=8)
+            {   int i;
+                RAWLOG(8, "orig %7u: ", current);
+                for (i=0; i<8; i++) RAWLOG(7," %02X ", ip[i]);
+                RAWLOG(8, " \n");
+                RAWLOG(8, "match%7u: ", matchIndex);
+                for (i=0; i<8; i++) RAWLOG(7," %02X ", match[i]);
+                RAWLOG(8, " \n");
+            }
+#endif
         } else {
             match = dictBase + matchIndex;
             matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dictEnd, prefixStart);
             if (matchIndex+matchLength >= dictLimit)
                 match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=8)
+            if (matchIndex + 8 < dictLimit)
+            {   int i;
+                const BYTE* const ptr = dictBase + matchIndex;
+                RAWLOG(8, "orig %7u: ", current);
+                for (i=0; i<8; i++) RAWLOG(7," %02X ", ip[i]);
+                RAWLOG(8, " \n");
+                RAWLOG(8, "match%7u: ", matchIndex);
+                for (i=0; i<8; i++) RAWLOG(7," %02X ", ptr[i]);
+                RAWLOG(8, " \n");
+            }
+#endif
         }
+        DEBUGLOG(8, "candidate match has length %u (best:%u) ",
+                    (U32)matchLength, (U32)bestLength);
 
         if (matchLength > bestLength) {
-            if (matchLength > matchEndIdx - matchIndex) matchEndIdx = matchIndex + (U32)matchLength;
+            DEBUGLOG(8, "current %u : found longer match of size%3u at distance%7u",
+                        current, (U32)matchLength, current - matchIndex);
+            assert(matchEndIdx > matchIndex);
+            if (matchLength > matchEndIdx - matchIndex)
+                matchEndIdx = matchIndex + (U32)matchLength;
             bestLength = matchLength;
-            matches[mnum].off = ZSTD_REP_MOVE + current - matchIndex;
+            matches[mnum].off = (current - matchIndex) + ZSTD_REP_MOVE;
             matches[mnum].len = (U32)matchLength;
             mnum++;
             if (matchLength > ZSTD_OPT_NUM) break;
-            if (ip+matchLength == iLimit)   /* equal : no way to know if inf or sup */
+            if (ip+matchLength == iLimit) {  /* equal : no way to know if inf or sup */
+                DEBUGLOG(8, "match at index %u has equal value at length %u : cannot determine > or <",
+                            matchIndex, (U32)matchLength);
                 break;   /* drop, to preserve bt consistency (miss a little bit of compression) */
+            }
         }
 
         if (match[matchLength] < ip[matchLength]) {
-            /* match is smaller than current */
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=8)
+            DEBUGLOG(8, "match at index %u is smaller than current (%02X<%02X) (pos%u)",
+                        matchIndex, match[matchLength], ip[matchLength], (U32)matchLength);
+            {   int i;
+                RAWLOG(8, "index %u: ", matchIndex);
+                for (i=0; i<27; i++) RAWLOG(7," %02X ", match[i]);
+                RAWLOG(8, " \n");
+            }
+#endif
             *smallerPtr = matchIndex;             /* update smaller idx */
             commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
             if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
             smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */
             matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=8)
+            DEBUGLOG(8, "selecting larger candidate : ");
+            {   int i;
+                const BYTE* const match2 = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex;
+                RAWLOG(8, "index %u: ", matchIndex);
+                for (i=0; i<27; i++) RAWLOG(7," %02X ", match2[i]);
+                RAWLOG(8, " \n");
+            }
+#endif
         } else {
-            /* match is larger than current */
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=8)
+            DEBUGLOG(8, "match at index %u is larger than current (%02X>%02X) (pos%u)",
+                        matchIndex, match[matchLength], ip[matchLength], (U32)matchLength);
+            {   int i;
+                RAWLOG(8, "index %u: ", matchIndex);
+                for (i=0; i<27; i++) RAWLOG(7," %02X ", match[i]);
+                RAWLOG(8, " \n");
+            }
+#endif
             *largerPtr = matchIndex;
             commonLengthLarger = matchLength;
             if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
             largerPtr = nextPtr;
             matchIndex = nextPtr[0];
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=8)
+            DEBUGLOG(8, "selecting smaller candidate : ");
+            {   int i;
+                const BYTE* const match2 = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex;
+                RAWLOG(8, "index %u: ", matchIndex);
+                for (i=0; i<27; i++) RAWLOG(7," %02X ", match2[i]);
+                RAWLOG(8, " \n");
+            }
+#endif
     }   }
 
     *smallerPtr = *largerPtr = 0;
 
-update:
     zc->nextToUpdate = (matchEndIdx > current + 8) ? matchEndIdx - 8 : current+1;  /* skip repetitive patterns */
     return mnum;
 }
 
 
-/** Tree updater, providing best match */
 static U32 ZSTD_BtGetAllMatches (
-                        ZSTD_CCtx* zc,
-                        const BYTE* const ip, const BYTE* const iLimit,
-                        const U32 maxNbAttempts, const U32 mls,
-                        U32 rep[ZSTD_REP_NUM], U32 const ll0,
-                        ZSTD_match_t* matches, const U32 minMatchLen)
-{
-    if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */
-    ZSTD_updateTree(zc, ip, iLimit, maxNbAttempts, mls);
-    return ZSTD_insertBtAndGetAllMatches(zc, ip, iLimit, maxNbAttempts, mls, 0, rep, ll0, matches, minMatchLen);
-}
-
-
-static U32 ZSTD_BtGetAllMatches_selectMLS (
                         ZSTD_CCtx* zc,   /* Index table will be updated */
-                        const BYTE* ip, const BYTE* const iHighLimit,
+                        const BYTE* ip, const BYTE* const iHighLimit, const int extDict,
                         const U32 maxNbAttempts, const U32 matchLengthSearch,
                         U32 rep[ZSTD_REP_NUM], U32 const ll0,
                         ZSTD_match_t* matches, const U32 minMatchLen)
-{
-    switch(matchLengthSearch)
-    {
-    case 3 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 3, rep, ll0, matches, minMatchLen);
-    default :
-    case 4 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 4, rep, ll0, matches, minMatchLen);
-    case 5 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 5, rep, ll0, matches, minMatchLen);
-    case 7 :
-    case 6 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 6, rep, ll0, matches, minMatchLen);
-    }
-}
-
-/** Tree updater, providing best match */
-static U32 ZSTD_BtGetAllMatches_extDict (
-                        ZSTD_CCtx* zc,
-                        const BYTE* const ip, const BYTE* const iLimit,
-                        const U32 maxNbAttempts, const U32 mls,
-                        U32 rep[ZSTD_REP_NUM], U32 const ll0,
-                        ZSTD_match_t* matches, const U32 minMatchLen)
 {
     if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */
-    ZSTD_updateTree_extDict(zc, ip, iLimit, maxNbAttempts, mls);
-    return ZSTD_insertBtAndGetAllMatches(zc, ip, iLimit, maxNbAttempts, mls, 1, rep, ll0, matches, minMatchLen);
-}
-
-
-static U32 ZSTD_BtGetAllMatches_selectMLS_extDict (
-                        ZSTD_CCtx* zc,   /* Index table will be updated */
-                        const BYTE* ip, const BYTE* const iHighLimit,
-                        const U32 maxNbAttempts, const U32 matchLengthSearch,
-                        U32 rep[ZSTD_REP_NUM], U32 const ll0,
-                        ZSTD_match_t* matches, const U32 minMatchLen)
-{
+    ZSTD_updateTree(zc, ip, iHighLimit, maxNbAttempts, matchLengthSearch);
     switch(matchLengthSearch)
     {
-    case 3 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 3, rep, ll0, matches, minMatchLen);
+    case 3 : return ZSTD_insertBtAndGetAllMatches(zc, ip, iHighLimit, extDict, maxNbAttempts, 3, rep, ll0, matches, minMatchLen);
     default :
-    case 4 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 4, rep, ll0, matches, minMatchLen);
-    case 5 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 5, rep, ll0, matches, minMatchLen);
+    case 4 : return ZSTD_insertBtAndGetAllMatches(zc, ip, iHighLimit, extDict, maxNbAttempts, 4, rep, ll0, matches, minMatchLen);
+    case 5 : return ZSTD_insertBtAndGetAllMatches(zc, ip, iHighLimit, extDict, maxNbAttempts, 5, rep, ll0, matches, minMatchLen);
     case 7 :
-    case 6 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 6, rep, ll0, matches, minMatchLen);
+    case 6 : return ZSTD_insertBtAndGetAllMatches(zc, ip, iHighLimit, extDict, maxNbAttempts, 6, rep, ll0, matches, minMatchLen);
     }
 }
 
@@ -472,7 +544,8 @@ repcodes_t ZSTD_updateRep(U32 const rep[3], U32 const offset, U32 const ll0)
 
 FORCE_INLINE_TEMPLATE
 size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
-                                      const void* src, size_t srcSize, const int ultra)
+                                      const void* src, size_t srcSize,
+                                      const int ultra, const int extDict)
 {
     seqStore_t* const seqStorePtr = &(ctx->seqStore);
     optState_t* const optStatePtr = &(ctx->optState);
@@ -503,55 +576,54 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
     while (ip < ilimit) {
         U32 cur, last_pos = 0;
         U32 best_mlen, best_off;
-        U32 const initLL = (U32)(ip - anchor);
 
         /* find first match */
-        memset(opt, 0, sizeof(ZSTD_optimal_t));
+        {   U32 const litlen = (U32)(ip - anchor);
+            U32 const ll0 = !litlen;
+            U32 const nbMatches = ZSTD_BtGetAllMatches(ctx, ip, iend, extDict, maxSearches, mls, rep, ll0, matches, minMatch);
+            if (!nbMatches) { ip++; continue; }
 
-        {   U32 const ll0 = !initLL;
-            U32 const nb_matches = ZSTD_BtGetAllMatches_selectMLS(ctx, ip, iend, maxSearches, mls, rep, ll0, matches, minMatch);
+            /* initialize opt[0] */
+            { U32 i ; for (i=0; i<ZSTD_REP_NUM; i++) opt[0].rep[i] = rep[i]; }
+            opt[0].mlen = 1;
+            opt[0].litlen = litlen;
 
-            if (!nb_matches /*no match*/) { ip++; continue; }
-            DEBUGLOG(7, "found %u matches of maxLength=%u and offset=%u at cPos=%u => start new serie",
-                        nb_matches, matches[nb_matches-1].len, matches[nb_matches-1].off, (U32)(ip-prefixStart));
+            /* large match -> immediate encoding */
+            {   U32 const maxML = matches[nbMatches-1].len;
+                DEBUGLOG(7, "found %u matches of maxLength=%u and offset=%u at cPos=%u => start new serie",
+                            nbMatches, maxML, matches[nbMatches-1].off, (U32)(ip-prefixStart));
 
-            if (matches[nb_matches-1].len > sufficient_len) {
-                best_mlen = matches[nb_matches-1].len;
-                best_off = matches[nb_matches-1].off;
-                DEBUGLOG(7, "large match (%u>%u), immediate encoding",
-                            best_mlen, sufficient_len);
-                cur = 0;
-                last_pos = 1;
-                goto _shortestPath;
-            }
+                if (maxML > sufficient_len) {
+                    best_mlen = maxML;
+                    best_off = matches[nbMatches-1].off;
+                    DEBUGLOG(7, "large match (%u>%u), immediate encoding",
+                                best_mlen, sufficient_len);
+                    cur = 0;
+                    last_pos = 1;
+                    goto _shortestPath;
+            }   }
 
-            /* set prices for first matches from position == 0 */
+            /* set prices for first matches starting position == 0 */
             {   U32 pos = minMatch;
                 U32 matchNb;
-                for (matchNb = 0; matchNb < nb_matches; matchNb++) {
+                for (matchNb = 0; matchNb < nbMatches; matchNb++) {
                     U32 const offset = matches[matchNb].off;
                     U32 const end = matches[matchNb].len;
-                    repcodes_t repMatch = ZSTD_updateRep(rep, offset, ll0);
+                    repcodes_t const repHistory = ZSTD_updateRep(rep, offset, ll0);
                     DEBUGLOG(7, "match %u: starting reps=%u,%u,%u ==> %u,%u,%u",
-                                matchNb, rep[0], rep[1], rep[2], repMatch.rep[0], repMatch.rep[1], repMatch.rep[2])
+                                matchNb, rep[0], rep[1], rep[2], repHistory.rep[0], repHistory.rep[1], repHistory.rep[2])
                     while (pos <= end) {
-                        U32 const matchPrice = ZSTD_getPrice(optStatePtr, initLL, anchor, offset, pos, ultra);
+                        U32 const matchPrice = ZSTD_getPrice(optStatePtr, litlen, anchor, offset, pos, ultra);
                         if (pos > last_pos || matchPrice < opt[pos].price) {
                             DEBUGLOG(7, "rPos:%u => set initial price : %u",
                                         pos, matchPrice);
                             DEBUGLOG(7, "transferring rep:%u,%u,%u",
-                                        repMatch.rep[0], repMatch.rep[1], repMatch.rep[2]);
-                            SET_PRICE(pos, pos, offset, initLL, matchPrice, repMatch);   /* note : macro modifies last_pos */
+                                        repHistory.rep[0], repHistory.rep[1], repHistory.rep[2]);
+                            SET_PRICE(pos, pos, offset, litlen, matchPrice, repHistory);   /* note : macro modifies last_pos */
                         }
                         pos++;
-        }   }   }   }
-
-        assert(last_pos >= minMatch);
-
-        /* initialize opt[0] */
-        { U32 i ; for (i=0; i<ZSTD_REP_NUM; i++) opt[0].rep[i] = rep[i]; }
-        opt[0].mlen = 1;
-        opt[0].litlen = initLL;
+            }   }   }
+        }
 
         /* check further positions */
         for (cur = 1; cur <= last_pos; cur++) {
@@ -571,7 +643,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                                 cur, price, opt[cur].price);
                     DEBUGLOG(7, "transferring rep:%u,%u,%u",
                                 opt[cur-1].rep[0], opt[cur-1].rep[1], opt[cur-1].rep[2]);
-                    SET_PRICE(cur, 1, 0, litlen, price, opt[cur-1].rep);  /* note : macro modifies last_pos */
+                    SET_PRICE(cur, 1/*mlen*/, 0/*offset*/, litlen, price, opt[cur-1].rep);
             }   }
 
             if (cur == last_pos) break;
@@ -579,43 +651,47 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
             /* last match must start at a minimum distance of 8 from oend */
             if (inr > ilimit) continue;
 
-            {   U32 const ll0_cur = (opt[cur].mlen != 1);
-                U32 const nb_matches = ZSTD_BtGetAllMatches_selectMLS(ctx, inr, iend, maxSearches, mls, opt[cur].rep, ll0_cur, matches, minMatch);
+            {   U32 const ll0 = (opt[cur].mlen != 1);
+                U32 const litlen = (opt[cur].mlen == 1) ? opt[cur].litlen : 0;
+                U32 const basePrice = (cur > litlen) ? opt[cur-litlen].price : 0;
+                const BYTE* const baseLiterals = ip + cur - litlen;
+                U32 const nbMatches = ZSTD_BtGetAllMatches(ctx, inr, iend, extDict, maxSearches, mls, opt[cur].rep, ll0, matches, minMatch);
                 U32 matchNb;
-                if (!nb_matches) continue;
+                if (!nbMatches) continue;
+                assert(baseLiterals >= prefixStart);
 
-                DEBUGLOG(7, "rPos:%u, found %u matches, of maxLength=%u",
-                            cur, nb_matches, matches[nb_matches-1].len);
-                if ( (matches[nb_matches-1].len > sufficient_len)
-                  || (cur + matches[nb_matches-1].len >= ZSTD_OPT_NUM) ) {
-                    best_mlen = matches[nb_matches-1].len;
-                    best_off = matches[nb_matches-1].off;
-                    last_pos = cur + 1;
-                    goto _shortestPath;
+                {   U32 const maxML = matches[nbMatches-1].len;
+                    DEBUGLOG(7, "rPos:%u, found %u matches, of maxLength=%u",
+                                cur, nbMatches, maxML);
+
+                    if ( (maxML > sufficient_len)
+                       | (cur + maxML >= ZSTD_OPT_NUM) ) {
+                        best_mlen = maxML;
+                        best_off = matches[nbMatches-1].off;
+                        last_pos = cur + 1;
+                        goto _shortestPath;
+                    }
                 }
 
-                /* set prices using matches at position = cur */
-                for (matchNb = 0; matchNb < nb_matches; matchNb++) {
+                /* set prices using matches found at position == cur */
+                for (matchNb = 0; matchNb < nbMatches; matchNb++) {
                     U32 mlen = (matchNb>0) ? matches[matchNb-1].len+1 : minMatch;
                     U32 const lastML = matches[matchNb].len;
                     U32 const offset = matches[matchNb].off;
-                    U32 const litlen = (opt[cur].mlen == 1) ? opt[cur].litlen : 0;
-                    repcodes_t const repMatch = ZSTD_updateRep(opt[cur].rep, offset, ll0_cur);
+                    repcodes_t const repHistory = ZSTD_updateRep(opt[cur].rep, offset, ll0);
 
                     DEBUGLOG(7, "testing match %u => offCode=%u, mlen=%u, llen=%u",
                                 matchNb, matches[matchNb].off, lastML, litlen);
 
                     while (mlen <= lastML) {
-                        U32 price;
-                        if (cur > litlen)
-                            price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, ip+cur-litlen, offset, mlen, ultra);
-                        else
-                            price = ZSTD_getPrice(optStatePtr, litlen, anchor, offset, mlen, ultra);
+                        U32 const pos = cur + mlen;
+                        U32 const price = basePrice + ZSTD_getPrice(optStatePtr, litlen, baseLiterals, offset, mlen, ultra);
+                        assert(pos < ZSTD_OPT_NUM);
 
-                        if (cur + mlen > last_pos || (price < opt[cur + mlen].price)) {
+                        if ((pos > last_pos) | (price < opt[pos].price)) {
                             DEBUGLOG(7, "rPos:%u => new better price (%u<%u)",
-                                        cur+mlen, price, opt[cur+mlen].price);
-                            SET_PRICE(cur + mlen, mlen, offset, litlen, price, repMatch);  /* note : macro modifies last_pos */
+                                        pos, price, opt[pos].price);
+                            SET_PRICE(pos, mlen, offset, litlen, price, repHistory);  /* note : macro modifies last_pos */
                         }
 
                         mlen++;
@@ -628,20 +704,20 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                     last_pos, cur, best_mlen);
 
 _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
-        opt[0].mlen = 1;
+        assert(opt[0].mlen == 1);
 
         /* reverse traversal */
         DEBUGLOG(7, "start reverse traversal (last_pos:%u, cur:%u)",
                     last_pos, cur);
-        {   U32 selected_matchLength = best_mlen;
+        {   U32 selectedMatchLength = best_mlen;
             U32 selectedOffset = best_off;
             U32 pos = cur;
             while (1) {
                 U32 const mlen = opt[pos].mlen;
                 U32 const off = opt[pos].off;
-                opt[pos].mlen = selected_matchLength;
+                opt[pos].mlen = selectedMatchLength;
                 opt[pos].off = selectedOffset;
-                selected_matchLength = mlen;
+                selectedMatchLength = mlen;
                 selectedOffset = off;
                 if (mlen > pos) break;
                 pos -= mlen;
@@ -650,19 +726,19 @@ _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
         /* save sequences */
         {   U32 pos;
             for (pos=0; pos < last_pos; ) {
-                U32 const litLength = (U32)(ip - anchor);
+                U32 const llen = (U32)(ip - anchor);
                 U32 const mlen = opt[pos].mlen;
-                U32 offset = opt[pos].off;
-                if (mlen == 1) { ip++; pos++; continue; }
-                pos += mlen;
+                U32 const offset = opt[pos].off;
+                if (mlen == 1) { ip++; pos++; continue; }  /* literal position => move on */
+                pos += mlen; ip += mlen;
 
-                /* repcodes update */
+                /* repcodes update : like ZSTD_updateRep(), but update in place */
                 if (offset >= ZSTD_REP_NUM) {  /* full offset */
                     rep[2] = rep[1];
                     rep[1] = rep[0];
                     rep[0] = offset - ZSTD_REP_MOVE;
                 } else {   /* repcode */
-                    U32 const repCode = offset + (litLength==0);
+                    U32 const repCode = offset + (llen==0);
                     if (repCode) {  /* note : if repCode==0, no change */
                         U32 const currentOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
                         if (repCode >= 2) rep[2] = rep[1];
@@ -671,11 +747,11 @@ _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
                     }
                 }
 
-                ZSTD_updatePrice(optStatePtr, litLength, anchor, offset, mlen);
-                ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
+                ZSTD_updatePrice(optStatePtr, llen, anchor, offset, mlen);
+                ZSTD_storeSeq(seqStorePtr, llen, anchor, offset, mlen-MINMATCH);
                 DEBUGLOG(7, "seq: ll:%u,ml:%u,off:%u - rep:%u,%u,%u",
-                            litLength, mlen, offset, rep[0], rep[1], rep[2]);
-                anchor = ip = ip + mlen;
+                            llen, mlen, offset, rep[0], rep[1], rep[2]);
+                anchor = ip;
         }   }
     }   /* for (cur=0; cur < last_pos; ) */
 
@@ -689,293 +765,20 @@ _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
 
 size_t ZSTD_compressBlock_btopt(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
 {
-    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 0);
+    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 0 /*ultra*/, 0 /*extDict*/);
 }
 
 size_t ZSTD_compressBlock_btultra(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
 {
-    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 1);
+    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 1 /*ultra*/, 0 /*extDict*/);
 }
 
-
-FORCE_INLINE_TEMPLATE
-size_t ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
-                                     const void* src, size_t srcSize, const int ultra)
-{
-    seqStore_t* seqStorePtr = &(ctx->seqStore);
-    optState_t* optStatePtr = &(ctx->optState);
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - 8;
-    const BYTE* const base = ctx->base;
-    const U32 lowestIndex = ctx->lowLimit;
-    const U32 dictLimit = ctx->dictLimit;
-    const BYTE* const prefixStart = base + dictLimit;
-    const BYTE* const dictBase = ctx->dictBase;
-    const BYTE* const dictEnd  = dictBase + dictLimit;
-
-    const U32 maxSearches = 1U << ctx->appliedParams.cParams.searchLog;
-    const U32 sufficient_len = ctx->appliedParams.cParams.targetLength;
-    const U32 mls = ctx->appliedParams.cParams.searchLength;
-    const U32 minMatch = (ctx->appliedParams.cParams.searchLength == 3) ? 3 : 4;
-
-    ZSTD_optimal_t* opt = optStatePtr->priceTable;
-    ZSTD_match_t* matches = optStatePtr->matchTable;
-    const BYTE* inr;
-
-    /* init */
-    U32 offset, rep[ZSTD_REP_NUM];
-    { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) rep[i]=seqStorePtr->rep[i]; }
-
-    ctx->nextToUpdate3 = ctx->nextToUpdate;
-    ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize);
-    ip += (ip==prefixStart);
-
-    /* Match Loop */
-    while (ip < ilimit) {
-        U32 cur, match_num, last_pos, litlen, price;
-        U32 u, mlen, best_mlen, best_off, litLength;
-        U32 current = (U32)(ip-base);
-        memset(opt, 0, sizeof(ZSTD_optimal_t));
-        last_pos = 0;
-        opt[0].litlen = (U32)(ip - anchor);
-
-        /* check repCode */
-        {   U32 i, last_i = ZSTD_REP_CHECK + (ip==anchor);
-            for (i = (ip==anchor); i<last_i; i++) {
-                const S32 repCur = (i==ZSTD_REP_MOVE_OPT) ? (rep[0] - 1) : rep[i];
-                const U32 repIndex = (U32)(current - repCur);
-                const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
-                const BYTE* const repMatch = repBase + repIndex;
-                if ( (repCur > 0 && repCur <= (S32)current)
-                   && (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex>lowestIndex))  /* intentional overflow */
-                   && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {
-                    /* repcode detected we should take it */
-                    const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
-                    mlen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iend, repEnd, prefixStart) + minMatch;
-
-                    if (mlen > sufficient_len || mlen >= ZSTD_OPT_NUM) {
-                        best_mlen = mlen; best_off = i; cur = 0; last_pos = 1;
-                        goto _storeSequence;
-                    }
-
-                    best_off = i - (ip==anchor);
-                    litlen = opt[0].litlen;
-                    do {
-                        price = ZSTD_getPrice(optStatePtr, litlen, anchor, best_off, mlen, ultra);
-                        if (mlen > last_pos || price < opt[mlen].price)
-                            SET_PRICE(mlen, mlen, i, litlen, price, rep);   /* note : macro modifies last_pos */
-                        mlen--;
-                    } while (mlen >= minMatch);
-        }   }   }
-
-        match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, ip, iend, maxSearches, mls, rep, (ip == anchor), matches, minMatch);  /* first search (depth 0) */
-
-        if (!last_pos && !match_num) { ip++; continue; }
-
-        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) opt[0].rep[i] = rep[i]; }
-        opt[0].mlen = 1;
-
-        if (match_num && (matches[match_num-1].len > sufficient_len || matches[match_num-1].len >= ZSTD_OPT_NUM)) {
-            best_mlen = matches[match_num-1].len;
-            best_off = matches[match_num-1].off;
-            cur = 0;
-            last_pos = 1;
-            goto _storeSequence;
-        }
-
-        best_mlen = (last_pos) ? last_pos : minMatch;
-
-        /* set prices using matches at position = 0 */
-        for (u = 0; u < match_num; u++) {
-            mlen = (u>0) ? matches[u-1].len+1 : best_mlen;
-            best_mlen = matches[u].len;
-            litlen = opt[0].litlen;
-            while (mlen <= best_mlen) {
-                price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[u].off-1, mlen, ultra);
-                if (mlen > last_pos || price < opt[mlen].price)
-                    SET_PRICE(mlen, mlen, matches[u].off, litlen, price, rep);
-                mlen++;
-        }   }
-
-        if (last_pos < minMatch) {
-            ip++; continue;
-        }
-
-        /* check further positions */
-        for (cur = 1; cur <= last_pos; cur++) {
-            inr = ip + cur;
-
-            if (opt[cur-1].mlen == 1) {
-                litlen = opt[cur-1].litlen + 1;
-                if (cur > litlen) {
-                    price = opt[cur - litlen].price + ZSTD_getLiteralPrice(optStatePtr, litlen, inr-litlen);
-                } else
-                    price = ZSTD_getLiteralPrice(optStatePtr, litlen, anchor);
-            } else {
-                litlen = 1;
-                price = opt[cur - 1].price + ZSTD_getLiteralPrice(optStatePtr, litlen, inr-1);
-            }
-
-            if (cur > last_pos || price <= opt[cur].price)
-                SET_PRICE(cur, 1, 0, litlen, price, rep);
-
-            if (cur == last_pos) break;
-
-            if (inr > ilimit)  /* last match must start at a minimum distance of 8 from oend */
-                continue;
-
-            mlen = opt[cur].mlen;
-            if (opt[cur].off > ZSTD_REP_MOVE_OPT) {
-                opt[cur].rep[2] = opt[cur-mlen].rep[1];
-                opt[cur].rep[1] = opt[cur-mlen].rep[0];
-                opt[cur].rep[0] = opt[cur].off - ZSTD_REP_MOVE_OPT;
-            } else {
-                opt[cur].rep[2] = (opt[cur].off > 1) ? opt[cur-mlen].rep[1] : opt[cur-mlen].rep[2];
-                opt[cur].rep[1] = (opt[cur].off > 0) ? opt[cur-mlen].rep[0] : opt[cur-mlen].rep[1];
-                assert(!(opt[cur].off == ZSTD_REP_MOVE_OPT && mlen == 1));
-                opt[cur].rep[0] = (opt[cur].off == ZSTD_REP_MOVE_OPT) ? (opt[cur-mlen].rep[0] - 1) : (opt[cur-mlen].rep[opt[cur].off]);
-            }
-
-            best_mlen = minMatch;
-            {   U32 i, last_i = ZSTD_REP_CHECK + (mlen != 1);
-                for (i = (mlen != 1); i<last_i; i++) {
-                    const S32 repCur = (i==ZSTD_REP_MOVE_OPT) ? (opt[cur].rep[0] - 1) : opt[cur].rep[i];
-                    const U32 repIndex = (U32)(current+cur - repCur);
-                    const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
-                    const BYTE* const repMatch = repBase + repIndex;
-                    if ( (repCur > 0 && repCur <= (S32)(current+cur))
-                      && (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex>lowestIndex))  /* intentional overflow */
-                      && (ZSTD_readMINMATCH(inr, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {
-                        /* repcode detected */
-                        const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
-                        mlen = (U32)ZSTD_count_2segments(inr+minMatch, repMatch+minMatch, iend, repEnd, prefixStart) + minMatch;
-
-                        if (mlen > sufficient_len || cur + mlen >= ZSTD_OPT_NUM) {
-                            best_mlen = mlen; best_off = i; last_pos = cur + 1;
-                            goto _storeSequence;
-                        }
-
-                        best_off = i - (opt[cur].mlen != 1);
-                        if (mlen > best_mlen) best_mlen = mlen;
-
-                        do {
-                            if (opt[cur].mlen == 1) {
-                                litlen = opt[cur].litlen;
-                                if (cur > litlen) {
-                                    price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, inr-litlen, best_off, mlen, ultra);
-                                } else
-                                    price = ZSTD_getPrice(optStatePtr, litlen, anchor, best_off, mlen, ultra);
-                            } else {
-                                litlen = 0;
-                                price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, best_off, mlen, ultra);
-                            }
-
-                            if (cur + mlen > last_pos || price <= opt[cur + mlen].price)
-                                SET_PRICE(cur + mlen, mlen, i, litlen, price, rep);
-                            mlen--;
-                        } while (mlen >= minMatch);
-            }   }   }
-
-            match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, inr, iend, maxSearches, mls, opt[cur].rep, (mlen != 1), matches, minMatch);
-
-            if (match_num > 0 && (matches[match_num-1].len > sufficient_len || cur + matches[match_num-1].len >= ZSTD_OPT_NUM)) {
-                best_mlen = matches[match_num-1].len;
-                best_off = matches[match_num-1].off;
-                last_pos = cur + 1;
-                goto _storeSequence;
-            }
-
-            /* set prices using matches at position = cur */
-            for (u = 0; u < match_num; u++) {
-                mlen = (u>0) ? matches[u-1].len+1 : best_mlen;
-                best_mlen = matches[u].len;
-
-                while (mlen <= best_mlen) {
-                    if (opt[cur].mlen == 1) {
-                        litlen = opt[cur].litlen;
-                        if (cur > litlen)
-                            price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, ip+cur-litlen, matches[u].off-1, mlen, ultra);
-                        else
-                            price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[u].off-1, mlen, ultra);
-                    } else {
-                        litlen = 0;
-                        price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, matches[u].off-1, mlen, ultra);
-                    }
-
-                    if (cur + mlen > last_pos || (price < opt[cur + mlen].price))
-                        SET_PRICE(cur + mlen, mlen, matches[u].off, litlen, price, rep);
-
-                    mlen++;
-        }   }   }   /* for (cur = 1; cur <= last_pos; cur++) */
-
-        best_mlen = opt[last_pos].mlen;
-        best_off = opt[last_pos].off;
-        cur = last_pos - best_mlen;
-
-        /* store sequence */
-_storeSequence:   /* cur, last_pos, best_mlen, best_off have to be set */
-        opt[0].mlen = 1;
-
-        while (1) {
-            mlen = opt[cur].mlen;
-            offset = opt[cur].off;
-            opt[cur].mlen = best_mlen;
-            opt[cur].off = best_off;
-            best_mlen = mlen;
-            best_off = offset;
-            if (mlen > cur) break;
-            cur -= mlen;
-        }
-
-        for (u = 0; u <= last_pos; ) {
-            u += opt[u].mlen;
-        }
-
-        for (cur=0; cur < last_pos; ) {
-            mlen = opt[cur].mlen;
-            if (mlen == 1) { ip++; cur++; continue; }
-            offset = opt[cur].off;
-            cur += mlen;
-            litLength = (U32)(ip - anchor);
-
-            if (offset > ZSTD_REP_MOVE_OPT) {
-                rep[2] = rep[1];
-                rep[1] = rep[0];
-                rep[0] = offset - ZSTD_REP_MOVE_OPT;
-                offset--;
-            } else {
-                if (offset != 0) {
-                    best_off = (offset==ZSTD_REP_MOVE_OPT) ? (rep[0] - 1) : (rep[offset]);
-                    if (offset != 1) rep[2] = rep[1];
-                    rep[1] = rep[0];
-                    rep[0] = best_off;
-                }
-
-                if (litLength==0) offset--;
-            }
-
-            ZSTD_updatePrice(optStatePtr, litLength, anchor, offset, mlen);
-            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
-            anchor = ip = ip + mlen;
-    }    }   /* for (cur=0; cur < last_pos; ) */
-
-    /* Save reps for next block */
-    { int i; for (i=0; i<ZSTD_REP_NUM; i++) seqStorePtr->repToConfirm[i] = rep[i]; }
-
-    /* Return the last literals size */
-    return iend - anchor;
-}
-
-
 size_t ZSTD_compressBlock_btopt_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
 {
-    return ZSTD_compressBlock_opt_extDict_generic(ctx, src, srcSize, 0);
+    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 0 /*ultra*/, 1 /*extDict*/);
 }
 
 size_t ZSTD_compressBlock_btultra_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
 {
-    return ZSTD_compressBlock_opt_extDict_generic(ctx, src, srcSize, 1);
+    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 1 /*ultra*/, 1 /*extDict*/);
 }

From 046ea53bef3d471a429d4b02a7fa578aed80fdea Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 15 Nov 2017 11:29:24 -0800
Subject: [PATCH 047/145] still fighting data corruption

due to messed up tree.
Seems to happen when reaching end of buffer.
---
 lib/compress/zstd_compress_internal.h |  4 +--
 lib/compress/zstd_lazy.c              | 45 +++++++++++++++++++++++----
 lib/compress/zstd_opt.c               | 44 ++++++++++++++++----------
 3 files changed, 68 insertions(+), 25 deletions(-)

diff --git a/lib/compress/zstd_compress_internal.h b/lib/compress/zstd_compress_internal.h
index b97cae141..a9ef7ad1c 100644
--- a/lib/compress/zstd_compress_internal.h
+++ b/lib/compress/zstd_compress_internal.h
@@ -233,12 +233,12 @@ MEM_STATIC U32 ZSTD_MLcode(U32 mlBase)
 */
 MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const void* literals, U32 offsetCode, size_t mlBase)
 {
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 2)
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 6)
     static const BYTE* g_start = NULL;
     if (g_start==NULL) g_start = (const BYTE*)literals;  /* note : index only works for compression within a single segment */
     {   U32 const pos = (U32)((const BYTE*)literals - g_start);
         g_debuglog_enable = ((pos >= 3670500) & (pos < 3673800));
-        DEBUGLOG(2, "Cpos%7u :%3u literals, match%3u bytes at dist.code%7u",
+        DEBUGLOG(6, "Cpos%7u :%3u literals, match%3u bytes at dist.code%7u",
                pos, (U32)litLength, (U32)mlBase+MINMATCH, (U32)offsetCode);
     }
 #endif
diff --git a/lib/compress/zstd_lazy.c b/lib/compress/zstd_lazy.c
index bd6fd7470..ee14bd4ac 100644
--- a/lib/compress/zstd_lazy.c
+++ b/lib/compress/zstd_lazy.c
@@ -50,6 +50,14 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, co
     predictedLarge += (predictedLarge>0);
 #endif /* ZSTD_C_PREDICT */
 
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 2)
+    g_debuglog_enable = (current <=  8530000);
+#endif
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 8)
+    g_debuglog_enable = (current ==  5202593);
+#endif
+    DEBUGLOG(8, "ZSTD_insertBt1 (%u)", current);
+
     assert(ip <= iend-8);   /* required for h calculation */
     hashTable[h] = current;   /* Update Hash Table */
 
@@ -57,6 +65,12 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, co
         U32* const nextPtr = bt + 2*(matchIndex & btMask);
         size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
 
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 8)
+        if (current ==  5189477) g_debuglog_enable = 1;
+#endif
+        DEBUGLOG(8, "index%8u evaluated during insertion of %u (presumed min matchLength:%3u) ",
+                    matchIndex, current, (U32)matchLength);
+
 #ifdef ZSTD_C_PREDICT   /* note : can create issues when hlog small <= 11 */
         const U32* predictPtr = bt + 2*((matchIndex-1) & btMask);   /* written this way, as bt is a roll buffer */
         if (matchIndex == predictedSmall) {
@@ -79,26 +93,48 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, co
 #endif
         if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
             match = base + matchIndex;
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=2)
+            {   size_t const controlSize = ZSTD_count(ip, match, iend);
+                if (controlSize < matchLength) {
+                    DEBUGLOG(2, "Warning !! => matchIndex %u while inserting %u within prefix is smaller than minimum expectation (%u<%u) !",
+                                matchIndex, current, (U32)controlSize, (U32)matchLength);
+            }   }
+#endif
             if (match[matchLength] == ip[matchLength])
                 matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iend) +1;
         } else {
             match = dictBase + matchIndex;
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=2)
+            {   size_t const controlSize = ZSTD_count_2segments(ip, match, iend, dictEnd, prefixStart);
+                if (controlSize < matchLength) {
+                    DEBUGLOG(2, "Warning !! => matchIndex %u while inserting %u into _extDict is smaller than minimum expectation (%u<%u) !",
+                                matchIndex, current, (U32)controlSize, (U32)matchLength);
+            }   }
+#endif
             matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
             if (matchIndex+matchLength >= dictLimit)
                 match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */
         }
 
+        DEBUGLOG(8, "matchIndex%8u has %u bytes in common with %u ",
+                    matchIndex, (U32)matchLength, current);
+
         if (matchLength > bestLength) {
             bestLength = matchLength;
             if (matchLength > matchEndIdx - matchIndex)
                 matchEndIdx = matchIndex + (U32)matchLength;
         }
 
-        if (ip+matchLength == iend)   /* equal : no way to know if inf or sup */
+        if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */
+            DEBUGLOG(8, "index %u has equal value at length %u as src : cannot determine > or <",
+                        matchIndex, (U32)matchLength);
             break;   /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */
+        }
 
         if (match[matchLength] < ip[matchLength]) {  /* necessarily within buffer */
             /* match+1 is smaller than current */
+            DEBUGLOG(8, "matchIndex%8u is smaller than %u (%u < %u)",
+                        matchIndex, current, match[matchLength], ip[matchLength]);
             *smallerPtr = matchIndex;             /* update smaller idx */
             commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
             if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop searching */
@@ -106,6 +142,8 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, co
             matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
         } else {
             /* match is larger than current */
+            DEBUGLOG(8, "matchIndex%8u is larger than %u (%u < %u)",
+                        matchIndex, current, match[matchLength], ip[matchLength]);
             *largerPtr = matchIndex;
             commonLengthLarger = matchLength;
             if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop searching */
@@ -157,9 +195,6 @@ static size_t ZSTD_insertBtAndFindBestMatch (
         size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
         const BYTE* match;
 
-        DEBUGLOG(8, "index%7u evaluated during insertion of %u (presumed min matchLength:%3u) ",
-                    matchIndex, current, (U32)matchLength);
-
         if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
             match = base + matchIndex;
             if (match[matchLength] == ip[matchLength])
@@ -177,8 +212,6 @@ static size_t ZSTD_insertBtAndFindBestMatch (
             if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(current-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) )
                 bestLength = matchLength, *offsetPtr = ZSTD_REP_MOVE + current - matchIndex;
             if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */
-                DEBUGLOG(8, "index %u has equal value at length %u as src : cannot determine > or <",
-                            matchIndex, (U32)matchLength);
                 break;   /* drop, to guarantee consistency (miss a little bit of compression) */
             }
         }
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index ad3cb6c6a..b7d4ed198 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -264,15 +264,11 @@ static U32 ZSTD_insertBtAndGetAllMatches (
     size_t bestLength = minMatchLen-1;
 
 #if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 8)
-    static const BYTE* g_start = NULL;
-    if (g_start==NULL) g_start = base;  /* note : index only works for compression within a single segment */
-    {   U32 const pos = (U32)(ip - g_start);
-        g_debuglog_enable = (pos==3673728);
-    }
-    if (current == 8793162) g_debuglog_enable = 1;
+    g_debuglog_enable = (current ==  5202593);
+    //g_debuglog_enable = (current ==  8845622);
+    //if (current == 12193408) g_debuglog_enable = 1;
 #endif
 
-
     /* check repCode */
 #if 0
     if (!extDict) /*static*/ {
@@ -293,7 +289,7 @@ static U32 ZSTD_insertBtAndGetAllMatches (
                     matches[mnum].len = (U32)repLen;
                     mnum++;
                     if ( (repLen > ZSTD_OPT_NUM)
-                      || (ip+repLen == iLimit) ) {  /* best possible */
+                       | (ip+repLen == iLimit) ) {  /* best possible */
                         return mnum;
         }   }   }   }
     } else {   /* extDict */
@@ -320,7 +316,7 @@ static U32 ZSTD_insertBtAndGetAllMatches (
                     matches[mnum].len = (U32)repLen;
                     mnum++;
                     if ( (repLen > ZSTD_OPT_NUM)
-                      || (ip+repLen == iLimit) ) {  /* best possible */
+                       | (ip+repLen == iLimit) ) {  /* best possible */
                         return mnum;
         }   }   }   }
     }
@@ -352,10 +348,10 @@ static U32 ZSTD_insertBtAndGetAllMatches (
                 assert(mnum==0);  /* no prior solution */
                 matches[0].off = (current - matchIndex3) + ZSTD_REP_MOVE;
                 matches[0].len = (U32)mlen;
-                mnum=1;
+                mnum = 1;
                 if ( (mlen > ZSTD_OPT_NUM)
-                  || (ip+mlen == iLimit) ) {  /* best possible */
-                    return mnum;
+                   | (ip+mlen == iLimit) ) {  /* best possible */
+                    return 1;
     }   }   }   }
 #endif
 
@@ -373,6 +369,13 @@ static U32 ZSTD_insertBtAndGetAllMatches (
 #endif
         if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
             match = base + matchIndex;
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=2)
+            {   size_t const controlSize = ZSTD_count(ip, match, iLimit);
+                if (controlSize < matchLength) {
+                    DEBUGLOG(2, "Warning !! => matchIndex %u while searching %u within prefix is smaller than minimum expectation (%u<%u) !",
+                                matchIndex, current, (U32)controlSize, (U32)matchLength);
+            }   }
+#endif
             if (match[matchLength] == ip[matchLength]) {
                 matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iLimit) +1;
             }
@@ -388,9 +391,16 @@ static U32 ZSTD_insertBtAndGetAllMatches (
 #endif
         } else {
             match = dictBase + matchIndex;
+#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=2)
+            {   size_t const controlSize = ZSTD_count_2segments(ip, match, iLimit, dictEnd, prefixStart);
+                if (controlSize < matchLength) {
+                    DEBUGLOG(2, "Warning !! => matchIndex %u while searching %u into _extDict is smaller than minimum expectation (%u<%u) !",
+                                matchIndex, current, (U32)controlSize, (U32)matchLength);
+            }   }
+#endif
             matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dictEnd, prefixStart);
             if (matchIndex+matchLength >= dictLimit)
-                match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */
+                match = base + matchIndex;   /* prepare for match[matchLength] */
 #if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=8)
             if (matchIndex + 8 < dictLimit)
             {   int i;
@@ -431,7 +441,7 @@ static U32 ZSTD_insertBtAndGetAllMatches (
                         matchIndex, match[matchLength], ip[matchLength], (U32)matchLength);
             {   int i;
                 RAWLOG(8, "index %u: ", matchIndex);
-                for (i=0; i<27; i++) RAWLOG(7," %02X ", match[i]);
+                for (i=0; i<18; i++) RAWLOG(7," %02X ", match[i]);
                 RAWLOG(8, " \n");
             }
 #endif
@@ -445,7 +455,7 @@ static U32 ZSTD_insertBtAndGetAllMatches (
             {   int i;
                 const BYTE* const match2 = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex;
                 RAWLOG(8, "index %u: ", matchIndex);
-                for (i=0; i<27; i++) RAWLOG(7," %02X ", match2[i]);
+                for (i=0; i<18; i++) RAWLOG(7," %02X ", match2[i]);
                 RAWLOG(8, " \n");
             }
 #endif
@@ -455,7 +465,7 @@ static U32 ZSTD_insertBtAndGetAllMatches (
                         matchIndex, match[matchLength], ip[matchLength], (U32)matchLength);
             {   int i;
                 RAWLOG(8, "index %u: ", matchIndex);
-                for (i=0; i<27; i++) RAWLOG(7," %02X ", match[i]);
+                for (i=0; i<18; i++) RAWLOG(7," %02X ", match[i]);
                 RAWLOG(8, " \n");
             }
 #endif
@@ -469,7 +479,7 @@ static U32 ZSTD_insertBtAndGetAllMatches (
             {   int i;
                 const BYTE* const match2 = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex;
                 RAWLOG(8, "index %u: ", matchIndex);
-                for (i=0; i<27; i++) RAWLOG(7," %02X ", match2[i]);
+                for (i=0; i<18; i++) RAWLOG(7," %02X ", match2[i]);
                 RAWLOG(8, " \n");
             }
 #endif

From d7e9805028e4bc5b498edc97a1a8e28945519d8d Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 15 Nov 2017 13:44:24 -0800
Subject: [PATCH 048/145] fixed corruption issue

---
 lib/compress/zstd_lazy.c |  43 ++--------------
 lib/compress/zstd_opt.c  | 108 ++++-----------------------------------
 2 files changed, 16 insertions(+), 135 deletions(-)

diff --git a/lib/compress/zstd_lazy.c b/lib/compress/zstd_lazy.c
index ee14bd4ac..2794d99bc 100644
--- a/lib/compress/zstd_lazy.c
+++ b/lib/compress/zstd_lazy.c
@@ -50,12 +50,6 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, co
     predictedLarge += (predictedLarge>0);
 #endif /* ZSTD_C_PREDICT */
 
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 2)
-    g_debuglog_enable = (current <=  8530000);
-#endif
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 8)
-    g_debuglog_enable = (current ==  5202593);
-#endif
     DEBUGLOG(8, "ZSTD_insertBt1 (%u)", current);
 
     assert(ip <= iend-8);   /* required for h calculation */
@@ -65,12 +59,6 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, co
         U32* const nextPtr = bt + 2*(matchIndex & btMask);
         size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
 
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 8)
-        if (current ==  5189477) g_debuglog_enable = 1;
-#endif
-        DEBUGLOG(8, "index%8u evaluated during insertion of %u (presumed min matchLength:%3u) ",
-                    matchIndex, current, (U32)matchLength);
-
 #ifdef ZSTD_C_PREDICT   /* note : can create issues when hlog small <= 11 */
         const U32* predictPtr = bt + 2*((matchIndex-1) & btMask);   /* written this way, as bt is a roll buffer */
         if (matchIndex == predictedSmall) {
@@ -91,34 +79,19 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, co
             continue;
         }
 #endif
+
         if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
+            assert(matchIndex+matchLength >= dictLimit);   /* might be wrong if extDict is incorrectly set to 0 */
             match = base + matchIndex;
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=2)
-            {   size_t const controlSize = ZSTD_count(ip, match, iend);
-                if (controlSize < matchLength) {
-                    DEBUGLOG(2, "Warning !! => matchIndex %u while inserting %u within prefix is smaller than minimum expectation (%u<%u) !",
-                                matchIndex, current, (U32)controlSize, (U32)matchLength);
-            }   }
-#endif
             if (match[matchLength] == ip[matchLength])
                 matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iend) +1;
         } else {
             match = dictBase + matchIndex;
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=2)
-            {   size_t const controlSize = ZSTD_count_2segments(ip, match, iend, dictEnd, prefixStart);
-                if (controlSize < matchLength) {
-                    DEBUGLOG(2, "Warning !! => matchIndex %u while inserting %u into _extDict is smaller than minimum expectation (%u<%u) !",
-                                matchIndex, current, (U32)controlSize, (U32)matchLength);
-            }   }
-#endif
             matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
             if (matchIndex+matchLength >= dictLimit)
                 match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */
         }
 
-        DEBUGLOG(8, "matchIndex%8u has %u bytes in common with %u ",
-                    matchIndex, (U32)matchLength, current);
-
         if (matchLength > bestLength) {
             bestLength = matchLength;
             if (matchLength > matchEndIdx - matchIndex)
@@ -126,24 +99,18 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, co
         }
 
         if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */
-            DEBUGLOG(8, "index %u has equal value at length %u as src : cannot determine > or <",
-                        matchIndex, (U32)matchLength);
             break;   /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */
         }
 
         if (match[matchLength] < ip[matchLength]) {  /* necessarily within buffer */
-            /* match+1 is smaller than current */
-            DEBUGLOG(8, "matchIndex%8u is smaller than %u (%u < %u)",
-                        matchIndex, current, match[matchLength], ip[matchLength]);
+            /* match is smaller than current */
             *smallerPtr = matchIndex;             /* update smaller idx */
             commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
             if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop searching */
-            smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */
-            matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
+            smallerPtr = nextPtr+1;               /* new "candidate" => larger than match, which was smaller than target */
+            matchIndex = nextPtr[1];              /* new matchIndex, larger than previous and closer to current */
         } else {
             /* match is larger than current */
-            DEBUGLOG(8, "matchIndex%8u is larger than %u (%u < %u)",
-                        matchIndex, current, match[matchLength], ip[matchLength]);
             *largerPtr = matchIndex;
             commonLengthLarger = matchLength;
             if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop searching */
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index b7d4ed198..5c65ed720 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -231,7 +231,8 @@ static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* zc, const BYTE* ip)
 /*-*************************************
 *  Binary Tree search
 ***************************************/
-static U32 ZSTD_insertBtAndGetAllMatches (
+FORCE_INLINE_TEMPLATE
+ U32 ZSTD_insertBtAndGetAllMatches (
                         ZSTD_CCtx* zc,
                         const BYTE* const ip, const BYTE* const iLimit, const int extDict,
                         U32 nbCompares, U32 const mls,
@@ -263,14 +264,8 @@ static U32 ZSTD_insertBtAndGetAllMatches (
 
     size_t bestLength = minMatchLen-1;
 
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG >= 8)
-    g_debuglog_enable = (current ==  5202593);
-    //g_debuglog_enable = (current ==  8845622);
-    //if (current == 12193408) g_debuglog_enable = 1;
-#endif
-
     /* check repCode */
-#if 0
+#if 1
     if (!extDict) /*static*/ {
         U32 const lastR = ZSTD_REP_NUM + ll0;
         U32 repCode;
@@ -324,7 +319,6 @@ static U32 ZSTD_insertBtAndGetAllMatches (
     (void)ll0; (void)rep; (void)minMatch;
 #endif
 
-#if 1
     /* HC3 match finder */
     if ((mls == 3) /*static*/ && (bestLength < mls)) {
         U32 const matchIndex3 = ZSTD_insertAndFindFirstIndexHash3 (zc, ip);
@@ -353,7 +347,6 @@ static U32 ZSTD_insertBtAndGetAllMatches (
                    | (ip+mlen == iLimit) ) {  /* best possible */
                     return 1;
     }   }   }   }
-#endif
 
     hashTable[h] = current;   /* Update Hash Table */
 
@@ -362,64 +355,21 @@ static U32 ZSTD_insertBtAndGetAllMatches (
         size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
         const BYTE* match;
         assert(current > matchIndex);
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=8)
-        if (matchIndex==5189477) g_debuglog_enable = 1;
-        DEBUGLOG(8, "candidate match at index:%7u; presumed min matchLength:%3u ",
-                    matchIndex, (U32)matchLength);
-#endif
+
         if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
+            assert(matchIndex+matchLength >= dictLimit);  /* ensure the condition is correct when !extDict */
             match = base + matchIndex;
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=2)
-            {   size_t const controlSize = ZSTD_count(ip, match, iLimit);
-                if (controlSize < matchLength) {
-                    DEBUGLOG(2, "Warning !! => matchIndex %u while searching %u within prefix is smaller than minimum expectation (%u<%u) !",
-                                matchIndex, current, (U32)controlSize, (U32)matchLength);
-            }   }
-#endif
             if (match[matchLength] == ip[matchLength]) {
                 matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iLimit) +1;
             }
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=8)
-            {   int i;
-                RAWLOG(8, "orig %7u: ", current);
-                for (i=0; i<8; i++) RAWLOG(7," %02X ", ip[i]);
-                RAWLOG(8, " \n");
-                RAWLOG(8, "match%7u: ", matchIndex);
-                for (i=0; i<8; i++) RAWLOG(7," %02X ", match[i]);
-                RAWLOG(8, " \n");
-            }
-#endif
         } else {
             match = dictBase + matchIndex;
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=2)
-            {   size_t const controlSize = ZSTD_count_2segments(ip, match, iLimit, dictEnd, prefixStart);
-                if (controlSize < matchLength) {
-                    DEBUGLOG(2, "Warning !! => matchIndex %u while searching %u into _extDict is smaller than minimum expectation (%u<%u) !",
-                                matchIndex, current, (U32)controlSize, (U32)matchLength);
-            }   }
-#endif
             matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dictEnd, prefixStart);
             if (matchIndex+matchLength >= dictLimit)
                 match = base + matchIndex;   /* prepare for match[matchLength] */
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=8)
-            if (matchIndex + 8 < dictLimit)
-            {   int i;
-                const BYTE* const ptr = dictBase + matchIndex;
-                RAWLOG(8, "orig %7u: ", current);
-                for (i=0; i<8; i++) RAWLOG(7," %02X ", ip[i]);
-                RAWLOG(8, " \n");
-                RAWLOG(8, "match%7u: ", matchIndex);
-                for (i=0; i<8; i++) RAWLOG(7," %02X ", ptr[i]);
-                RAWLOG(8, " \n");
-            }
-#endif
         }
-        DEBUGLOG(8, "candidate match has length %u (best:%u) ",
-                    (U32)matchLength, (U32)bestLength);
 
         if (matchLength > bestLength) {
-            DEBUGLOG(8, "current %u : found longer match of size%3u at distance%7u",
-                        current, (U32)matchLength, current - matchIndex);
             assert(matchEndIdx > matchIndex);
             if (matchLength > matchEndIdx - matchIndex)
                 matchEndIdx = matchIndex + (U32)matchLength;
@@ -429,60 +379,23 @@ static U32 ZSTD_insertBtAndGetAllMatches (
             mnum++;
             if (matchLength > ZSTD_OPT_NUM) break;
             if (ip+matchLength == iLimit) {  /* equal : no way to know if inf or sup */
-                DEBUGLOG(8, "match at index %u has equal value at length %u : cannot determine > or <",
-                            matchIndex, (U32)matchLength);
                 break;   /* drop, to preserve bt consistency (miss a little bit of compression) */
             }
         }
 
         if (match[matchLength] < ip[matchLength]) {
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=8)
-            DEBUGLOG(8, "match at index %u is smaller than current (%02X<%02X) (pos%u)",
-                        matchIndex, match[matchLength], ip[matchLength], (U32)matchLength);
-            {   int i;
-                RAWLOG(8, "index %u: ", matchIndex);
-                for (i=0; i<18; i++) RAWLOG(7," %02X ", match[i]);
-                RAWLOG(8, " \n");
-            }
-#endif
+            /* match smaller than current */
             *smallerPtr = matchIndex;             /* update smaller idx */
             commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
             if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
-            smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */
-            matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=8)
-            DEBUGLOG(8, "selecting larger candidate : ");
-            {   int i;
-                const BYTE* const match2 = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex;
-                RAWLOG(8, "index %u: ", matchIndex);
-                for (i=0; i<18; i++) RAWLOG(7," %02X ", match2[i]);
-                RAWLOG(8, " \n");
-            }
-#endif
+            smallerPtr = nextPtr+1;               /* new candidate => larger than match, which was smaller than current */
+            matchIndex = nextPtr[1];              /* new matchIndex, larger than previous, closer to current */
         } else {
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=8)
-            DEBUGLOG(8, "match at index %u is larger than current (%02X>%02X) (pos%u)",
-                        matchIndex, match[matchLength], ip[matchLength], (U32)matchLength);
-            {   int i;
-                RAWLOG(8, "index %u: ", matchIndex);
-                for (i=0; i<18; i++) RAWLOG(7," %02X ", match[i]);
-                RAWLOG(8, " \n");
-            }
-#endif
             *largerPtr = matchIndex;
             commonLengthLarger = matchLength;
             if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
             largerPtr = nextPtr;
             matchIndex = nextPtr[0];
-#if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=8)
-            DEBUGLOG(8, "selecting smaller candidate : ");
-            {   int i;
-                const BYTE* const match2 = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex;
-                RAWLOG(8, "index %u: ", matchIndex);
-                for (i=0; i<18; i++) RAWLOG(7," %02X ", match2[i]);
-                RAWLOG(8, " \n");
-            }
-#endif
     }   }
 
     *smallerPtr = *largerPtr = 0;
@@ -492,7 +405,7 @@ static U32 ZSTD_insertBtAndGetAllMatches (
 }
 
 
-static U32 ZSTD_BtGetAllMatches (
+FORCE_INLINE_TEMPLATE U32 ZSTD_BtGetAllMatches (
                         ZSTD_CCtx* zc,   /* Index table will be updated */
                         const BYTE* ip, const BYTE* const iHighLimit, const int extDict,
                         const U32 maxNbAttempts, const U32 matchLengthSearch,
@@ -500,7 +413,8 @@ static U32 ZSTD_BtGetAllMatches (
                         ZSTD_match_t* matches, const U32 minMatchLen)
 {
     if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */
-    ZSTD_updateTree(zc, ip, iHighLimit, maxNbAttempts, matchLengthSearch);
+    if (extDict) ZSTD_updateTree_extDict(zc, ip, iHighLimit, maxNbAttempts, matchLengthSearch);
+    else ZSTD_updateTree(zc, ip, iHighLimit, maxNbAttempts, matchLengthSearch);
     switch(matchLengthSearch)
     {
     case 3 : return ZSTD_insertBtAndGetAllMatches(zc, ip, iHighLimit, extDict, maxNbAttempts, 3, rep, ll0, matches, minMatchLen);

From 61c2d70c869f68e93a7af62327df2f0cb6022c75 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 15 Nov 2017 14:37:40 -0800
Subject: [PATCH 049/145] shortened repcode match finder implementation

---
 lib/compress/zstd_opt.c | 79 +++++++++++++++--------------------------
 1 file changed, 28 insertions(+), 51 deletions(-)

diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index 5c65ed720..f8e9c92a5 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -265,59 +265,36 @@ FORCE_INLINE_TEMPLATE
     size_t bestLength = minMatchLen-1;
 
     /* check repCode */
-#if 1
-    if (!extDict) /*static*/ {
-        U32 const lastR = ZSTD_REP_NUM + ll0;
+    {   U32 const lastR = ZSTD_REP_NUM + ll0;
         U32 repCode;
         for (repCode = ll0; repCode < lastR; repCode++) {
-            S32 const repOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
-            if ( (repOffset > 0)
-              && (repOffset < (S32)(ip-prefixStart))  /* within current mem segment */
-              && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repOffset, minMatch))) {
-                U32 const repLen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repOffset, iLimit) + minMatch;
-                /* save longer solution */
-                if (repLen > bestLength) {
-                    DEBUGLOG(8, "current %u : found rep%u match of size%3u",
-                                current, repCode - ll0, repLen);
-                    bestLength = repLen;
-                    matches[mnum].off = repCode - ll0;
-                    matches[mnum].len = (U32)repLen;
-                    mnum++;
-                    if ( (repLen > ZSTD_OPT_NUM)
-                       | (ip+repLen == iLimit) ) {  /* best possible */
-                        return mnum;
-        }   }   }   }
-    } else {   /* extDict */
-        U32 const lastR = ZSTD_REP_NUM + ll0;
-        U32 repCode;
-        for (repCode=ll0; repCode<lastR; repCode++) {
-            const S32 repCur = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
-            const U32 repIndex = (U32)(current - repCur);
-            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
-            const BYTE* const repMatch = repBase + repIndex;
-            if ( (repCur > 0 && repCur <= (S32)current)
-               && (((U32)((dictLimit-1) - repIndex) >= 3) & (repIndex>windowLow))  /* intentional overflow */
-               && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {
-                /* repcode detected we should take it */
-                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iLimit;
-                U32 const repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, repEnd, prefixStart) + minMatch;
-
-                /* save longer solution */
-                if (repLen > bestLength) {
-                    DEBUGLOG(8, "current %u : found rep%u match of size%3u",
-                                current, repCode - ll0, repLen);
-                    bestLength = repLen;
-                    matches[mnum].off = repCode - ll0;
-                    matches[mnum].len = (U32)repLen;
-                    mnum++;
-                    if ( (repLen > ZSTD_OPT_NUM)
-                       | (ip+repLen == iLimit) ) {  /* best possible */
-                        return mnum;
-        }   }   }   }
-    }
-#else
-    (void)ll0; (void)rep; (void)minMatch;
-#endif
+            U32 const repOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
+            U32 const repIndex = current - repOffset;
+            U32 repLen = 0;
+            assert(repOffset <= current);
+            assert(current >= dictLimit);
+            if (!extDict /*static*/ || (repIndex>=dictLimit)) {
+                if ( (repOffset-1 /* intentional overflow, discards 0 and -1 */ < current-dictLimit)  /* within current mem segment */
+                  && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repOffset, minMatch))) {
+                    repLen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repOffset, iLimit) + minMatch;
+                }
+            } else {  /* extDict */
+                const BYTE* const repMatch = dictBase + repIndex;
+                if ( ((repOffset-1) /*intentional overflow*/ < current)
+                   & (((U32)((dictLimit-1) - repIndex) >= 3) /* intentional overflow */ & (repIndex > windowLow))
+                  && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {
+                    repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, dictEnd, prefixStart) + minMatch;
+            }   }
+            /* save longer solution */
+            if (repLen > bestLength) {
+                bestLength = repLen;
+                matches[mnum].off = repCode - ll0;
+                matches[mnum].len = (U32)repLen;
+                mnum++;
+                if ( (repLen > ZSTD_OPT_NUM)
+                   | (ip+repLen == iLimit) ) {  /* best possible */
+                    return mnum;
+    }   }   }   }
 
     /* HC3 match finder */
     if ((mls == 3) /*static*/ && (bestLength < mls)) {

From c55e35b2fca5930881e80d467f307460e40c50fb Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 15 Nov 2017 15:04:53 -0800
Subject: [PATCH 050/145] removed a few specialized traces

---
 lib/compress/zstd_opt.c | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index f8e9c92a5..e3112085a 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -312,8 +312,6 @@ FORCE_INLINE_TEMPLATE
 
             /* save best solution */
             if (mlen >= mls /* == 3 > bestLength */) {
-                DEBUGLOG(8, "current %u : found short match of size%3u at distance%7u",
-                            current, (U32)mlen, current - matchIndex3);
                 bestLength = mlen;
                 assert(current > matchIndex3);
                 assert(mnum==0);  /* no prior solution */
@@ -511,15 +509,11 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                     U32 const offset = matches[matchNb].off;
                     U32 const end = matches[matchNb].len;
                     repcodes_t const repHistory = ZSTD_updateRep(rep, offset, ll0);
-                    DEBUGLOG(7, "match %u: starting reps=%u,%u,%u ==> %u,%u,%u",
-                                matchNb, rep[0], rep[1], rep[2], repHistory.rep[0], repHistory.rep[1], repHistory.rep[2])
                     while (pos <= end) {
                         U32 const matchPrice = ZSTD_getPrice(optStatePtr, litlen, anchor, offset, pos, ultra);
                         if (pos > last_pos || matchPrice < opt[pos].price) {
                             DEBUGLOG(7, "rPos:%u => set initial price : %u",
                                         pos, matchPrice);
-                            DEBUGLOG(7, "transferring rep:%u,%u,%u",
-                                        repHistory.rep[0], repHistory.rep[1], repHistory.rep[2]);
                             SET_PRICE(pos, pos, offset, litlen, matchPrice, repHistory);   /* note : macro modifies last_pos */
                         }
                         pos++;
@@ -542,8 +536,6 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                 if (price <= opt[cur].price) {
                     DEBUGLOG(7, "rPos:%u : better price (%u<%u) using literal",
                                 cur, price, opt[cur].price);
-                    DEBUGLOG(7, "transferring rep:%u,%u,%u",
-                                opt[cur-1].rep[0], opt[cur-1].rep[1], opt[cur-1].rep[2]);
                     SET_PRICE(cur, 1/*mlen*/, 0/*offset*/, litlen, price, opt[cur-1].rep);
             }   }
 
@@ -601,8 +593,6 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
         best_mlen = opt[last_pos].mlen;
         best_off = opt[last_pos].off;
         cur = last_pos - best_mlen;
-        DEBUGLOG(7, "Preparing path selection : last_pos:%u, cur:%u, best_mlen:%u",
-                    last_pos, cur, best_mlen);
 
 _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
         assert(opt[0].mlen == 1);
@@ -650,8 +640,6 @@ _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
 
                 ZSTD_updatePrice(optStatePtr, llen, anchor, offset, mlen);
                 ZSTD_storeSeq(seqStorePtr, llen, anchor, offset, mlen-MINMATCH);
-                DEBUGLOG(7, "seq: ll:%u,ml:%u,off:%u - rep:%u,%u,%u",
-                            llen, mlen, offset, rep[0], rep[1], rep[2]);
                 anchor = ip;
         }   }
     }   /* for (cur=0; cur < last_pos; ) */

From dfc14579f5344a5f225bf0b30f22785127f4e6b5 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 15 Nov 2017 15:35:56 -0800
Subject: [PATCH 051/145] removed wrong assertion

---
 lib/compress/zstd_opt.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index e3112085a..c3814f8d2 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -271,7 +271,6 @@ FORCE_INLINE_TEMPLATE
             U32 const repOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];
             U32 const repIndex = current - repOffset;
             U32 repLen = 0;
-            assert(repOffset <= current);
             assert(current >= dictLimit);
             if (!extDict /*static*/ || (repIndex>=dictLimit)) {
                 if ( (repOffset-1 /* intentional overflow, discards 0 and -1 */ < current-dictLimit)  /* within current mem segment */

From 05dffe43a75cf29563ae508d71e7f1085db3ad2b Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Thu, 16 Nov 2017 12:18:56 -0800
Subject: [PATCH 052/145] Fixed Btree update

ZSTD_updateTree() expected to be followed by a Bt match finder, which would update zc->nextToUpdate.
With the new optimal match finder, it's not necessarily the case : a match might be found during repcode or hash3, and stops there because it reaches sufficient_len, without even entering the binary tree.
Previous policy was to nonetheless update zc->nextToUpdate, but the current position would not be inserted, creating "holes" in the btree, aka positions that will no longer be searched.
Now, when current position is not inserted, zc->nextToUpdate is not update, expecting ZSTD_updateTree() to fill the tree later on.

Solution selected is that ZSTD_updateTree() takes care of properly setting zc->nextToUpdate,
so that it no longer depends on a future function to do this job.

It took time to get there, as the issue started with a memory sanitizer error.
The pb would have been easier to spot with a proper `assert()`.
So this patch add a few of them.

Additionnally, I discovered that `make test` does not enable `assert()` during CLI tests.
This patch enables them.

Unfortunately, these `assert()` triggered other (unrelated) bugs during CLI tests, mostly within zstdmt.
So this patch also fixes them.

- Changed packed structure for gcc memory access : memory sanitizer would complain that a read "might" reach out-of-bound position on the ground that the `union` is larger than the type accessed.
  Now, to avoid this issue, each type is independent.
- ZSTD_CCtxParams_setParameter() : @return provides the value of parameter, clamped/fixed appropriately.
- ZSTDMT : changed constant name to ZSTDMT_JOBSIZE_MIN
- ZSTDMT : multithreading is automatically disabled when srcSize <= ZSTDMT_JOBSIZE_MIN, since only one thread will be used in this case (saves memory and runtime).
- ZSTDMT : nbThreads is automatically clamped on setting the value.
---
 Makefile                              |   2 +-
 lib/common/mem.h                      |  24 ++-
 lib/compress/zstd_compress.c          | 236 +++++++++++++++-----------
 lib/compress/zstd_compress_internal.h |   1 -
 lib/compress/zstd_lazy.c              |  56 +++---
 lib/compress/zstd_opt.c               |  47 +++--
 lib/compress/zstdmt_compress.c        |  79 +++++----
 lib/compress/zstdmt_compress.h        |   6 +-
 lib/zstd.h                            |   3 +-
 9 files changed, 263 insertions(+), 191 deletions(-)

diff --git a/Makefile b/Makefile
index f2487c591..9f4b1fe4d 100644
--- a/Makefile
+++ b/Makefile
@@ -77,7 +77,7 @@ check: shortest
 
 .PHONY: test shortest
 test shortest:
-	$(MAKE) -C $(PRGDIR) allVariants
+	$(MAKE) -C $(PRGDIR) allVariants MOREFLAGS="-g -DZSTD_DEBUG=1"
 	$(MAKE) -C $(TESTDIR) $@
 
 .PHONY: examples
diff --git a/lib/common/mem.h b/lib/common/mem.h
index 23335c314..2ec328733 100644
--- a/lib/common/mem.h
+++ b/lib/common/mem.h
@@ -123,20 +123,26 @@ MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }
 /* currently only defined for gcc and icc */
 #if defined(_MSC_VER) || (defined(__INTEL_COMPILER) && defined(WIN32))
     __pragma( pack(push, 1) )
-    typedef union { U16 u16; U32 u32; U64 u64; size_t st; } unalign;
+    typedef struct { U16 v; } unalign16;
+    typedef struct { U32 v; } unalign32;
+    typedef struct { U64 v; } unalign64;
+    typedef struct { size_t v; } unalignArch;
     __pragma( pack(pop) )
 #else
-    typedef union { U16 u16; U32 u32; U64 u64; size_t st; } __attribute__((packed)) unalign;
+    typedef struct { U16 v; } __attribute__((packed)) unalign16;
+    typedef struct { U32 v; } __attribute__((packed)) unalign32;
+    typedef struct { U64 v; } __attribute__((packed)) unalign64;
+    typedef struct { size_t v; } __attribute__((packed)) unalignArch;
 #endif
 
-MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
-MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
-MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
-MEM_STATIC size_t MEM_readST(const void* ptr) { return ((const unalign*)ptr)->st; }
+MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign16*)ptr)->v; }
+MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign32*)ptr)->v; }
+MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign64*)ptr)->v; }
+MEM_STATIC size_t MEM_readST(const void* ptr) { return ((const unalignArch*)ptr)->v; }
 
-MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }
-MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; }
-MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign*)memPtr)->u64 = value; }
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign16*)memPtr)->v = value; }
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign32*)memPtr)->v = value; }
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign64*)memPtr)->v = value; }
 
 #else
 
diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index f49e14b38..0bdcc26ab 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -142,17 +142,17 @@ const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx) { return &(ctx->seqStor
 #define ZSTD_CLEVEL_CUSTOM 999
 
 static ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(
-        ZSTD_CCtx_params params, U64 srcSizeHint, size_t dictSize)
+        ZSTD_CCtx_params CCtxParams, U64 srcSizeHint, size_t dictSize)
 {
-    return (params.compressionLevel == ZSTD_CLEVEL_CUSTOM ?
-                    params.cParams :
-                    ZSTD_getCParams(params.compressionLevel, srcSizeHint, dictSize));
+    return (CCtxParams.compressionLevel == ZSTD_CLEVEL_CUSTOM) ?
+                CCtxParams.cParams :
+                ZSTD_getCParams(CCtxParams.compressionLevel, srcSizeHint, dictSize);
 }
 
-static void ZSTD_cLevelToCCtxParams_srcSize(ZSTD_CCtx_params* params, U64 srcSize)
+static void ZSTD_cLevelToCCtxParams_srcSize(ZSTD_CCtx_params* CCtxParams, U64 srcSize)
 {
-    params->cParams = ZSTD_getCParamsFromCCtxParams(*params, srcSize, 0);
-    params->compressionLevel = ZSTD_CLEVEL_CUSTOM;
+    CCtxParams->cParams = ZSTD_getCParamsFromCCtxParams(*CCtxParams, srcSize, 0);
+    CCtxParams->compressionLevel = ZSTD_CLEVEL_CUSTOM;
 }
 
 static void ZSTD_cLevelToCParams(ZSTD_CCtx* cctx)
@@ -161,9 +161,9 @@ static void ZSTD_cLevelToCParams(ZSTD_CCtx* cctx)
             &cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1);
 }
 
-static void ZSTD_cLevelToCCtxParams(ZSTD_CCtx_params* params)
+static void ZSTD_cLevelToCCtxParams(ZSTD_CCtx_params* CCtxParams)
 {
-    ZSTD_cLevelToCCtxParams_srcSize(params, 0);
+    ZSTD_cLevelToCCtxParams_srcSize(CCtxParams, 0);
 }
 
 static ZSTD_CCtx_params ZSTD_makeCCtxParamsFromCParams(
@@ -314,148 +314,157 @@ size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned v
 }
 
 size_t ZSTD_CCtxParam_setParameter(
-        ZSTD_CCtx_params* params, ZSTD_cParameter param, unsigned value)
+        ZSTD_CCtx_params* CCtxParams, ZSTD_cParameter param, unsigned value)
 {
     switch(param)
     {
     case ZSTD_p_format :
         if (value > (unsigned)ZSTD_f_zstd1_magicless)
             return ERROR(parameter_unsupported);
-        params->format = (ZSTD_format_e)value;
-        return 0;
+        CCtxParams->format = (ZSTD_format_e)value;
+        return (size_t)CCtxParams->format;
 
     case ZSTD_p_compressionLevel :
         if ((int)value > ZSTD_maxCLevel()) value = ZSTD_maxCLevel();
-        if (value == 0) return 0;
-        params->compressionLevel = value;
-        return 0;
+        if (value)  /* 0 : does not change current level */
+            CCtxParams->compressionLevel = value;
+        return CCtxParams->compressionLevel;
 
     case ZSTD_p_windowLog :
-        if (value == 0) return 0;
-        CLAMPCHECK(value, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX);
-        ZSTD_cLevelToCCtxParams(params);
-        params->cParams.windowLog = value;
-        return 0;
+        if (value) {  /* 0 : does not change current windowLog */
+            CLAMPCHECK(value, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX);
+            ZSTD_cLevelToCCtxParams(CCtxParams);
+            CCtxParams->cParams.windowLog = value;
+        }
+        return CCtxParams->cParams.windowLog;
 
     case ZSTD_p_hashLog :
-        if (value == 0) return 0;
-        CLAMPCHECK(value, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX);
-        ZSTD_cLevelToCCtxParams(params);
-        params->cParams.hashLog = value;
-        return 0;
+        if (value) { /* 0 : does not change current hashLog */
+            CLAMPCHECK(value, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX);
+            ZSTD_cLevelToCCtxParams(CCtxParams);
+            CCtxParams->cParams.hashLog = value;
+        }
+        return CCtxParams->cParams.hashLog;
 
     case ZSTD_p_chainLog :
-        if (value == 0) return 0;
-        CLAMPCHECK(value, ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX);
-        ZSTD_cLevelToCCtxParams(params);
-        params->cParams.chainLog = value;
-        return 0;
+        if (value) { /* 0 : does not change current chainLog */
+            CLAMPCHECK(value, ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX);
+            ZSTD_cLevelToCCtxParams(CCtxParams);
+            CCtxParams->cParams.chainLog = value;
+        }
+        return CCtxParams->cParams.chainLog;
 
     case ZSTD_p_searchLog :
-        if (value == 0) return 0;
-        CLAMPCHECK(value, ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX);
-        ZSTD_cLevelToCCtxParams(params);
-        params->cParams.searchLog = value;
-        return 0;
+        if (value) { /* 0 : does not change current searchLog */
+            CLAMPCHECK(value, ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX);
+            ZSTD_cLevelToCCtxParams(CCtxParams);
+            CCtxParams->cParams.searchLog = value;
+        }
+        return value;
 
     case ZSTD_p_minMatch :
-        if (value == 0) return 0;
-        CLAMPCHECK(value, ZSTD_SEARCHLENGTH_MIN, ZSTD_SEARCHLENGTH_MAX);
-        ZSTD_cLevelToCCtxParams(params);
-        params->cParams.searchLength = value;
-        return 0;
+        if (value) { /* 0 : does not change current minMatch length */
+            CLAMPCHECK(value, ZSTD_SEARCHLENGTH_MIN, ZSTD_SEARCHLENGTH_MAX);
+            ZSTD_cLevelToCCtxParams(CCtxParams);
+            CCtxParams->cParams.searchLength = value;
+        }
+        return CCtxParams->cParams.searchLength;
 
     case ZSTD_p_targetLength :
-        if (value == 0) return 0;
-        CLAMPCHECK(value, ZSTD_TARGETLENGTH_MIN, ZSTD_TARGETLENGTH_MAX);
-        ZSTD_cLevelToCCtxParams(params);
-        params->cParams.targetLength = value;
-        return 0;
+        if (value) { /* 0 : does not change current sufficient_len */
+            CLAMPCHECK(value, ZSTD_TARGETLENGTH_MIN, ZSTD_TARGETLENGTH_MAX);
+            ZSTD_cLevelToCCtxParams(CCtxParams);
+            CCtxParams->cParams.targetLength = value;
+        }
+        return CCtxParams->cParams.targetLength;
 
     case ZSTD_p_compressionStrategy :
-        if (value == 0) return 0;
-        CLAMPCHECK(value, (unsigned)ZSTD_fast, (unsigned)ZSTD_btultra);
-        ZSTD_cLevelToCCtxParams(params);
-        params->cParams.strategy = (ZSTD_strategy)value;
-        return 0;
+        if (value) { /* 0 : does not change currentstrategy */
+            CLAMPCHECK(value, (unsigned)ZSTD_fast, (unsigned)ZSTD_btultra);
+            ZSTD_cLevelToCCtxParams(CCtxParams);
+            CCtxParams->cParams.strategy = (ZSTD_strategy)value;
+        }
+        return (size_t)CCtxParams->cParams.strategy;
 
     case ZSTD_p_contentSizeFlag :
         /* Content size written in frame header _when known_ (default:1) */
         DEBUGLOG(4, "set content size flag = %u", (value>0));
-        params->fParams.contentSizeFlag = value > 0;
-        return 0;
+        CCtxParams->fParams.contentSizeFlag = value > 0;
+        return CCtxParams->fParams.contentSizeFlag;
 
     case ZSTD_p_checksumFlag :
         /* A 32-bits content checksum will be calculated and written at end of frame (default:0) */
-        params->fParams.checksumFlag = value > 0;
-        return 0;
+        CCtxParams->fParams.checksumFlag = value > 0;
+        return CCtxParams->fParams.checksumFlag;
 
     case ZSTD_p_dictIDFlag : /* When applicable, dictionary's dictID is provided in frame header (default:1) */
         DEBUGLOG(4, "set dictIDFlag = %u", (value>0));
-        params->fParams.noDictIDFlag = (value == 0);
-        return 0;
+        CCtxParams->fParams.noDictIDFlag = (value == 0);
+        return !CCtxParams->fParams.noDictIDFlag;
 
     case ZSTD_p_forceMaxWindow :
-        params->forceWindow = value > 0;
-        return 0;
+        CCtxParams->forceWindow = (value > 0);
+        return CCtxParams->forceWindow;
 
     case ZSTD_p_nbThreads :
-        if (value == 0) return 0;
+        if (value == 0) return CCtxParams->nbThreads;
 #ifndef ZSTD_MULTITHREAD
         if (value > 1) return ERROR(parameter_unsupported);
-        return 0;
+        return 1;
 #else
-        return ZSTDMT_initializeCCtxParameters(params, value);
+        return ZSTDMT_CCtxParam_setNbThreads(CCtxParams, value);
 #endif
 
     case ZSTD_p_jobSize :
 #ifndef ZSTD_MULTITHREAD
         return ERROR(parameter_unsupported);
 #else
-        if (params->nbThreads <= 1) return ERROR(parameter_unsupported);
-        return ZSTDMT_CCtxParam_setMTCtxParameter(params, ZSTDMT_p_sectionSize, value);
+        if (CCtxParams->nbThreads <= 1) return ERROR(parameter_unsupported);
+        return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_sectionSize, value);
 #endif
 
     case ZSTD_p_overlapSizeLog :
 #ifndef ZSTD_MULTITHREAD
         return ERROR(parameter_unsupported);
 #else
-        if (params->nbThreads <= 1) return ERROR(parameter_unsupported);
-        return ZSTDMT_CCtxParam_setMTCtxParameter(params, ZSTDMT_p_overlapSectionLog, value);
+        if (CCtxParams->nbThreads <= 1) return ERROR(parameter_unsupported);
+        return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_overlapSectionLog, value);
 #endif
 
     case ZSTD_p_enableLongDistanceMatching :
         if (value != 0) {
-            ZSTD_cLevelToCCtxParams(params);
-            params->cParams.windowLog = ZSTD_LDM_DEFAULT_WINDOW_LOG;
+            ZSTD_cLevelToCCtxParams(CCtxParams);
+            CCtxParams->cParams.windowLog = ZSTD_LDM_DEFAULT_WINDOW_LOG;
         }
-        return ZSTD_ldm_initializeParameters(&params->ldmParams, value);
+        return ZSTD_ldm_initializeParameters(&CCtxParams->ldmParams, value);
 
     case ZSTD_p_ldmHashLog :
-        if (value == 0) return 0;
-        CLAMPCHECK(value, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX);
-        params->ldmParams.hashLog = value;
-        return 0;
+        if (value) { /* 0 : does not change current ldmHashLog */
+            CLAMPCHECK(value, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX);
+            CCtxParams->ldmParams.hashLog = value;
+        }
+        return CCtxParams->ldmParams.hashLog;
 
     case ZSTD_p_ldmMinMatch :
-        if (value == 0) return 0;
-        CLAMPCHECK(value, ZSTD_LDM_MINMATCH_MIN, ZSTD_LDM_MINMATCH_MAX);
-        params->ldmParams.minMatchLength = value;
-        return 0;
+        if (value) { /* 0 : does not change current ldmMinMatch */
+            CLAMPCHECK(value, ZSTD_LDM_MINMATCH_MIN, ZSTD_LDM_MINMATCH_MAX);
+            CCtxParams->ldmParams.minMatchLength = value;
+        }
+        return CCtxParams->ldmParams.minMatchLength;
 
     case ZSTD_p_ldmBucketSizeLog :
         if (value > ZSTD_LDM_BUCKETSIZELOG_MAX) {
             return ERROR(parameter_outOfBound);
         }
-        params->ldmParams.bucketSizeLog = value;
-        return 0;
+        CCtxParams->ldmParams.bucketSizeLog = value;
+        return value;
 
     case ZSTD_p_ldmHashEveryLog :
         if (value > ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN) {
             return ERROR(parameter_outOfBound);
         }
-        params->ldmParams.hashEveryLog = value;
-        return 0;
+        CCtxParams->ldmParams.hashEveryLog = value;
+        return value;
 
     default: return ERROR(parameter_unsupported);
     }
@@ -768,12 +777,26 @@ static U32 ZSTD_equivalentLdmParams(ldmParams_t ldmParams1,
             ldmParams1.hashEveryLog == ldmParams2.hashEveryLog);
 }
 
+typedef enum { ZSTDb_not_buffered, ZSTDb_buffered } ZSTD_buffered_policy_e;
+
+/* ZSTD_equivalentBuffPolicy() :
+ * check internal buffers exist for streaming if buffPol == ZSTDb_buffered .
+ * Note : they are assumed to be correctly sized if ZSTD_equivalentCParams()==1 */
+static U32 ZSTD_equivalentBuffPolicy(size_t bufferSize, ZSTD_buffered_policy_e buffPol)
+{
+    if ((buffPol == ZSTDb_buffered) & (!bufferSize)) return 0;
+    return 1;
+}
+
 /** Equivalence for resetCCtx purposes */
 static U32 ZSTD_equivalentParams(ZSTD_CCtx_params params1,
-                                 ZSTD_CCtx_params params2)
+                                 ZSTD_CCtx_params params2,
+                                 size_t buffSize1,
+                                 ZSTD_buffered_policy_e buffPol2)
 {
     return ZSTD_equivalentCParams(params1.cParams, params2.cParams) &&
-           ZSTD_equivalentLdmParams(params1.ldmParams, params2.ldmParams);
+           ZSTD_equivalentLdmParams(params1.ldmParams, params2.ldmParams) &&
+           ZSTD_equivalentBuffPolicy(buffSize1, buffPol2);
 }
 
 /*! ZSTD_continueCCtx() :
@@ -802,7 +825,6 @@ static size_t ZSTD_continueCCtx(ZSTD_CCtx* cctx, ZSTD_CCtx_params params, U64 pl
 }
 
 typedef enum { ZSTDcrp_continue, ZSTDcrp_noMemset } ZSTD_compResetPolicy_e;
-typedef enum { ZSTDb_not_buffered, ZSTDb_buffered } ZSTD_buffered_policy_e;
 
 /*! ZSTD_resetCCtx_internal() :
     note : `params` are assumed fully validated at this stage */
@@ -815,8 +837,8 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
     assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
 
     if (crp == ZSTDcrp_continue) {
-        if (ZSTD_equivalentParams(params, zc->appliedParams)) {
-            DEBUGLOG(4, "ZSTD_equivalentParams()==1");
+        if (ZSTD_equivalentParams(params, zc->appliedParams, zc->inBuffSize, zbuff)) {
+            DEBUGLOG(4, "ZSTD_equivalentParams()==1 -> continue mode");
             assert(!(params.ldmParams.enableLdm &&
                      params.ldmParams.hashEveryLog == ZSTD_LDM_HASHEVERYLOG_NOTSET));
             zc->entropy->hufCTable_repeatMode = HUF_repeat_none;
@@ -825,6 +847,7 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
             zc->entropy->litlength_repeatMode = FSE_repeat_none;
             return ZSTD_continueCCtx(zc, params, pledgedSrcSize);
     }   }
+    DEBUGLOG(4, "ZSTD_equivalentParams()==0 -> reset CCtx");
 
     if (params.ldmParams.enableLdm) {
         /* Adjust long distance matching parameters */
@@ -863,11 +886,15 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
                 : 0;
             size_t const neededSpace = entropySpace + optSpace + ldmSpace +
                                        tableSpace + tokenSpace + bufferSpace;
+            DEBUGLOG(4, "Need %uKB workspace, including %uKB for tables",
+                        (U32)(neededSpace>>10), (U32)(tableSpace>>10));
+            DEBUGLOG(4, "chainSize: %u - hSize: %u - h3Size: %u",
+                        (U32)chainSize, (U32)hSize, (U32)h3Size);
 
             if (zc->workSpaceSize < neededSpace) {  /* too small : resize */
-                DEBUGLOG(5, "Need to update workSpaceSize from %uK to %uK \n",
-                            (unsigned)zc->workSpaceSize>>10,
-                            (unsigned)neededSpace>>10);
+                DEBUGLOG(4, "Need to update workSpaceSize from %uK to %uK",
+                            (unsigned)(zc->workSpaceSize>>10),
+                            (unsigned)(neededSpace>>10));
                 /* static cctx : no resize, error out */
                 if (zc->staticSize) return ERROR(memory_allocation);
 
@@ -916,7 +943,7 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
 
         /* opt parser space */
         if ((params.cParams.strategy == ZSTD_btopt) || (params.cParams.strategy == ZSTD_btultra)) {
-            DEBUGLOG(5, "reserving optimal parser space");
+            DEBUGLOG(4, "reserving optimal parser space");
             assert(((size_t)ptr & 3) == 0);  /* ensure ptr is properly aligned */
             zc->optState.litFreq = (U32*)ptr;
             zc->optState.litLengthFreq = zc->optState.litFreq + (1<<Litbits);
@@ -940,6 +967,7 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
         }
 
         /* table Space */
+        DEBUGLOG(4, "reset table : %u", crp!=ZSTDcrp_noMemset);
         if (crp!=ZSTDcrp_noMemset) memset(ptr, 0, tableSpace);   /* reset tables only */
         assert(((size_t)ptr & 3) == 0);  /* ensure ptr is properly aligned */
         zc->hashTable = (U32*)(ptr);
@@ -1753,7 +1781,6 @@ static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,
                 !params.fParams.noDictIDFlag, dictID,  dictIDSizeCode);
 
     if (params.format == ZSTD_f_zstd1) {
-        DEBUGLOG(4, "writing zstd magic number");
         MEM_writeLE32(dst, ZSTD_MAGICNUMBER);
         pos = 4;
     }
@@ -1787,8 +1814,7 @@ static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,
     const BYTE* const ip = (const BYTE*) src;
     size_t fhSize = 0;
 
-    DEBUGLOG(5, "ZSTD_compressContinue_internal");
-    DEBUGLOG(5, "stage: %u", cctx->stage);
+    DEBUGLOG(5, "ZSTD_compressContinue_internal, stage: %u", cctx->stage);
     if (cctx->stage==ZSTDcs_created) return ERROR(stage_wrong);   /* missing init (ZSTD_compressBegin) */
 
     if (frame && (cctx->stage==ZSTDcs_init)) {
@@ -2017,7 +2043,7 @@ static size_t ZSTD_compress_insertDictionary(ZSTD_CCtx* cctx,
                                        const void* dict, size_t dictSize,
                                              ZSTD_dictMode_e dictMode)
 {
-    DEBUGLOG(5, "ZSTD_compress_insertDictionary");
+    DEBUGLOG(4, "ZSTD_compress_insertDictionary (dictSize=%u)", (U32)dictSize);
     if ((dict==NULL) || (dictSize<=8)) return 0;
 
     /* dict restricted modes */
@@ -2026,7 +2052,7 @@ static size_t ZSTD_compress_insertDictionary(ZSTD_CCtx* cctx,
 
     if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) {
         if (dictMode == ZSTD_dm_auto) {
-            DEBUGLOG(5, "raw content dictionary detected");
+            DEBUGLOG(4, "raw content dictionary detected");
             return ZSTD_loadDictionaryContent(cctx, dict, dictSize);
         }
         if (dictMode == ZSTD_dm_fullDict)
@@ -2097,6 +2123,7 @@ size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t di
     ZSTD_parameters const params = ZSTD_getParams(compressionLevel, 0, dictSize);
     ZSTD_CCtx_params const cctxParams =
             ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params);
+    DEBUGLOG(4, "ZSTD_compressBegin_usingDict");
     return ZSTD_compressBegin_internal(cctx, dict, dictSize, ZSTD_dm_auto, NULL,
                                        cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, ZSTDb_not_buffered);
 }
@@ -2179,6 +2206,7 @@ static size_t ZSTD_compress_internal (ZSTD_CCtx* cctx,
 {
     ZSTD_CCtx_params const cctxParams =
             ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params);
+    DEBUGLOG(4, "ZSTD_compress_internal");
     return ZSTD_compress_advanced_internal(cctx,
                                           dst, dstCapacity,
                                           src, srcSize,
@@ -2192,6 +2220,7 @@ size_t ZSTD_compress_advanced (ZSTD_CCtx* ctx,
                          const void* dict,size_t dictSize,
                                ZSTD_parameters params)
 {
+    DEBUGLOG(4, "ZSTD_compress_advanced");
     CHECK_F(ZSTD_checkCParams(params.cParams));
     return ZSTD_compress_internal(ctx, dst, dstCapacity, src, srcSize, dict, dictSize, params);
 }
@@ -2204,6 +2233,7 @@ size_t ZSTD_compress_advanced_internal(
         const void* dict,size_t dictSize,
         ZSTD_CCtx_params params)
 {
+    DEBUGLOG(4, "ZSTD_compress_advanced_internal");
     CHECK_F( ZSTD_compressBegin_internal(cctx, dict, dictSize, ZSTD_dm_auto, NULL,
                                          params, srcSize, ZSTDb_not_buffered) );
     return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
@@ -2214,6 +2244,8 @@ size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx, void* dst, size_t dstCapacity, co
 {
     ZSTD_parameters params = ZSTD_getParams(compressionLevel, srcSize ? srcSize : 1, dict ? dictSize : 0);
     params.fParams.contentSizeFlag = 1;
+    DEBUGLOG(4, "ZSTD_compress_usingDict (level=%i, srcSize=%u, dictSize=%u)",
+                compressionLevel, (U32)srcSize, (U32)dictSize);
     return ZSTD_compress_internal(ctx, dst, dstCapacity, src, srcSize, dict, dictSize, params);
 }
 
@@ -2270,7 +2302,7 @@ static size_t ZSTD_initCDict_internal(
                     ZSTD_dictMode_e dictMode,
                     ZSTD_compressionParameters cParams)
 {
-    DEBUGLOG(5, "ZSTD_initCDict_internal, mode %u", (U32)dictMode);
+    DEBUGLOG(4, "ZSTD_initCDict_internal, mode %u", (U32)dictMode);
     if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dictBuffer) || (!dictSize)) {
         cdict->dictBuffer = NULL;
         cdict->dictContent = dictBuffer;
@@ -2409,11 +2441,11 @@ size_t ZSTD_compressBegin_usingCDict_advanced(
     ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict,
     ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize)
 {
+    DEBUGLOG(4, "ZSTD_compressBegin_usingCDict_advanced");
     if (cdict==NULL) return ERROR(dictionary_wrong);
     {   ZSTD_CCtx_params params = cctx->requestedParams;
         params.cParams = ZSTD_getCParamsFromCDict(cdict);
         params.fParams = fParams;
-        DEBUGLOG(4, "ZSTD_compressBegin_usingCDict_advanced");
         return ZSTD_compressBegin_internal(cctx,
                                            NULL, 0, ZSTD_dm_auto,
                                            cdict,
@@ -2811,16 +2843,17 @@ size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
 
     /* transparent initialization stage */
     if (cctx->streamStage == zcss_init) {
-        ZSTD_prefixDict const prefixDict = cctx->prefixDict;
         ZSTD_CCtx_params params = cctx->requestedParams;
-        if (endOp == ZSTD_e_end) cctx->pledgedSrcSizePlusOne = input->size + 1;
-        params.cParams = ZSTD_getCParamsFromCCtxParams(
-                cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1, 0 /*dictSize*/);
+        ZSTD_prefixDict const prefixDict = cctx->prefixDict;
         memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));  /* single usage */
         assert(prefixDict.dict==NULL || cctx->cdict==NULL);   /* only one can be set */
         DEBUGLOG(4, "ZSTD_compress_generic : transparent init stage");
+        if (endOp == ZSTD_e_end) cctx->pledgedSrcSizePlusOne = input->size + 1;  /* auto-fix pledgedSrcSize */
+        params.cParams = ZSTD_getCParamsFromCCtxParams(
+                cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1, 0 /*dictSize*/);
 
 #ifdef ZSTD_MULTITHREAD
+        if ((cctx->pledgedSrcSizePlusOne-1) <= ZSTDMT_JOBSIZE_MIN) params.nbThreads = 1; /* do not invoke multi-threading when src size is too small */
         if (params.nbThreads > 1) {
             if (cctx->mtctx == NULL || cctx->appliedParams.nbThreads != params.nbThreads) {
                 ZSTDMT_freeCCtx(cctx->mtctx);
@@ -2897,8 +2930,7 @@ size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
     {   size_t const lastBlockSize = zcs->frameEnded ? 0 : ZSTD_BLOCKHEADERSIZE;
         size_t const checksumSize = zcs->frameEnded ? 0 : zcs->appliedParams.fParams.checksumFlag * 4;
         size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize + lastBlockSize + checksumSize;
-        DEBUGLOG(5, "ZSTD_endStream : remaining to flush : %u",
-                (unsigned)toFlush);
+        DEBUGLOG(4, "ZSTD_endStream : remaining to flush : %u", (U32)toFlush);
         return toFlush;
     }
 }
diff --git a/lib/compress/zstd_compress_internal.h b/lib/compress/zstd_compress_internal.h
index a9ef7ad1c..efcbc4501 100644
--- a/lib/compress/zstd_compress_internal.h
+++ b/lib/compress/zstd_compress_internal.h
@@ -237,7 +237,6 @@ MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const v
     static const BYTE* g_start = NULL;
     if (g_start==NULL) g_start = (const BYTE*)literals;  /* note : index only works for compression within a single segment */
     {   U32 const pos = (U32)((const BYTE*)literals - g_start);
-        g_debuglog_enable = ((pos >= 3670500) & (pos < 3673800));
         DEBUGLOG(6, "Cpos%7u :%3u literals, match%3u bytes at dist.code%7u",
                pos, (U32)litLength, (U32)mlBase+MINMATCH, (U32)offsetCode);
     }
diff --git a/lib/compress/zstd_lazy.c b/lib/compress/zstd_lazy.c
index 2794d99bc..d7ef039f0 100644
--- a/lib/compress/zstd_lazy.c
+++ b/lib/compress/zstd_lazy.c
@@ -18,8 +18,9 @@
 /** ZSTD_insertBt1() : add one or multiple positions to tree.
 *   ip : assumed <= iend-8 .
 *   @return : nb of positions added */
-static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, const BYTE* const iend, U32 nbCompares,
-                          U32 extDict)
+static U32 ZSTD_insertBt1(ZSTD_CCtx* zc,
+                const BYTE* const ip, const BYTE* const iend,
+                U32 nbCompares, U32 const mls, U32 const extDict)
 {
     U32*   const hashTable = zc->hashTable;
     U32    const hashLog = zc->appliedParams.cParams.hashLog;
@@ -58,6 +59,7 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, co
     while (nbCompares-- && (matchIndex > windowLow)) {
         U32* const nextPtr = bt + 2*(matchIndex & btMask);
         size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
+        assert(matchIndex < current);
 
 #ifdef ZSTD_C_PREDICT   /* note : can create issues when hlog small <= 11 */
         const U32* predictPtr = bt + 2*((matchIndex-1) & btMask);   /* written this way, as bt is a roll buffer */
@@ -124,6 +126,36 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, co
     return 1;
 }
 
+FORCE_INLINE_TEMPLATE
+void ZSTD_updateTree_internal(ZSTD_CCtx* zc,
+                const BYTE* const ip, const BYTE* const iend,
+                const U32 nbCompares, const U32 mls, const U32 extDict)
+{
+    const BYTE* const base = zc->base;
+    U32 const target = (U32)(ip - base);
+    U32 idx = zc->nextToUpdate;
+    DEBUGLOG(7, "ZSTD_updateTree_internal, from %u to %u  (extDict:%u)",
+                idx, target, extDict);
+
+    while(idx < target)
+        idx += ZSTD_insertBt1(zc, base+idx, iend, nbCompares, mls, extDict);
+    zc->nextToUpdate = target;
+}
+
+void ZSTD_updateTree(ZSTD_CCtx* zc,
+                const BYTE* const ip, const BYTE* const iend,
+                const U32 nbCompares, const U32 mls)
+{
+    return ZSTD_updateTree_internal(zc, ip, iend, nbCompares, mls, 0 /*extDict*/);
+}
+
+void ZSTD_updateTree_extDict(ZSTD_CCtx* zc,
+                const BYTE* const ip, const BYTE* const iend,
+                const U32 nbCompares, const U32 mls)
+{
+    return ZSTD_updateTree_internal(zc, ip, iend, nbCompares, mls, 1 /*extDict*/);
+}
+
 
 static size_t ZSTD_insertBtAndFindBestMatch (
                         ZSTD_CCtx* zc,
@@ -206,16 +238,6 @@ static size_t ZSTD_insertBtAndFindBestMatch (
 }
 
 
-void ZSTD_updateTree(ZSTD_CCtx* zc, const BYTE* const ip, const BYTE* const iend, const U32 nbCompares, const U32 mls)
-{
-    const BYTE* const base = zc->base;
-    const U32 target = (U32)(ip - base);
-    U32 idx = zc->nextToUpdate;
-
-    while(idx < target)
-        idx += ZSTD_insertBt1(zc, base+idx, mls, iend, nbCompares, 0);
-}
-
 /** ZSTD_BtFindBestMatch() : Tree updater, providing best match */
 static size_t ZSTD_BtFindBestMatch (
                         ZSTD_CCtx* zc,
@@ -246,16 +268,6 @@ static size_t ZSTD_BtFindBestMatch_selectMLS (
 }
 
 
-void ZSTD_updateTree_extDict(ZSTD_CCtx* zc, const BYTE* const ip, const BYTE* const iend, const U32 nbCompares, const U32 mls)
-{
-    const BYTE* const base = zc->base;
-    const U32 target = (U32)(ip - base);
-    U32 idx = zc->nextToUpdate;
-
-    while (idx < target) idx += ZSTD_insertBt1(zc, base+idx, mls, iend, nbCompares, 1);
-}
-
-
 /** Tree updater, providing best match */
 static size_t ZSTD_BtFindBestMatch_extDict (
                         ZSTD_CCtx* zc,
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index c3814f8d2..52486bd3c 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -148,7 +148,7 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr, U32 litLength, const
         return ZSTD_getLiteralPrice(optPtr, litLength, literals) + ZSTD_highbit32((U32)mlBase+1) + 16 + offCode;
 
     price = offCode + optPtr->log2offCodeSum - ZSTD_highbit32(optPtr->offCodeFreq[offCode]+1);
-    if (!ultra /*static*/ && offCode >= 20) price += (offCode-19)*2; /* handicap for long matches, favor decompression speed */
+    if (!ultra /*static*/ && offCode >= 20) price += (offCode-19)*2; /* handicap for long distance offsets, favor decompression speed */
 
     /* match Length */
     {   U32 const mlCode = ZSTD_MLcode(mlBase);
@@ -231,8 +231,8 @@ static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* zc, const BYTE* ip)
 /*-*************************************
 *  Binary Tree search
 ***************************************/
-FORCE_INLINE_TEMPLATE
- U32 ZSTD_insertBtAndGetAllMatches (
+//FORCE_INLINE_TEMPLATE
+U32 ZSTD_insertBtAndGetAllMatches (
                         ZSTD_CCtx* zc,
                         const BYTE* const ip, const BYTE* const iLimit, const int extDict,
                         U32 nbCompares, U32 const mls,
@@ -240,22 +240,22 @@ FORCE_INLINE_TEMPLATE
                         ZSTD_match_t* matches, const U32 minMatchLen)
 {
     const BYTE* const base = zc->base;
-    const U32 current = (U32)(ip-base);
-    const U32 hashLog = zc->appliedParams.cParams.hashLog;
-    const size_t h  = ZSTD_hashPtr(ip, hashLog, mls);
+    U32 const current = (U32)(ip-base);
+    U32 const hashLog = zc->appliedParams.cParams.hashLog;
     U32 const minMatch = (mls==3) ? 3 : 4;
     U32* const hashTable = zc->hashTable;
+    size_t const h  = ZSTD_hashPtr(ip, hashLog, mls);
     U32 matchIndex  = hashTable[h];
     U32* const bt   = zc->chainTable;
-    const U32 btLog = zc->appliedParams.cParams.chainLog - 1;
-    const U32 btMask= (1U << btLog) - 1;
+    U32 const btLog = zc->appliedParams.cParams.chainLog - 1;
+    U32 const btMask= (1U << btLog) - 1;
     size_t commonLengthSmaller=0, commonLengthLarger=0;
     const BYTE* const dictBase = zc->dictBase;
-    const U32 dictLimit = zc->dictLimit;
+    U32 const dictLimit = zc->dictLimit;
     const BYTE* const dictEnd = dictBase + dictLimit;
     const BYTE* const prefixStart = base + dictLimit;
-    const U32 btLow = btMask >= current ? 0 : current - btMask;
-    const U32 windowLow = zc->lowLimit;
+    U32 const btLow = btMask >= current ? 0 : current - btMask;
+    U32 const windowLow = zc->lowLimit;
     U32* smallerPtr = bt + 2*(current&btMask);
     U32* largerPtr  = bt + 2*(current&btMask) + 1;
     U32 matchEndIdx = current+8;   /* farthest referenced position of any match => detects repetitive patterns */
@@ -263,6 +263,7 @@ FORCE_INLINE_TEMPLATE
     U32 mnum = 0;
 
     size_t bestLength = minMatchLen-1;
+    DEBUGLOG(7, "ZSTD_insertBtAndGetAllMatches");
 
     /* check repCode */
     {   U32 const lastR = ZSTD_REP_NUM + ll0;
@@ -272,20 +273,23 @@ FORCE_INLINE_TEMPLATE
             U32 const repIndex = current - repOffset;
             U32 repLen = 0;
             assert(current >= dictLimit);
-            if (!extDict /*static*/ || (repIndex>=dictLimit)) {
-                if ( (repOffset-1 /* intentional overflow, discards 0 and -1 */ < current-dictLimit)  /* within current mem segment */
-                  && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repOffset, minMatch))) {
+            if (repOffset-1 /* intentional overflow, discards 0 and -1 */ < current-dictLimit) {  /* equivalent to `current > repIndex >= dictLimit` */
+                if (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repOffset, minMatch)) {
                     repLen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repOffset, iLimit) + minMatch;
                 }
-            } else {  /* extDict */
+            } else {  /* repIndex < dictLimit || repIndex >= current */
                 const BYTE* const repMatch = dictBase + repIndex;
-                if ( ((repOffset-1) /*intentional overflow*/ < current)
-                   & (((U32)((dictLimit-1) - repIndex) >= 3) /* intentional overflow */ & (repIndex > windowLow))
+                assert(current >= windowLow);
+                if ( extDict /* this case only valid in extDict mode */
+                  && ( ((repOffset-1) /*intentional overflow*/ < current - windowLow)  /* equivalent to `current > repIndex >= windowLow` */
+                     & (((U32)((dictLimit-1) - repIndex) >= 3) ) /* intentional overflow : do not test positions overlapping 2 memory segments */)
                   && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {
                     repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, dictEnd, prefixStart) + minMatch;
             }   }
             /* save longer solution */
             if (repLen > bestLength) {
+                DEBUGLOG(8, "found rep-match %u of length %u",
+                            repCode - ll0, (U32)repLen);
                 bestLength = repLen;
                 matches[mnum].off = repCode - ll0;
                 matches[mnum].len = (U32)repLen;
@@ -298,7 +302,7 @@ FORCE_INLINE_TEMPLATE
     /* HC3 match finder */
     if ((mls == 3) /*static*/ && (bestLength < mls)) {
         U32 const matchIndex3 = ZSTD_insertAndFindFirstIndexHash3 (zc, ip);
-        if ((matchIndex3>windowLow)
+        if ((matchIndex3 > windowLow)
           & (current - matchIndex3 < (1<<18)) /*heuristic : longer distance likely too expensive*/ ) {
             size_t mlen;
             if ((!extDict) /*static*/ || (matchIndex3 >= dictLimit)) {
@@ -311,6 +315,8 @@ FORCE_INLINE_TEMPLATE
 
             /* save best solution */
             if (mlen >= mls /* == 3 > bestLength */) {
+                DEBUGLOG(8, "found small match with hlog3, of length %u",
+                            (U32)mlen);
                 bestLength = mlen;
                 assert(current > matchIndex3);
                 assert(mnum==0);  /* no prior solution */
@@ -344,6 +350,8 @@ FORCE_INLINE_TEMPLATE
         }
 
         if (matchLength > bestLength) {
+            DEBUGLOG(8, "found match of length %u at distance %u",
+                    (U32)matchLength, current - matchIndex);
             assert(matchEndIdx > matchIndex);
             if (matchLength > matchEndIdx - matchIndex)
                 matchEndIdx = matchIndex + (U32)matchLength;
@@ -386,6 +394,7 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_BtGetAllMatches (
                         U32 rep[ZSTD_REP_NUM], U32 const ll0,
                         ZSTD_match_t* matches, const U32 minMatchLen)
 {
+    DEBUGLOG(7, "ZSTD_BtGetAllMatches");
     if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */
     if (extDict) ZSTD_updateTree_extDict(zc, ip, iHighLimit, maxNbAttempts, matchLengthSearch);
     else ZSTD_updateTree(zc, ip, iHighLimit, maxNbAttempts, matchLengthSearch);
@@ -465,6 +474,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
     U32 rep[ZSTD_REP_NUM];
 
     /* init */
+    DEBUGLOG(5, "ZSTD_compressBlock_opt_generic");
     ctx->nextToUpdate3 = ctx->nextToUpdate;
     ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize);
     ip += (ip==prefixStart);
@@ -653,6 +663,7 @@ _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
 
 size_t ZSTD_compressBlock_btopt(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
 {
+    DEBUGLOG(5, "ZSTD_compressBlock_btopt");
     return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 0 /*ultra*/, 0 /*extDict*/);
 }
 
diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c
index 0b9173f3b..2926d3b48 100644
--- a/lib/compress/zstdmt_compress.c
+++ b/lib/compress/zstdmt_compress.c
@@ -412,13 +412,14 @@ struct ZSTDMT_CCtx_s {
     ZSTDMT_CCtxPool* cctxPool;
     ZSTD_pthread_mutex_t jobCompleted_mutex;
     ZSTD_pthread_cond_t jobCompleted_cond;
+    ZSTD_CCtx_params params;
     size_t targetSectionSize;
     size_t inBuffSize;
     size_t dictSize;
     size_t targetDictSize;
     inBuff_t inBuff;
-    ZSTD_CCtx_params params;
     XXH64_state_t xxhState;
+    unsigned singleThreaded;
     unsigned jobIDMask;
     unsigned doneJobID;
     unsigned nextJobID;
@@ -439,20 +440,23 @@ static ZSTDMT_jobDescription* ZSTDMT_allocJobsTable(U32* nbJobsPtr, ZSTD_customM
                             nbJobs * sizeof(ZSTDMT_jobDescription), cMem);
 }
 
-/* Internal only */
-size_t ZSTDMT_initializeCCtxParameters(ZSTD_CCtx_params* params, unsigned nbThreads)
+/* ZSTDMT_CCtxParam_setNbThreads():
+ * Internal use only */
+size_t ZSTDMT_CCtxParam_setNbThreads(ZSTD_CCtx_params* params, unsigned nbThreads)
 {
+    if (nbThreads > ZSTDMT_NBTHREADS_MAX) nbThreads = ZSTDMT_NBTHREADS_MAX;
+    if (nbThreads < 1) nbThreads = 1;
     params->nbThreads = nbThreads;
     params->overlapSizeLog = ZSTDMT_OVERLAPLOG_DEFAULT;
     params->jobSize = 0;
-    return 0;
+    return nbThreads;
 }
 
 ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbThreads, ZSTD_customMem cMem)
 {
     ZSTDMT_CCtx* mtctx;
     U32 nbJobs = nbThreads + 2;
-    DEBUGLOG(3, "ZSTDMT_createCCtx_advanced");
+    DEBUGLOG(3, "ZSTDMT_createCCtx_advanced (nbThreads = %u)", nbThreads);
 
     if (nbThreads < 1) return NULL;
     nbThreads = MIN(nbThreads , ZSTDMT_NBTHREADS_MAX);
@@ -462,7 +466,7 @@ ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbThreads, ZSTD_customMem cMem)
 
     mtctx = (ZSTDMT_CCtx*) ZSTD_calloc(sizeof(ZSTDMT_CCtx), cMem);
     if (!mtctx) return NULL;
-    ZSTDMT_initializeCCtxParameters(&mtctx->params, nbThreads);
+    ZSTDMT_CCtxParam_setNbThreads(&mtctx->params, nbThreads);
     mtctx->cMem = cMem;
     mtctx->allJobsCompleted = 1;
     mtctx->factory = POOL_create_advanced(nbThreads, 0, cMem);
@@ -559,12 +563,16 @@ size_t ZSTDMT_CCtxParam_setMTCtxParameter(
     switch(parameter)
     {
     case ZSTDMT_p_sectionSize :
+        if ( (value > 0)  /* value==0 => automatic job size */
+           & (value < ZSTDMT_JOBSIZE_MIN) )
+            value = ZSTDMT_JOBSIZE_MIN;
         params->jobSize = value;
-        return 0;
+        return value;
     case ZSTDMT_p_overlapSectionLog :
+        if (value > 9) value = 9;
         DEBUGLOG(4, "ZSTDMT_p_overlapSectionLog : %u", value);
         params->overlapSizeLog = (value >= 9) ? 9 : value;
-        return 0;
+        return value;
     default :
         return ERROR(parameter_unsupported);
     }
@@ -763,13 +771,14 @@ size_t ZSTDMT_initCStream_internal(
         const ZSTD_CDict* cdict, ZSTD_CCtx_params params,
         unsigned long long pledgedSrcSize)
 {
-    DEBUGLOG(4, "ZSTDMT_initCStream_internal");
+    DEBUGLOG(4, "ZSTDMT_initCStream_internal (pledgedSrcSize=%u)", (U32)pledgedSrcSize);
     /* params are supposed to be fully validated at this point */
     assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
     assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
     assert(zcs->cctxPool->totalCCtx == params.nbThreads);
+    zcs->singleThreaded = (params.nbThreads==1) | (pledgedSrcSize <= ZSTDMT_JOBSIZE_MIN);  /* do not trigger multi-threading when srcSize is too small */
 
-    if (params.nbThreads==1) {
+    if (zcs->singleThreaded) {
         ZSTD_CCtx_params const singleThreadParams = ZSTDMT_makeJobCCtxParams(params);
         DEBUGLOG(4, "single thread mode");
         assert(singleThreadParams.nbThreads == 0);
@@ -777,7 +786,7 @@ size_t ZSTDMT_initCStream_internal(
                                          dict, dictSize, cdict,
                                          singleThreadParams, pledgedSrcSize);
     }
-    DEBUGLOG(4, "multi - threading mode");
+    DEBUGLOG(4, "multi-threading mode (%u threads)", params.nbThreads);
 
     if (zcs->allJobsCompleted == 0) {   /* previous compression not correctly finished */
         ZSTDMT_waitForAllJobsCompleted(zcs);
@@ -800,13 +809,13 @@ size_t ZSTDMT_initCStream_internal(
         zcs->cdict = cdict;
     }
 
+    assert(params.overlapSizeLog <= 9);
     zcs->targetDictSize = (params.overlapSizeLog==0) ? 0 : (size_t)1 << (params.cParams.windowLog - (9 - params.overlapSizeLog));
-    DEBUGLOG(4, "overlapLog : %u ", params.overlapSizeLog);
-    DEBUGLOG(4, "overlap Size : %u KB", (U32)(zcs->targetDictSize>>10));
+    DEBUGLOG(4, "overlapLog=%u => %u KB", params.overlapSizeLog, (U32)(zcs->targetDictSize>>10));
     zcs->targetSectionSize = params.jobSize ? params.jobSize : (size_t)1 << (params.cParams.windowLog + 2);
-    zcs->targetSectionSize = MAX(ZSTDMT_SECTION_SIZE_MIN, zcs->targetSectionSize);
-    zcs->targetSectionSize = MAX(zcs->targetDictSize, zcs->targetSectionSize);   /* one job size must be at least overlap */
-    DEBUGLOG(4, "Section Size : %u KB", (U32)(zcs->targetSectionSize>>10));
+    if (zcs->targetSectionSize < ZSTDMT_JOBSIZE_MIN) zcs->targetSectionSize = ZSTDMT_JOBSIZE_MIN;
+    if (zcs->targetSectionSize < zcs->targetDictSize) zcs->targetSectionSize = zcs->targetDictSize;  /* job size must be >= overlap size */
+    DEBUGLOG(4, "Job Size : %u KB", (U32)(zcs->targetSectionSize>>10));
     zcs->inBuffSize = zcs->targetDictSize + zcs->targetSectionSize;
     DEBUGLOG(4, "inBuff Size : %u KB", (U32)(zcs->inBuffSize>>10));
     ZSTDMT_setBufferSize(zcs->bufPool, MAX(zcs->inBuffSize, ZSTD_compressBound(zcs->targetSectionSize)) );
@@ -826,7 +835,7 @@ size_t ZSTDMT_initCStream_advanced(ZSTDMT_CCtx* mtctx,
                                    unsigned long long pledgedSrcSize)
 {
     ZSTD_CCtx_params cctxParams = mtctx->params;
-    DEBUGLOG(5, "ZSTDMT_initCStream_advanced");
+    DEBUGLOG(5, "ZSTDMT_initCStream_advanced (pledgedSrcSize=%u)", (U32)pledgedSrcSize);
     cctxParams.cParams = params.cParams;
     cctxParams.fParams = params.fParams;
     return ZSTDMT_initCStream_internal(mtctx, dict, dictSize, ZSTD_dm_auto, NULL,
@@ -1008,13 +1017,15 @@ size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
     DEBUGLOG(5, "ZSTDMT_compressStream_generic");
     assert(output->pos <= output->size);
     assert(input->pos  <= input->size);
+
+    if (mtctx->singleThreaded) {  /* delegate to single-thread (synchronous) */
+        return ZSTD_compressStream_generic(mtctx->cctxPool->cctx[0], output, input, endOp);
+    }
+
     if ((mtctx->frameEnded) && (endOp==ZSTD_e_continue)) {
         /* current frame being ended. Only flush/end are allowed */
         return ERROR(stage_wrong);
     }
-    if (mtctx->params.nbThreads==1) {  /* delegate to single-thread (synchronous) */
-        return ZSTD_compressStream_generic(mtctx->cctxPool->cctx[0], output, input, endOp);
-    }
 
     /* single-pass shortcut (note : synchronous-mode) */
     if ( (mtctx->nextJobID == 0)     /* just started */
@@ -1083,32 +1094,32 @@ size_t ZSTDMT_compressStream(ZSTDMT_CCtx* zcs, ZSTD_outBuffer* output, ZSTD_inBu
 }
 
 
-static size_t ZSTDMT_flushStream_internal(ZSTDMT_CCtx* zcs, ZSTD_outBuffer* output, unsigned endFrame)
+static size_t ZSTDMT_flushStream_internal(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, unsigned endFrame)
 {
-    size_t const srcSize = zcs->inBuff.filled - zcs->dictSize;
+    size_t const srcSize = mtctx->inBuff.filled - mtctx->dictSize;
 
-    if ( ((srcSize > 0) || (endFrame && !zcs->frameEnded))
-       && (zcs->nextJobID <= zcs->doneJobID + zcs->jobIDMask) ) {
-        CHECK_F( ZSTDMT_createCompressionJob(zcs, srcSize, endFrame) );
+    if ( ((srcSize > 0) || (endFrame && !mtctx->frameEnded))
+       && (mtctx->nextJobID <= mtctx->doneJobID + mtctx->jobIDMask) ) {
+        CHECK_F( ZSTDMT_createCompressionJob(mtctx, srcSize, endFrame) );
     }
 
     /* check if there is any data available to flush */
-    return ZSTDMT_flushNextJob(zcs, output, 1 /* blockToFlush */);
+    return ZSTDMT_flushNextJob(mtctx, output, 1 /* blockToFlush */);
 }
 
 
-size_t ZSTDMT_flushStream(ZSTDMT_CCtx* zcs, ZSTD_outBuffer* output)
+size_t ZSTDMT_flushStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output)
 {
     DEBUGLOG(5, "ZSTDMT_flushStream");
-    if (zcs->params.nbThreads==1)
-        return ZSTD_flushStream(zcs->cctxPool->cctx[0], output);
-    return ZSTDMT_flushStream_internal(zcs, output, 0 /* endFrame */);
+    if (mtctx->singleThreaded)
+        return ZSTD_flushStream(mtctx->cctxPool->cctx[0], output);
+    return ZSTDMT_flushStream_internal(mtctx, output, 0 /* endFrame */);
 }
 
-size_t ZSTDMT_endStream(ZSTDMT_CCtx* zcs, ZSTD_outBuffer* output)
+size_t ZSTDMT_endStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output)
 {
     DEBUGLOG(4, "ZSTDMT_endStream");
-    if (zcs->params.nbThreads==1)
-        return ZSTD_endStream(zcs->cctxPool->cctx[0], output);
-    return ZSTDMT_flushStream_internal(zcs, output, 1 /* endFrame */);
+    if (mtctx->singleThreaded)
+        return ZSTD_endStream(mtctx->cctxPool->cctx[0], output);
+    return ZSTDMT_flushStream_internal(mtctx, output, 1 /* endFrame */);
 }
diff --git a/lib/compress/zstdmt_compress.h b/lib/compress/zstdmt_compress.h
index a7ce7c7dd..598e6daf5 100644
--- a/lib/compress/zstdmt_compress.h
+++ b/lib/compress/zstdmt_compress.h
@@ -60,8 +60,8 @@ ZSTDLIB_API size_t ZSTDMT_endStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output);
 
 /* ===   Advanced functions and parameters  === */
 
-#ifndef ZSTDMT_SECTION_SIZE_MIN
-#  define ZSTDMT_SECTION_SIZE_MIN (1U << 20)   /* 1 MB - Minimum size of each compression job */
+#ifndef ZSTDMT_JOBSIZE_MIN
+#  define ZSTDMT_JOBSIZE_MIN (1U << 20)   /* 1 MB - Minimum size of each compression job */
 #endif
 
 ZSTDLIB_API size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,
@@ -112,7 +112,7 @@ ZSTDLIB_API size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
 
 size_t ZSTDMT_CCtxParam_setMTCtxParameter(ZSTD_CCtx_params* params, ZSTDMT_parameter parameter, unsigned value);
 
-size_t ZSTDMT_initializeCCtxParameters(ZSTD_CCtx_params* params, unsigned nbThreads);
+size_t ZSTDMT_CCtxParam_setNbThreads(ZSTD_CCtx_params* params, unsigned nbThreads);
 
 /*! ZSTDMT_initCStream_internal() :
  *  Private use only. Init streaming operation.
diff --git a/lib/zstd.h b/lib/zstd.h
index 6b7bfd03c..f07c9eed2 100644
--- a/lib/zstd.h
+++ b/lib/zstd.h
@@ -1059,7 +1059,8 @@ typedef enum {
 /*! ZSTD_CCtx_setParameter() :
  *  Set one compression parameter, selected by enum ZSTD_cParameter.
  *  Note : when `value` is an enum, cast it to unsigned for proper type checking.
- *  @result : 0, or an error code (which can be tested with ZSTD_isError()). */
+ *  @result : informational value (typically, the one being set, possibly corrected),
+ *            or an error code (which can be tested with ZSTD_isError()). */
 ZSTDLIB_API size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned value);
 
 /*! ZSTD_CCtx_setPledgedSrcSize() :

From 15768cabb580fa8fab7a3838861eba307a655b68 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Thu, 16 Nov 2017 15:02:28 -0800
Subject: [PATCH 053/145] fixed some complex scenarios

Fixed : multithreading to compress some small data with dictionary
Fixed : ZSTD_initCStream_usingCDict()
Improved streaming memory usage when pledgedSrcSize is known.
---
 lib/compress/zstd_compress.c   | 70 +++++++++++++++++-----------------
 lib/compress/zstd_opt.c        |  2 +-
 lib/compress/zstdmt_compress.h |  3 ++
 tests/zstreamtest.c            |  8 +++-
 4 files changed, 44 insertions(+), 39 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 0bdcc26ab..f0cebe7a3 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -249,7 +249,6 @@ size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned v
         return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 
     case ZSTD_p_compressionLevel:
-        if (value == 0) return 0;  /* special value : 0 means "don't change anything" */
         if (cctx->cdict) return ERROR(stage_wrong);
         return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 
@@ -260,7 +259,6 @@ size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned v
     case ZSTD_p_minMatch:
     case ZSTD_p_targetLength:
     case ZSTD_p_compressionStrategy:
-        if (value == 0) return 0;  /* special value : 0 means "don't change anything" */
         if (cctx->cdict) return ERROR(stage_wrong);
         ZSTD_cLevelToCParams(cctx);  /* Can optimize if srcSize is known */
         return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
@@ -277,8 +275,6 @@ size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned v
         return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 
     case ZSTD_p_nbThreads:
-        if (value==0) return 0;
-        DEBUGLOG(5, " setting nbThreads : %u", value);
         if (value > 1 && cctx->staticSize) {
             return ERROR(parameter_unsupported);  /* MT not compatible with static alloc */
         }
@@ -288,22 +284,15 @@ size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned v
         return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 
     case ZSTD_p_overlapSizeLog:
-        DEBUGLOG(5, " setting overlap with nbThreads == %u", cctx->requestedParams.nbThreads);
         return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 
     case ZSTD_p_enableLongDistanceMatching:
         if (cctx->cdict) return ERROR(stage_wrong);
-        if (value != 0) {
-            ZSTD_cLevelToCParams(cctx);
-        }
+        if (value>0) ZSTD_cLevelToCParams(cctx);
         return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 
     case ZSTD_p_ldmHashLog:
     case ZSTD_p_ldmMinMatch:
-        if (value == 0) return 0;  /* special value : 0 means "don't change anything" */
-        if (cctx->cdict) return ERROR(stage_wrong);
-        return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
-
     case ZSTD_p_ldmBucketSizeLog:
     case ZSTD_p_ldmHashEveryLog:
         if (cctx->cdict) return ERROR(stage_wrong);
@@ -779,24 +768,27 @@ static U32 ZSTD_equivalentLdmParams(ldmParams_t ldmParams1,
 
 typedef enum { ZSTDb_not_buffered, ZSTDb_buffered } ZSTD_buffered_policy_e;
 
-/* ZSTD_equivalentBuffPolicy() :
+/* ZSTD_sufficientBuff() :
  * check internal buffers exist for streaming if buffPol == ZSTDb_buffered .
  * Note : they are assumed to be correctly sized if ZSTD_equivalentCParams()==1 */
-static U32 ZSTD_equivalentBuffPolicy(size_t bufferSize, ZSTD_buffered_policy_e buffPol)
+static U32 ZSTD_sufficientBuff(size_t bufferSize, ZSTD_buffered_policy_e buffPol, ZSTD_compressionParameters cParams2, U64 pledgedSrcSize)
 {
-    if ((buffPol == ZSTDb_buffered) & (!bufferSize)) return 0;
-    return 1;
+    size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << cParams2.windowLog), pledgedSrcSize));
+    size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, windowSize);
+    size_t const neededBufferSize = (buffPol==ZSTDb_buffered) ? windowSize + blockSize : 0;
+    return (neededBufferSize <= bufferSize);
 }
 
 /** Equivalence for resetCCtx purposes */
 static U32 ZSTD_equivalentParams(ZSTD_CCtx_params params1,
                                  ZSTD_CCtx_params params2,
                                  size_t buffSize1,
-                                 ZSTD_buffered_policy_e buffPol2)
+                                 ZSTD_buffered_policy_e buffPol2,
+                                 U64 pledgedSrcSize)
 {
     return ZSTD_equivalentCParams(params1.cParams, params2.cParams) &&
            ZSTD_equivalentLdmParams(params1.ldmParams, params2.ldmParams) &&
-           ZSTD_equivalentBuffPolicy(buffSize1, buffPol2);
+           ZSTD_sufficientBuff(buffSize1, buffPol2, params2.cParams, pledgedSrcSize);
 }
 
 /*! ZSTD_continueCCtx() :
@@ -837,7 +829,7 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
     assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
 
     if (crp == ZSTDcrp_continue) {
-        if (ZSTD_equivalentParams(params, zc->appliedParams, zc->inBuffSize, zbuff)) {
+        if (ZSTD_equivalentParams(params, zc->appliedParams, zc->inBuffSize, zbuff, pledgedSrcSize)) {
             DEBUGLOG(4, "ZSTD_equivalentParams()==1 -> continue mode");
             assert(!(params.ldmParams.enableLdm &&
                      params.ldmParams.hashEveryLog == ZSTD_LDM_HASHEVERYLOG_NOTSET));
@@ -858,7 +850,8 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
                 ZSTD_ldm_getHashPower(params.ldmParams.minMatchLength);
     }
 
-    {   size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << params.cParams.windowLog);
+    {   size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << params.cParams.windowLog), pledgedSrcSize));
+        size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, windowSize);
         U32    const divider = (params.cParams.searchLength==3) ? 3 : 4;
         size_t const maxNbSeq = blockSize / divider;
         size_t const tokenSpace = blockSize + 11*maxNbSeq;
@@ -870,7 +863,7 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
         size_t const h3Size = ((size_t)1) << hashLog3;
         size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);
         size_t const buffOutSize = (zbuff==ZSTDb_buffered) ? ZSTD_compressBound(blockSize)+1 : 0;
-        size_t const buffInSize = (zbuff==ZSTDb_buffered) ? ((size_t)1 << params.cParams.windowLog) + blockSize : 0;
+        size_t const buffInSize = (zbuff==ZSTDb_buffered) ? windowSize + blockSize : 0;
         void* ptr;
 
         /* Check if workSpace is large enough, alloc a new one if needed */
@@ -886,10 +879,10 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
                 : 0;
             size_t const neededSpace = entropySpace + optSpace + ldmSpace +
                                        tableSpace + tokenSpace + bufferSpace;
-            DEBUGLOG(4, "Need %uKB workspace, including %uKB for tables",
-                        (U32)(neededSpace>>10), (U32)(tableSpace>>10));
-            DEBUGLOG(4, "chainSize: %u - hSize: %u - h3Size: %u",
-                        (U32)chainSize, (U32)hSize, (U32)h3Size);
+            DEBUGLOG(4, "Need %uKB workspace, including %uKB for tables, and %uKB for buffers",
+                        (U32)(neededSpace>>10), (U32)(tableSpace>>10), (U32)(bufferSpace>>10));
+            DEBUGLOG(4, "chainSize: %u - hSize: %u - h3Size: %u - windowSize: %u",
+                        (U32)chainSize, (U32)hSize, (U32)h3Size, (U32)windowSize);
 
             if (zc->workSpaceSize < neededSpace) {  /* too small : resize */
                 DEBUGLOG(4, "Need to update workSpaceSize from %uK to %uK",
@@ -917,7 +910,7 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
         zc->consumedSrcSize = 0;
         if (pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN)
             zc->appliedParams.fParams.contentSizeFlag = 0;
-        DEBUGLOG(5, "pledged content size : %u ; flag : %u",
+        DEBUGLOG(4, "pledged content size : %u ; flag : %u",
             (U32)pledgedSrcSize, zc->appliedParams.fParams.contentSizeFlag);
         zc->blockSize = blockSize;
 
@@ -1016,8 +1009,8 @@ void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx) {
 
 /*! ZSTD_copyCCtx_internal() :
  *  Duplicate an existing context `srcCCtx` into another one `dstCCtx`.
- *  The "context", in this case, refers to the hash and chain tables, entropy
- *  tables, and dictionary offsets.
+ *  The "context", in this case, refers to the hash and chain tables,
+ *  entropy tables, and dictionary offsets.
  *  Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()).
  *  pledgedSrcSize=0 means "empty".
  *  @return : 0, or an error code */
@@ -2079,6 +2072,7 @@ static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
     assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
 
     if (cdict && cdict->dictContentSize>0) {
+        cctx->requestedParams = params;
         return ZSTD_copyCCtx_internal(cctx, cdict->refContext,
                                       params.fParams, pledgedSrcSize,
                                       zbuff);
@@ -2525,9 +2519,9 @@ size_t ZSTD_CStreamOutSize(void)
 }
 
 static size_t ZSTD_resetCStream_internal(ZSTD_CStream* zcs,
-                    const void* dict, size_t dictSize, ZSTD_dictMode_e dictMode,
-                    const ZSTD_CDict* cdict,
-                    const ZSTD_CCtx_params params, unsigned long long pledgedSrcSize)
+                    const void* const dict, size_t const dictSize, ZSTD_dictMode_e const dictMode,
+                    const ZSTD_CDict* const cdict,
+                    ZSTD_CCtx_params const params, unsigned long long const pledgedSrcSize)
 {
     DEBUGLOG(4, "ZSTD_resetCStream_internal");
     /* params are supposed to be fully validated at this point */
@@ -2606,8 +2600,9 @@ size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
                                             const ZSTD_CDict* cdict,
                                             ZSTD_frameParameters fParams,
                                             unsigned long long pledgedSrcSize)
-{   /* cannot handle NULL cdict (does not know what to do) */
-    if (!cdict) return ERROR(dictionary_wrong);
+{
+    DEBUGLOG(4, "ZSTD_initCStream_usingCDict_advanced");
+    if (!cdict) return ERROR(dictionary_wrong); /* cannot handle NULL cdict (does not know what to do) */
     {   ZSTD_CCtx_params params = zcs->requestedParams;
         params.cParams = ZSTD_getCParamsFromCDict(cdict);
         params.fParams = fParams;
@@ -2620,8 +2615,9 @@ size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
 /* note : cdict must outlive compression session */
 size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)
 {
-    ZSTD_frameParameters const fParams = { 0 /* contentSize */, 0 /* checksum */, 0 /* hideDictID */ };
-    return ZSTD_initCStream_usingCDict_advanced(zcs, cdict, fParams, 0);  /* note : will check that cdict != NULL */
+    ZSTD_frameParameters const fParams = { 0 /* contentSizeFlag */, 0 /* checksum */, 0 /* hideDictID */ };
+    DEBUGLOG(4, "ZSTD_initCStream_usingCDict");
+    return ZSTD_initCStream_usingCDict_advanced(zcs, cdict, fParams, ZSTD_CONTENTSIZE_UNKNOWN);  /* note : will check that cdict != NULL */
 }
 
 /* ZSTD_initCStream_advanced() :
@@ -2853,7 +2849,8 @@ size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
                 cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1, 0 /*dictSize*/);
 
 #ifdef ZSTD_MULTITHREAD
-        if ((cctx->pledgedSrcSizePlusOne-1) <= ZSTDMT_JOBSIZE_MIN) params.nbThreads = 1; /* do not invoke multi-threading when src size is too small */
+        if ((cctx->pledgedSrcSizePlusOne-1) <= ZSTDMT_JOBSIZE_MIN)
+            params.nbThreads = 1; /* do not invoke multi-threading when src size is too small */
         if (params.nbThreads > 1) {
             if (cctx->mtctx == NULL || cctx->appliedParams.nbThreads != params.nbThreads) {
                 ZSTDMT_freeCCtx(cctx->mtctx);
@@ -2874,6 +2871,7 @@ size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
                              prefixDict.dictMode, cctx->cdict, params,
                              cctx->pledgedSrcSizePlusOne-1) );
             assert(cctx->streamStage == zcss_load);
+            assert(cctx->appliedParams.nbThreads <= 1);
     }   }
 
     /* compression stage */
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index 52486bd3c..aebe55f88 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -231,7 +231,7 @@ static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* zc, const BYTE* ip)
 /*-*************************************
 *  Binary Tree search
 ***************************************/
-//FORCE_INLINE_TEMPLATE
+FORCE_INLINE_TEMPLATE
 U32 ZSTD_insertBtAndGetAllMatches (
                         ZSTD_CCtx* zc,
                         const BYTE* const ip, const BYTE* const iLimit, const int extDict,
diff --git a/lib/compress/zstdmt_compress.h b/lib/compress/zstdmt_compress.h
index 598e6daf5..269c54b1a 100644
--- a/lib/compress/zstdmt_compress.h
+++ b/lib/compress/zstdmt_compress.h
@@ -112,6 +112,9 @@ ZSTDLIB_API size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
 
 size_t ZSTDMT_CCtxParam_setMTCtxParameter(ZSTD_CCtx_params* params, ZSTDMT_parameter parameter, unsigned value);
 
+/* ZSTDMT_CCtxParam_setNbThreads()
+ * Set nbThreads, and clamp it correctly,
+ * but also reset jobSize and overlapLog */ 
 size_t ZSTDMT_CCtxParam_setNbThreads(ZSTD_CCtx_params* params, unsigned nbThreads);
 
 /*! ZSTDMT_initCStream_internal() :
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index 384858edd..4cdd6235b 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -473,6 +473,7 @@ static int basicUnitTests(U32 seed, double compressibility, ZSTD_customMem custo
     DISPLAYLEVEL(3, "test%3i : digested dictionary : ", testNb++);
     {   ZSTD_CDict* const cdict = ZSTD_createCDict(dictionary.start, dictionary.filled, 1 /*byRef*/ );
         size_t const initError = ZSTD_initCStream_usingCDict(zc, cdict);
+        DISPLAYLEVEL(5, "ZSTD_initCStream_usingCDict result : %u ", (U32)initError);
         if (ZSTD_isError(initError)) goto _output_error;
         cSize = 0;
         outBuff.dst = compressedBuffer;
@@ -481,10 +482,13 @@ static int basicUnitTests(U32 seed, double compressibility, ZSTD_customMem custo
         inBuff.src = CNBuffer;
         inBuff.size = CNBufferSize;
         inBuff.pos = 0;
+        DISPLAYLEVEL(5, "- starting ZSTD_compressStream ");
         CHECK_Z( ZSTD_compressStream(zc, &outBuff, &inBuff) );
         if (inBuff.pos != inBuff.size) goto _output_error;   /* entire input should be consumed */
-        { size_t const r = ZSTD_endStream(zc, &outBuff);
-          if (r != 0) goto _output_error; }  /* error, or some data not flushed */
+        {   size_t const r = ZSTD_endStream(zc, &outBuff);
+            DISPLAYLEVEL(5, "- ZSTD_endStream result : %u ", (U32)r);
+            if (r != 0) goto _output_error;  /* error, or some data not flushed */
+        }
         cSize = outBuff.pos;
         ZSTD_freeCDict(cdict);
         DISPLAYLEVEL(3, "OK (%u bytes : %.2f%%)\n", (U32)cSize, (double)cSize/CNBufferSize*100);

From 11e58d9ba46d26132767c0141e0e0d8c80453378 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Thu, 16 Nov 2017 15:21:30 -0800
Subject: [PATCH 054/145] fixed minor warning

warning: void function returning a value
(even if the return value is void)
---
 lib/compress/zstd_lazy.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/compress/zstd_lazy.c b/lib/compress/zstd_lazy.c
index d7ef039f0..cd3d1530a 100644
--- a/lib/compress/zstd_lazy.c
+++ b/lib/compress/zstd_lazy.c
@@ -146,14 +146,14 @@ void ZSTD_updateTree(ZSTD_CCtx* zc,
                 const BYTE* const ip, const BYTE* const iend,
                 const U32 nbCompares, const U32 mls)
 {
-    return ZSTD_updateTree_internal(zc, ip, iend, nbCompares, mls, 0 /*extDict*/);
+    ZSTD_updateTree_internal(zc, ip, iend, nbCompares, mls, 0 /*extDict*/);
 }
 
 void ZSTD_updateTree_extDict(ZSTD_CCtx* zc,
                 const BYTE* const ip, const BYTE* const iend,
                 const U32 nbCompares, const U32 mls)
 {
-    return ZSTD_updateTree_internal(zc, ip, iend, nbCompares, mls, 1 /*extDict*/);
+    ZSTD_updateTree_internal(zc, ip, iend, nbCompares, mls, 1 /*extDict*/);
 }
 
 

From 8accfa7fcc3da7d1f81a4b3e879293fd393a1099 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 17 Nov 2017 00:02:37 -0800
Subject: [PATCH 055/145] bench: realTime is a global parameter

like most parameters not directly related to compression
---
 programs/bench.c   | 35 ++++++++++++++++++++++-------------
 programs/bench.h   |  3 ++-
 programs/zstdcli.c |  3 ++-
 3 files changed, 26 insertions(+), 15 deletions(-)

diff --git a/programs/bench.c b/programs/bench.c
index 6525f3371..c61273936 100644
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -129,6 +129,12 @@ void BMK_setNbThreads(unsigned nbThreads) {
 #endif
     g_nbThreads = nbThreads;
 }
+
+static U32 g_realTime = 0;
+void BMK_setRealTime(unsigned priority) {
+    g_realTime = (priority>0);
+}
+
 static U32 g_ldmFlag = 0;
 void BMK_setLdmFlag(unsigned ldmFlag) {
     g_ldmFlag = ldmFlag;
@@ -480,7 +486,7 @@ static void BMK_benchCLevel(void* srcBuffer, size_t benchedSize,
                             const char* displayName, int cLevel, int cLevelLast,
                             const size_t* fileSizes, unsigned nbFiles,
                             const void* dictBuffer, size_t dictBufferSize,
-                            ZSTD_compressionParameters *compressionParams, int setRealTimePrio)
+                            ZSTD_compressionParameters *compressionParams)
 {
     int l;
 
@@ -488,8 +494,8 @@ static void BMK_benchCLevel(void* srcBuffer, size_t benchedSize,
     if (!pch) pch = strrchr(displayName, '/'); /* Linux */
     if (pch) displayName = pch+1;
 
-    if (setRealTimePrio) {
-        DISPLAYLEVEL(2, "Note : switching to a real-time priority \n");
+    if (g_realTime) {
+        DISPLAYLEVEL(2, "Note : switching to real-time priority \n");
         SET_REALTIME_PRIORITY;
     }
 
@@ -545,7 +551,7 @@ static void BMK_loadFiles(void* buffer, size_t bufferSize,
 }
 
 static void BMK_benchFileTable(const char** fileNamesTable, unsigned nbFiles, const char* dictFileName, int cLevel,
-                               int cLevelLast, ZSTD_compressionParameters *compressionParams, int setRealTimePrio)
+                               int cLevelLast, ZSTD_compressionParameters *compressionParams)
 {
     void* srcBuffer;
     size_t benchedSize;
@@ -583,11 +589,11 @@ static void BMK_benchFileTable(const char** fileNamesTable, unsigned nbFiles, co
 
     /* Bench */
     snprintf (mfName, sizeof(mfName), " %u files", nbFiles);
-    {   const char* displayName = (nbFiles > 1) ? mfName : fileNamesTable[0];
+    {   const char* const displayName = (nbFiles > 1) ? mfName : fileNamesTable[0];
         BMK_benchCLevel(srcBuffer, benchedSize,
                         displayName, cLevel, cLevelLast,
                         fileSizes, nbFiles,
-                        dictBuffer, dictBufferSize, compressionParams, setRealTimePrio);
+                        dictBuffer, dictBufferSize, compressionParams);
     }
 
     /* clean up */
@@ -597,7 +603,7 @@ static void BMK_benchFileTable(const char** fileNamesTable, unsigned nbFiles, co
 }
 
 
-static void BMK_syntheticTest(int cLevel, int cLevelLast, double compressibility, ZSTD_compressionParameters* compressionParams, int setRealTimePrio)
+static void BMK_syntheticTest(int cLevel, int cLevelLast, double compressibility, ZSTD_compressionParameters* compressionParams)
 {
     char name[20] = {0};
     size_t benchedSize = 10000000;
@@ -611,15 +617,17 @@ static void BMK_syntheticTest(int cLevel, int cLevelLast, double compressibility
 
     /* Bench */
     snprintf (name, sizeof(name), "Synthetic %2u%%", (unsigned)(compressibility*100));
-    BMK_benchCLevel(srcBuffer, benchedSize, name, cLevel, cLevelLast, &benchedSize, 1, NULL, 0, compressionParams, setRealTimePrio);
+    BMK_benchCLevel(srcBuffer, benchedSize, name, cLevel, cLevelLast, &benchedSize, 1, NULL, 0, compressionParams);
 
     /* clean up */
     free(srcBuffer);
 }
 
 
-int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles, const char* dictFileName,
-                   int cLevel, int cLevelLast, ZSTD_compressionParameters* compressionParams, int setRealTimePrio)
+int BMK_benchFiles(const char** const fileNamesTable, unsigned const nbFiles,
+                   const char* dictFileName,
+                   int cLevel, int cLevelLast,
+                   ZSTD_compressionParameters* compressionParams)
 {
     double const compressibility = (double)g_compressibilityDefault / 100;
 
@@ -627,11 +635,12 @@ int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles, const char* di
     if (cLevel > ZSTD_maxCLevel()) cLevel = ZSTD_maxCLevel();
     if (cLevelLast > ZSTD_maxCLevel()) cLevelLast = ZSTD_maxCLevel();
     if (cLevelLast < cLevel) cLevelLast = cLevel;
-    if (cLevelLast > cLevel) DISPLAYLEVEL(2, "Benchmarking levels from %d to %d\n", cLevel, cLevelLast);
+    if (cLevelLast > cLevel)
+        DISPLAYLEVEL(2, "Benchmarking levels from %d to %d\n", cLevel, cLevelLast);
 
     if (nbFiles == 0)
-        BMK_syntheticTest(cLevel, cLevelLast, compressibility, compressionParams, setRealTimePrio);
+        BMK_syntheticTest(cLevel, cLevelLast, compressibility, compressionParams);
     else
-        BMK_benchFileTable(fileNamesTable, nbFiles, dictFileName, cLevel, cLevelLast, compressionParams, setRealTimePrio);
+        BMK_benchFileTable(fileNamesTable, nbFiles, dictFileName, cLevel, cLevelLast, compressionParams);
     return 0;
 }
diff --git a/programs/bench.h b/programs/bench.h
index 82bb34569..f4d415488 100644
--- a/programs/bench.h
+++ b/programs/bench.h
@@ -17,12 +17,13 @@
 #include "zstd.h"     /* ZSTD_compressionParameters */
 
 int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles,const char* dictFileName,
-                   int cLevel, int cLevelLast, ZSTD_compressionParameters* compressionParams, int setRealTimePrio);
+                   int cLevel, int cLevelLast, ZSTD_compressionParameters* compressionParams);
 
 /* Set Parameters */
 void BMK_setNbSeconds(unsigned nbLoops);
 void BMK_setBlockSize(size_t blockSize);
 void BMK_setNbThreads(unsigned nbThreads);
+void BMK_setRealTime(unsigned priority);
 void BMK_setNotificationLevel(unsigned level);
 void BMK_setAdditionalParam(int additionalParam);
 void BMK_setDecodeOnlyMode(unsigned decodeFlag);
diff --git a/programs/zstdcli.c b/programs/zstdcli.c
index 3f8367341..d5cb6285c 100644
--- a/programs/zstdcli.c
+++ b/programs/zstdcli.c
@@ -753,6 +753,7 @@ int main(int argCount, const char* argv[])
         BMK_setNotificationLevel(g_displayLevel);
         BMK_setBlockSize(blockSize);
         BMK_setNbThreads(nbThreads);
+        BMK_setRealTime(setRealTimePrio);
         BMK_setNbSeconds(bench_nbSeconds);
         BMK_setLdmFlag(ldmFlag);
         BMK_setLdmMinMatch(g_ldmMinMatch);
@@ -763,7 +764,7 @@ int main(int argCount, const char* argv[])
         if (g_ldmHashEveryLog != LDM_PARAM_DEFAULT) {
             BMK_setLdmHashEveryLog(g_ldmHashEveryLog);
         }
-        BMK_benchFiles(filenameTable, filenameIdx, dictFileName, cLevel, cLevelLast, &compressionParams, setRealTimePrio);
+        BMK_benchFiles(filenameTable, filenameIdx, dictFileName, cLevel, cLevelLast, &compressionParams);
 #endif
         (void)bench_nbSeconds; (void)blockSize; (void)setRealTimePrio;
         goto _end;

From d898fb7ba60611a3c293c8b8098960263e0bd7db Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 17 Nov 2017 00:22:55 -0800
Subject: [PATCH 056/145] bench: added cli command `-S` to benchmark multiple
 files separately

Currently, all files are joined by default,
they are compressed separately but benchmarked together,
providing a single final result.

Benchmarking files separately make it possible to accurately measure difference for each file.
This is expected to be useful while tuning optimal parser.
---
 programs/bench.c   | 47 ++++++++++++++++++++++++++++++++--------------
 programs/bench.h   |  1 +
 programs/util.h    |  2 +-
 programs/zstdcli.c |  8 ++++++++
 4 files changed, 43 insertions(+), 15 deletions(-)

diff --git a/programs/bench.c b/programs/bench.c
index c61273936..e28bed747 100644
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -135,6 +135,11 @@ void BMK_setRealTime(unsigned priority) {
     g_realTime = (priority>0);
 }
 
+static U32 g_separateFiles = 0;
+void BMK_setSeparateFiles(unsigned separate) {
+    g_separateFiles = (separate>0);
+}
+
 static U32 g_ldmFlag = 0;
 void BMK_setLdmFlag(unsigned ldmFlag) {
     g_ldmFlag = ldmFlag;
@@ -482,11 +487,11 @@ static size_t BMK_findMaxMem(U64 requiredMem)
     return (size_t)(requiredMem);
 }
 
-static void BMK_benchCLevel(void* srcBuffer, size_t benchedSize,
+static void BMK_benchCLevel(const void* srcBuffer, size_t benchedSize,
                             const char* displayName, int cLevel, int cLevelLast,
                             const size_t* fileSizes, unsigned nbFiles,
                             const void* dictBuffer, size_t dictBufferSize,
-                            ZSTD_compressionParameters *compressionParams)
+                            const ZSTD_compressionParameters* const compressionParams)
 {
     int l;
 
@@ -518,7 +523,7 @@ static void BMK_benchCLevel(void* srcBuffer, size_t benchedSize,
     At most, fills `buffer` entirely */
 static void BMK_loadFiles(void* buffer, size_t bufferSize,
                           size_t* fileSizes,
-                          const char** fileNamesTable, unsigned nbFiles)
+                          const char* const * const fileNamesTable, unsigned nbFiles)
 {
     size_t pos = 0, totalSize = 0;
     unsigned n;
@@ -550,16 +555,17 @@ static void BMK_loadFiles(void* buffer, size_t bufferSize,
     if (totalSize == 0) EXM_THROW(12, "no data to bench");
 }
 
-static void BMK_benchFileTable(const char** fileNamesTable, unsigned nbFiles, const char* dictFileName, int cLevel,
-                               int cLevelLast, ZSTD_compressionParameters *compressionParams)
+static void BMK_benchFileTable(const char* const * const fileNamesTable, unsigned const nbFiles,
+                               const char* const dictFileName,
+                               int const cLevel, int const cLevelLast,
+                               const ZSTD_compressionParameters* const compressionParams)
 {
     void* srcBuffer;
     size_t benchedSize;
     void* dictBuffer = NULL;
     size_t dictBufferSize = 0;
-    size_t* fileSizes = (size_t*)malloc(nbFiles * sizeof(size_t));
+    size_t* const fileSizes = (size_t*)malloc(nbFiles * sizeof(size_t));
     U64 const totalSizeToLoad = UTIL_getTotalFileSize(fileNamesTable, nbFiles);
-    char mfName[20] = {0};
 
     if (!fileSizes) EXM_THROW(12, "not enough memory for fileSizes");
 
@@ -588,13 +594,26 @@ static void BMK_benchFileTable(const char** fileNamesTable, unsigned nbFiles, co
     BMK_loadFiles(srcBuffer, benchedSize, fileSizes, fileNamesTable, nbFiles);
 
     /* Bench */
-    snprintf (mfName, sizeof(mfName), " %u files", nbFiles);
-    {   const char* const displayName = (nbFiles > 1) ? mfName : fileNamesTable[0];
-        BMK_benchCLevel(srcBuffer, benchedSize,
-                        displayName, cLevel, cLevelLast,
-                        fileSizes, nbFiles,
-                        dictBuffer, dictBufferSize, compressionParams);
-    }
+    if (g_separateFiles) {
+        const BYTE* srcPtr = (const BYTE*)srcBuffer;
+        U32 fileNb;
+        for (fileNb=0; fileNb<nbFiles; fileNb++) {
+            size_t const fileSize = fileSizes[fileNb];
+            BMK_benchCLevel(srcPtr, fileSize,
+                            fileNamesTable[fileNb], cLevel, cLevelLast,
+                            fileSizes+fileNb, 1,
+                            dictBuffer, dictBufferSize, compressionParams);
+            srcPtr += fileSize;
+        }
+    } else {
+        char mfName[20] = {0};
+        snprintf (mfName, sizeof(mfName), " %u files", nbFiles);
+        {   const char* const displayName = (nbFiles > 1) ? mfName : fileNamesTable[0];
+            BMK_benchCLevel(srcBuffer, benchedSize,
+                            displayName, cLevel, cLevelLast,
+                            fileSizes, nbFiles,
+                            dictBuffer, dictBufferSize, compressionParams);
+    }   }
 
     /* clean up */
     free(srcBuffer);
diff --git a/programs/bench.h b/programs/bench.h
index f4d415488..597f25036 100644
--- a/programs/bench.h
+++ b/programs/bench.h
@@ -25,6 +25,7 @@ void BMK_setBlockSize(size_t blockSize);
 void BMK_setNbThreads(unsigned nbThreads);
 void BMK_setRealTime(unsigned priority);
 void BMK_setNotificationLevel(unsigned level);
+void BMK_setSeparateFiles(unsigned separate);
 void BMK_setAdditionalParam(int additionalParam);
 void BMK_setDecodeOnlyMode(unsigned decodeFlag);
 void BMK_setLdmFlag(unsigned ldmFlag);
diff --git a/programs/util.h b/programs/util.h
index c5e4365d0..e44d7459d 100644
--- a/programs/util.h
+++ b/programs/util.h
@@ -336,7 +336,7 @@ UTIL_STATIC U64 UTIL_getFileSize(const char* infilename)
 }
 
 
-UTIL_STATIC U64 UTIL_getTotalFileSize(const char** fileNamesTable, unsigned nbFiles)
+UTIL_STATIC U64 UTIL_getTotalFileSize(const char* const * const fileNamesTable, unsigned nbFiles)
 {
     U64 total = 0;
     int error = 0;
diff --git a/programs/zstdcli.c b/programs/zstdcli.c
index d5cb6285c..91af49e24 100644
--- a/programs/zstdcli.c
+++ b/programs/zstdcli.c
@@ -377,6 +377,7 @@ int main(int argCount, const char* argv[])
         lastCommand = 0,
         nbThreads = 1,
         setRealTimePrio = 0,
+        separateFiles = 0,
         ldmFlag = 0;
     unsigned bench_nbSeconds = 3;   /* would be better if this value was synchronized from bench */
     size_t blockSize = 0;
@@ -633,6 +634,12 @@ int main(int argCount, const char* argv[])
                         blockSize = readU32FromChar(&argument);
                         break;
 
+                        /* benchmark files separately (hidden option) */
+                    case 'S':
+                        argument++;
+                        separateFiles = 1;
+                        break;
+
 #endif   /* ZSTD_NOBENCH */
 
                         /* nb of threads (hidden option) */
@@ -751,6 +758,7 @@ int main(int argCount, const char* argv[])
     if (operation==zom_bench) {
 #ifndef ZSTD_NOBENCH
         BMK_setNotificationLevel(g_displayLevel);
+        BMK_setSeparateFiles(separateFiles);
         BMK_setBlockSize(blockSize);
         BMK_setNbThreads(nbThreads);
         BMK_setRealTime(setRealTimePrio);

From 5b957ba8997e0ae5b32f8125ea02a8e2205aa3a9 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 17 Nov 2017 01:21:40 -0800
Subject: [PATCH 057/145] minor interface adjustments

---
 Makefile         | 5 -----
 programs/bench.c | 6 +++---
 programs/bench.h | 4 ++--
 3 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/Makefile b/Makefile
index 9f4b1fe4d..9c2657052 100644
--- a/Makefile
+++ b/Makefile
@@ -130,11 +130,6 @@ uninstall:
 travis-install:
 	$(MAKE) install PREFIX=~/install_test_dir
 
-.PHONY: gppbuild
-gppbuild: clean
-	g++ -v
-	CC=g++ $(MAKE) -C programs all CFLAGS="-O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror"
-
 .PHONY: gcc5build
 gcc5build: clean
 	gcc-5 -v
diff --git a/programs/bench.c b/programs/bench.c
index e28bed747..27952169f 100644
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -622,7 +622,7 @@ static void BMK_benchFileTable(const char* const * const fileNamesTable, unsigne
 }
 
 
-static void BMK_syntheticTest(int cLevel, int cLevelLast, double compressibility, ZSTD_compressionParameters* compressionParams)
+static void BMK_syntheticTest(int cLevel, int cLevelLast, double compressibility, const ZSTD_compressionParameters* compressionParams)
 {
     char name[20] = {0};
     size_t benchedSize = 10000000;
@@ -643,10 +643,10 @@ static void BMK_syntheticTest(int cLevel, int cLevelLast, double compressibility
 }
 
 
-int BMK_benchFiles(const char** const fileNamesTable, unsigned const nbFiles,
+int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles,
                    const char* dictFileName,
                    int cLevel, int cLevelLast,
-                   ZSTD_compressionParameters* compressionParams)
+                   const ZSTD_compressionParameters* compressionParams)
 {
     double const compressibility = (double)g_compressibilityDefault / 100;
 
diff --git a/programs/bench.h b/programs/bench.h
index 597f25036..d2ec94ee3 100644
--- a/programs/bench.h
+++ b/programs/bench.h
@@ -16,8 +16,8 @@
 #define ZSTD_STATIC_LINKING_ONLY   /* ZSTD_compressionParameters */
 #include "zstd.h"     /* ZSTD_compressionParameters */
 
-int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles,const char* dictFileName,
-                   int cLevel, int cLevelLast, ZSTD_compressionParameters* compressionParams);
+int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles, const char* dictFileName,
+                   int cLevel, int cLevelLast, const ZSTD_compressionParameters* compressionParams);
 
 /* Set Parameters */
 void BMK_setNbSeconds(unsigned nbLoops);

From 49a445e65d6eb71e4cca371ea37560852362db04 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 17 Nov 2017 02:14:16 -0800
Subject: [PATCH 058/145] fixed circle-ci script

---
 circle.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/circle.yml b/circle.yml
index 5bc0ce643..b488c1a7b 100644
--- a/circle.yml
+++ b/circle.yml
@@ -24,7 +24,7 @@ test:
       :
         parallel: true
     - ? |
-        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make gppbuild     && make clean; fi &&
+        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make cxxtest      && make clean; fi &&
         if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make gcc5build    && make clean; fi
       :
         parallel: true

From cdade555ee9a023187a1dfc894c3add64b0bbb0a Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 17 Nov 2017 11:40:08 -0800
Subject: [PATCH 059/145] fixed one UB pointer arithmetic

---
 lib/common/mem.h                 |  4 ----
 lib/common/zstd_internal.h       |  2 +-
 lib/decompress/zstd_decompress.c | 36 ++++++++++++++++----------------
 3 files changed, 19 insertions(+), 23 deletions(-)

diff --git a/lib/common/mem.h b/lib/common/mem.h
index 2ec328733..47d230017 100644
--- a/lib/common/mem.h
+++ b/lib/common/mem.h
@@ -56,8 +56,6 @@ MEM_STATIC void MEM_check(void) { MEM_STATIC_ASSERT((sizeof(size_t)==4) || (size
   typedef   int32_t S32;
   typedef  uint64_t U64;
   typedef   int64_t S64;
-  typedef  intptr_t iPtrDiff;
-  typedef uintptr_t uPtrDiff;
 #else
   typedef unsigned char      BYTE;
   typedef unsigned short      U16;
@@ -66,8 +64,6 @@ MEM_STATIC void MEM_check(void) { MEM_STATIC_ASSERT((sizeof(size_t)==4) || (size
   typedef   signed int        S32;
   typedef unsigned long long  U64;
   typedef   signed long long  S64;
-  typedef ptrdiff_t      iPtrDiff;
-  typedef size_t         uPtrDiff;
 #endif
 
 
diff --git a/lib/common/zstd_internal.h b/lib/common/zstd_internal.h
index ce2b85b4c..01d343da6 100644
--- a/lib/common/zstd_internal.h
+++ b/lib/common/zstd_internal.h
@@ -187,7 +187,7 @@ static void ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
 #define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; }
 
 /*! ZSTD_wildcopy() :
-*   custom version of memcpy(), can copy up to 7 bytes too many (8 bytes if length==0) */
+ *  custom version of memcpy(), can overwrite up to WILDCOPY_OVERLENGTH bytes (if length==0) */
 #define WILDCOPY_OVERLENGTH 8
 MEM_STATIC void ZSTD_wildcopy(void* dst, const void* src, ptrdiff_t length)
 {
diff --git a/lib/decompress/zstd_decompress.c b/lib/decompress/zstd_decompress.c
index caeafc255..4ded3656f 100644
--- a/lib/decompress/zstd_decompress.c
+++ b/lib/decompress/zstd_decompress.c
@@ -827,9 +827,9 @@ typedef struct {
     FSE_DState_t stateOffb;
     FSE_DState_t stateML;
     size_t prevOffset[ZSTD_REP_NUM];
-    const BYTE* base;
+    const BYTE* prefixStart;
+    const BYTE* dictEnd;
     size_t pos;
-    uPtrDiff gotoDict;
 } seqState_t;
 
 
@@ -1224,8 +1224,8 @@ seq_t ZSTD_decodeSequenceLong(seqState_t* seqState, ZSTD_longOffset_e const long
         BIT_reloadDStream(&seqState->DStream);
 
     {   size_t const pos = seqState->pos + seq.litLength;
-        seq.match = seqState->base + pos - seq.offset;    /* single memory segment */
-        if (seq.offset > pos) seq.match += seqState->gotoDict;   /* separate memory segment */
+        const BYTE* const matchBase = (seq.offset > pos) ? seqState->dictEnd : seqState->prefixStart;
+        seq.match = matchBase + pos - seq.offset;
         seqState->pos = pos + seq.matchLength;
     }
 
@@ -1243,7 +1243,7 @@ HINT_INLINE
 size_t ZSTD_execSequenceLong(BYTE* op,
                              BYTE* const oend, seq_t sequence,
                              const BYTE** litPtr, const BYTE* const litLimit,
-                             const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)
+                             const BYTE* const prefixStart, const BYTE* const dictStart, const BYTE* const dictEnd)
 {
     BYTE* const oLitEnd = op + sequence.litLength;
     size_t const sequenceLength = sequence.litLength + sequence.matchLength;
@@ -1253,21 +1253,21 @@ size_t ZSTD_execSequenceLong(BYTE* op,
     const BYTE* match = sequence.match;
 
     /* check */
-    if (oMatchEnd>oend) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */
+    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */
     if (iLitEnd > litLimit) return ERROR(corruption_detected);   /* over-read beyond lit buffer */
-    if (oLitEnd>oend_w) return ZSTD_execSequenceLast7(op, oend, sequence, litPtr, litLimit, base, vBase, dictEnd);
+    if (oLitEnd > oend_w) return ZSTD_execSequenceLast7(op, oend, sequence, litPtr, litLimit, prefixStart, dictStart, dictEnd);
 
     /* copy Literals */
-    ZSTD_copy8(op, *litPtr);
+    ZSTD_copy8(op, *litPtr);  /* note : op <= oLitEnd <= oend_w == oend - 8 */
     if (sequence.litLength > 8)
         ZSTD_wildcopy(op+8, (*litPtr)+8, sequence.litLength - 8);   /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, no risk of overwrite beyond oend */
     op = oLitEnd;
     *litPtr = iLitEnd;   /* update for next sequence */
 
     /* copy Match */
-    if (sequence.offset > (size_t)(oLitEnd - base)) {
+    if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
         /* offset beyond prefix */
-        if (sequence.offset > (size_t)(oLitEnd - vBase)) return ERROR(corruption_detected);
+        if (sequence.offset > (size_t)(oLitEnd - dictStart)) return ERROR(corruption_detected);
         if (match + sequence.matchLength <= dictEnd) {
             memmove(oLitEnd, match, sequence.matchLength);
             return sequenceLength;
@@ -1277,7 +1277,7 @@ size_t ZSTD_execSequenceLong(BYTE* op,
             memmove(oLitEnd, match, length1);
             op = oLitEnd + length1;
             sequence.matchLength -= length1;
-            match = base;
+            match = prefixStart;
             if (op > oend_w || sequence.matchLength < MINMATCH) {
               U32 i;
               for (i = 0; i < sequence.matchLength; ++i) op[i] = match[i];
@@ -1331,8 +1331,8 @@ static size_t ZSTD_decompressSequencesLong(
     BYTE* op = ostart;
     const BYTE* litPtr = dctx->litPtr;
     const BYTE* const litEnd = litPtr + dctx->litSize;
-    const BYTE* const base = (const BYTE*) (dctx->base);
-    const BYTE* const vBase = (const BYTE*) (dctx->vBase);
+    const BYTE* const prefixStart = (const BYTE*) (dctx->base);
+    const BYTE* const dictStart = (const BYTE*) (dctx->vBase);
     const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
     int nbSeq;
 
@@ -1353,9 +1353,9 @@ static size_t ZSTD_decompressSequencesLong(
         int seqNb;
         dctx->fseEntropy = 1;
         { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
-        seqState.base = base;
-        seqState.pos = (size_t)(op-base);
-        seqState.gotoDict = (uPtrDiff)dictEnd - (uPtrDiff)base; /* cast to avoid undefined behaviour */
+        seqState.prefixStart = prefixStart;
+        seqState.pos = (size_t)(op-prefixStart);
+        seqState.dictEnd = dictEnd;
         CHECK_E(BIT_initDStream(&seqState.DStream, ip, iend-ip), corruption_detected);
         FSE_initDState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
         FSE_initDState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
@@ -1370,7 +1370,7 @@ static size_t ZSTD_decompressSequencesLong(
         /* decode and decompress */
         for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && seqNb<nbSeq ; seqNb++) {
             seq_t const sequence = ZSTD_decodeSequenceLong(&seqState, isLongOffset);
-            size_t const oneSeqSize = ZSTD_execSequenceLong(op, oend, sequences[(seqNb-ADVANCED_SEQS) & STOSEQ_MASK], &litPtr, litEnd, base, vBase, dictEnd);
+            size_t const oneSeqSize = ZSTD_execSequenceLong(op, oend, sequences[(seqNb-ADVANCED_SEQS) & STOSEQ_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd);
             if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
             PREFETCH(sequence.match);
             sequences[seqNb&STOSEQ_MASK] = sequence;
@@ -1381,7 +1381,7 @@ static size_t ZSTD_decompressSequencesLong(
         /* finish queue */
         seqNb -= seqAdvance;
         for ( ; seqNb<nbSeq ; seqNb++) {
-            size_t const oneSeqSize = ZSTD_execSequenceLong(op, oend, sequences[seqNb&STOSEQ_MASK], &litPtr, litEnd, base, vBase, dictEnd);
+            size_t const oneSeqSize = ZSTD_execSequenceLong(op, oend, sequences[seqNb&STOSEQ_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd);
             if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
             op += oneSeqSize;
         }

From 23767e950aea65d5aec0a81f2980aeeae8bfaf94 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 17 Nov 2017 12:55:37 -0800
Subject: [PATCH 060/145] fix one UB pointer arithmetic in encoder

Instead of calculating distance between 2 memory objects, which is UB,
we extract the offset from object 1, and transfer it into object 2.
---
 lib/compress/zstd_compress.c     | 18 +++++++++---------
 lib/decompress/zstd_decompress.c |  5 +++--
 tests/Makefile                   | 11 ++++-------
 3 files changed, 16 insertions(+), 18 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index f0cebe7a3..858eaca30 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -1819,17 +1819,21 @@ static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,
         cctx->stage = ZSTDcs_ongoing;
     }
 
+    if (!srcSize) return fhSize;  /* do not generate an empty block if no input */
+
     /* Check if blocks follow each other */
     if (src != cctx->nextSrc) {
         /* not contiguous */
-        ptrdiff_t const delta = cctx->nextSrc - ip;
+        size_t const distanceFromBase = (size_t)(cctx->nextSrc - cctx->base);
         cctx->lowLimit = cctx->dictLimit;
-        cctx->dictLimit = (U32)(cctx->nextSrc - cctx->base);
+        assert(distanceFromBase == (size_t)(U32)distanceFromBase);  /* should never overflow */
+        cctx->dictLimit = (U32)distanceFromBase;
         cctx->dictBase = cctx->base;
-        cctx->base -= delta;
+        cctx->base = ip - distanceFromBase;
         cctx->nextToUpdate = cctx->dictLimit;
         if (cctx->dictLimit - cctx->lowLimit < HASH_READ_SIZE) cctx->lowLimit = cctx->dictLimit;   /* too small extDict */
     }
+    cctx->nextSrc = ip + srcSize;
 
     /* if input and dictionary overlap : reduce dictionary (area presumed modified by input) */
     if ((ip+srcSize > cctx->dictBase + cctx->lowLimit) & (ip < cctx->dictBase + cctx->dictLimit)) {
@@ -1838,17 +1842,13 @@ static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,
         cctx->lowLimit = lowLimitMax;
     }
 
-    cctx->nextSrc = ip + srcSize;
-
-    if (srcSize) {
-        size_t const cSize = frame ?
+    {   size_t const cSize = frame ?
                              ZSTD_compress_frameChunk (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) :
                              ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize);
         if (ZSTD_isError(cSize)) return cSize;
         cctx->consumedSrcSize += srcSize;
         return cSize + fhSize;
-    } else
-        return fhSize;
+    }
 }
 
 size_t ZSTD_compressContinue (ZSTD_CCtx* cctx,
diff --git a/lib/decompress/zstd_decompress.c b/lib/decompress/zstd_decompress.c
index 4ded3656f..f0cf967cb 100644
--- a/lib/decompress/zstd_decompress.c
+++ b/lib/decompress/zstd_decompress.c
@@ -1225,7 +1225,8 @@ seq_t ZSTD_decodeSequenceLong(seqState_t* seqState, ZSTD_longOffset_e const long
 
     {   size_t const pos = seqState->pos + seq.litLength;
         const BYTE* const matchBase = (seq.offset > pos) ? seqState->dictEnd : seqState->prefixStart;
-        seq.match = matchBase + pos - seq.offset;
+        seq.match = matchBase + pos - seq.offset;  /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted.
+                                                    * No consequence though : no memory access will occur, overly large offset will be detected in ZSTD_execSequenceLong() */
         seqState->pos = pos + seq.matchLength;
     }
 
@@ -1372,7 +1373,7 @@ static size_t ZSTD_decompressSequencesLong(
             seq_t const sequence = ZSTD_decodeSequenceLong(&seqState, isLongOffset);
             size_t const oneSeqSize = ZSTD_execSequenceLong(op, oend, sequences[(seqNb-ADVANCED_SEQS) & STOSEQ_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd);
             if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
-            PREFETCH(sequence.match);
+            PREFETCH(sequence.match);  /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */
             sequences[seqNb&STOSEQ_MASK] = sequence;
             op += oneSeqSize;
         }
diff --git a/tests/Makefile b/tests/Makefile
index eb8bb3dd6..11d55a75d 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -131,14 +131,11 @@ zbufftest-dll : $(ZSTDDIR)/common/xxhash.c $(PRGDIR)/datagen.c zbufftest.c
 	$(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@$(EXT)
 
 ZSTREAMFILES := $(ZSTD_FILES) $(ZDICT_FILES) $(PRGDIR)/datagen.c seqgen.c zstreamtest.c
-zstreamtest : CPPFLAGS += $(MULTITHREAD_CPP)
-zstreamtest : LDFLAGS += $(MULTITHREAD_LD)
-zstreamtest : $(ZSTREAMFILES)
-	$(CC) $(FLAGS) $^ -o $@$(EXT)
-
 zstreamtest32 : CFLAGS += -m32
-zstreamtest32 : $(ZSTREAMFILES)
-	$(CC) $(FLAGS) $(MULTITHREAD) $^ -o $@$(EXT)
+zstreamtest zstreamtest32 : CPPFLAGS += $(MULTITHREAD_CPP)
+zstreamtest zstreamtest32 : LDFLAGS += $(MULTITHREAD_LD)
+zstreamtest zstreamtest32 : $(ZSTREAMFILES)
+	$(CC) $(FLAGS) $^ -o $@$(EXT)
 
 zstreamtest_asan : CFLAGS += -fsanitize=address
 zstreamtest_asan : $(ZSTREAMFILES)

From a4a20a4b2f7f1ea9207cb5881d7271ed21913c8f Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 17 Nov 2017 15:51:52 -0800
Subject: [PATCH 061/145] fix un-initialized memory warning

harmless, but cleaner
---
 lib/compress/zstd_opt.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index aebe55f88..04f03ebcd 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -588,9 +588,8 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                     while (mlen <= lastML) {
                         U32 const pos = cur + mlen;
                         U32 const price = basePrice + ZSTD_getPrice(optStatePtr, litlen, baseLiterals, offset, mlen, ultra);
-                        assert(pos < ZSTD_OPT_NUM);
 
-                        if ((pos > last_pos) | (price < opt[pos].price)) {
+                        if ((pos > last_pos) || (price < opt[pos].price)) {
                             DEBUGLOG(7, "rPos:%u => new better price (%u<%u)",
                                         pos, price, opt[pos].price);
                             SET_PRICE(pos, mlen, offset, litlen, price, repHistory);  /* note : macro modifies last_pos */

From a6052af0e89d8b0d270bd1c7023c183c2d9da2fe Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Fri, 17 Nov 2017 16:38:56 -0800
Subject: [PATCH 062/145] [zstd] Fix rare bug with signal handler

---
 programs/fileio.c | 52 +++++++++++++++++++++++++++++++----------------
 1 file changed, 35 insertions(+), 17 deletions(-)

diff --git a/programs/fileio.c b/programs/fileio.c
index a8e33994c..8bee6086c 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -141,6 +141,21 @@ static void INThandler(int sig)
     DISPLAY("\n");
     exit(2);
 }
+static void addHandler(char const* dstFileName)
+{
+    if (UTIL_isRegularFile(dstFileName)) {
+        g_artefact = dstFileName;
+        signal(SIGINT, INThandler);
+    } else {
+        g_artefact = NULL;
+    }
+}
+/* Idempotent */
+static void clearHandler(void)
+{
+    if (g_artefact) signal(SIGINT, SIG_DFL);
+    g_artefact = NULL;
+}
 
 
 /* ************************************************************
@@ -841,6 +856,10 @@ static int FIO_compressFilename_srcFile(cRess_t ress,
 
     fclose(ress.srcFile);
     if (g_removeSrcFile /* --rm */ && !result && strcmp(srcFileName, stdinmark)) {
+        /* We must clear the handler, since after this point calling it would
+         * delete both the source and destination files.
+         */
+        clearHandler();
         if (remove(srcFileName))
             EXM_THROW(1, "zstd: %s: %s", srcFileName, strerror(errno));
     }
@@ -863,18 +882,16 @@ static int FIO_compressFilename_dstFile(cRess_t ress,
 
     ress.dstFile = FIO_openDstFile(dstFileName);
     if (ress.dstFile==NULL) return 1;  /* could not open dstFileName */
-
-    if (UTIL_isRegularFile(dstFileName)) {
-        g_artefact = dstFileName;
-        signal(SIGINT, INThandler);
-    } else {
-        g_artefact = NULL;
-    }
-
+    /* Must ony be added after FIO_openDstFile() succeeds.
+     * Otherwise we may delete the destination file if at already exists, and
+     * the user presses Ctrl-C when asked if they wish to overwrite.
+     */
+    addHandler(dstFileName);
 
     if (strcmp (srcFileName, stdinmark) && UTIL_getFileStat(srcFileName, &statbuf))
         stat_result = 1;
     result = FIO_compressFilename_srcFile(ress, dstFileName, srcFileName, compressionLevel);
+    clearHandler();
 
     if (fclose(ress.dstFile)) { /* error closing dstFile */
         DISPLAYLEVEL(1, "zstd: %s: %s \n", dstFileName, strerror(errno));
@@ -887,8 +904,6 @@ static int FIO_compressFilename_dstFile(cRess_t ress,
     else if (strcmp (dstFileName, stdoutmark) && stat_result)
         UTIL_setFileStat(dstFileName, &statbuf);
 
-    signal(SIGINT, SIG_DFL);
-
     return result;
 }
 
@@ -1552,6 +1567,10 @@ static int FIO_decompressSrcFile(dRess_t ress, const char* dstFileName, const ch
     if ( g_removeSrcFile /* --rm */
       && (result==0)     /* decompression successful */
       && strcmp(srcFileName, stdinmark) ) /* not stdin */ {
+        /* We must clear the handler, since after this point calling it would
+         * delete both the source and destination files.
+         */
+        clearHandler();
         if (remove(srcFileName)) {
             /* failed to remove src file */
             DISPLAYLEVEL(1, "zstd: %s: %s \n", srcFileName, strerror(errno));
@@ -1575,18 +1594,17 @@ static int FIO_decompressDstFile(dRess_t ress,
 
     ress.dstFile = FIO_openDstFile(dstFileName);
     if (ress.dstFile==0) return 1;
-
-    if (UTIL_isRegularFile(dstFileName)) {
-        g_artefact = dstFileName;
-        signal(SIGINT, INThandler);
-    } else {
-        g_artefact = NULL;
-    }
+    /* Must ony be added after FIO_openDstFile() succeeds.
+     * Otherwise we may delete the destination file if at already exists, and
+     * the user presses Ctrl-C when asked if they wish to overwrite.
+     */
+    addHandler(dstFileName);
 
     if ( strcmp(srcFileName, stdinmark)
       && UTIL_getFileStat(srcFileName, &statbuf) )
         stat_result = 1;
     result = FIO_decompressSrcFile(ress, dstFileName, srcFileName);
+    clearHandler();
 
     if (fclose(ress.dstFile)) {
         DISPLAYLEVEL(1, "zstd: %s: %s \n", dstFileName, strerror(errno));

From d11661c3ecd0cd121ca10543bf0d7200b9b3821b Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Sat, 18 Nov 2017 11:16:39 -0800
Subject: [PATCH 063/145] fix ZSTD_COMPRESSBOUND() macro

It was using macro `KB`, which is not defined in `zstd.h`.
---
 lib/zstd.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/zstd.h b/lib/zstd.h
index f07c9eed2..919d1e2e0 100644
--- a/lib/zstd.h
+++ b/lib/zstd.h
@@ -131,7 +131,7 @@ ZSTDLIB_API unsigned long long ZSTD_getDecompressedSize(const void* src, size_t
 
 
 /*======  Helper functions  ======*/
-#define ZSTD_COMPRESSBOUND(srcSize)   ((srcSize) + ((srcSize)>>8) + (((srcSize) < 128 KB) ? ((128 KB - (srcSize)) >> 11) /* margin, from 64 to 0 */ : 0))  /* this formula ensures that bound(A) + bound(B) <= bound(A+B) as long as A and B >= 128 KB */
+#define ZSTD_COMPRESSBOUND(srcSize)   ((srcSize) + ((srcSize)>>8) + (((srcSize) < (128<<10)) ? (((128<<10) - (srcSize)) >> 11) /* margin, from 64 to 0 */ : 0))  /* this formula ensures that bound(A) + bound(B) <= bound(A+B) as long as A and B >= 128 KB */
 ZSTDLIB_API size_t      ZSTD_compressBound(size_t srcSize); /*!< maximum compressed size in worst case scenario */
 ZSTDLIB_API unsigned    ZSTD_isError(size_t code);          /*!< tells if a `size_t` function result is an error code */
 ZSTDLIB_API const char* ZSTD_getErrorName(size_t code);     /*!< provides readable string from an error code */

From fccb46fbe03d3a876ce32cc3ddc3d2dcdacad7ed Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Sat, 18 Nov 2017 11:28:00 -0800
Subject: [PATCH 064/145] minor spelling fixes

---
 doc/zstd_compression_format.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/zstd_compression_format.md b/doc/zstd_compression_format.md
index aa86d1420..86a7ace91 100644
--- a/doc/zstd_compression_format.md
+++ b/doc/zstd_compression_format.md
@@ -91,10 +91,10 @@ Overview
 
 Frames
 ------
-Zstandard compressed data is made of up one or more __frames__.
+Zstandard compressed data is made of one or more __frames__.
 Each frame is independent and can be decompressed indepedently of other frames.
 The decompressed content of multiple concatenated frames is the concatenation of
-each frames decompressed content.
+each frame decompressed content.
 
 There are two frame formats defined by Zstandard:
   Zstandard frames and Skippable frames.
@@ -182,7 +182,7 @@ data must be regenerated within a single continuous memory segment.
 In this case, `Window_Descriptor` byte is skipped,
 but `Frame_Content_Size` is necessarily present.
 As a consequence, the decoder must allocate a memory segment
-of size equal or bigger than `Frame_Content_Size`.
+of size equal or larger than `Frame_Content_Size`.
 
 In order to preserve the decoder from unreasonable memory requirements,
 a decoder is allowed to reject a compressed frame

From daebc7fe26f70896c3a51d96f287012128b4ce36 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Sat, 18 Nov 2017 15:54:32 -0800
Subject: [PATCH 065/145] bench: slightly adjusted display format

adapt accuracy depending on value.
makes it possible to have higher accuracy for small value,
notably small compression speed.
This capability is expected to be useful while modifying optimal parser.
---
 programs/bench.c | 27 +++++++++++++++++++--------
 1 file changed, 19 insertions(+), 8 deletions(-)

diff --git a/programs/bench.c b/programs/bench.c
index 27952169f..1df8aeb0d 100644
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -356,9 +356,14 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
                 { U32 blockNb; for (blockNb=0; blockNb<nbBlocks; blockNb++) cSize += blockTable[blockNb].cSize; }
                 ratio = (double)srcSize / (double)cSize;
                 markNb = (markNb+1) % NB_MARKS;
-                DISPLAYLEVEL(2, "%2s-%-17.17s :%10u ->%10u (%5.3f),%6.1f MB/s\r",
-                        marks[markNb], displayName, (U32)srcSize, (U32)cSize,
-                        ratio, (double)srcSize / fastestC );
+                {   int const ratioAccuracy = (ratio < 10.) ? 3 : 2;
+                    double const compressionSpeed = (double)srcSize / fastestC;
+                    int const cSpeedAccuracy = (compressionSpeed < 10.) ? 2 : 1;
+                    DISPLAYLEVEL(2, "%2s-%-17.17s :%10u ->%10u (%5.*f),%6.*f MB/s\r",
+                            marks[markNb], displayName, (U32)srcSize, (U32)cSize,
+                            ratioAccuracy, ratio,
+                            cSpeedAccuracy, compressionSpeed );
+                }
             } else {   /* g_decodeOnly */
                 memcpy(compressedBuffer, srcBuffer, loadedCompressedSize);
             }
@@ -403,10 +408,16 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
             }   }
 
             markNb = (markNb+1) % NB_MARKS;
-            DISPLAYLEVEL(2, "%2s-%-17.17s :%10u ->%10u (%5.3f),%6.1f MB/s ,%6.1f MB/s\r",
-                    marks[markNb], displayName, (U32)srcSize, (U32)cSize, ratio,
-                    (double)srcSize / fastestC,
-                    (double)srcSize / fastestD );
+            {   int const ratioAccuracy = (ratio < 10.) ? 3 : 2;
+                double const compressionSpeed = (double)srcSize / fastestC;
+                int const cSpeedAccuracy = (compressionSpeed < 10.) ? 2 : 1;
+                double const decompressionSpeed = (double)srcSize / fastestD;
+                DISPLAYLEVEL(2, "%2s-%-17.17s :%10u ->%10u (%5.*f),%6.*f MB/s ,%6.1f MB/s \r",
+                        marks[markNb], displayName, (U32)srcSize, (U32)cSize,
+                        ratioAccuracy, ratio,
+                        cSpeedAccuracy, compressionSpeed,
+                        decompressionSpeed);
+            }
 
             /* CRC Checking */
             {   U64 const crcCheck = XXH64(resultBuffer, srcSize, 0);
@@ -448,7 +459,7 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
 #endif
         }   /* for (testNb = 1; testNb <= (g_nbSeconds + !g_nbSeconds); testNb++) */
 
-        if (g_displayLevel == 1) {
+        if (g_displayLevel == 1) {   /* hidden display mode -q, used by python speed benchmark */
             double cSpeed = (double)srcSize / fastestC;
             double dSpeed = (double)srcSize / fastestD;
             if (g_additionalParam)

From e717a5b0ddb478108f826076f3efef3a17735735 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Sat, 18 Nov 2017 16:24:02 -0800
Subject: [PATCH 066/145] zstd_opt: minor speed optimization

Calculate reference log2sums only once per serie of sequence
(as opposed to once per sequence)

Also: improved code comments
---
 lib/compress/zstd_compress_internal.h | 19 +++++++++---------
 lib/compress/zstd_opt.c               | 28 +++++++++++++--------------
 2 files changed, 24 insertions(+), 23 deletions(-)

diff --git a/lib/compress/zstd_compress_internal.h b/lib/compress/zstd_compress_internal.h
index efcbc4501..862558b50 100644
--- a/lib/compress/zstd_compress_internal.h
+++ b/lib/compress/zstd_compress_internal.h
@@ -72,26 +72,27 @@ typedef struct {
 } ZSTD_optimal_t;
 
 typedef struct {
-    U32* litFreq;
-    U32* litLengthFreq;
-    U32* matchLengthFreq;
-    U32* offCodeFreq;
-    ZSTD_match_t* matchTable;
-    ZSTD_optimal_t* priceTable;
+    /* All tables are allocated inside cctx->workspace by ZSTD_resetCCtx_internal() */
+    U32* litFreq;               /* table of literals statistics, of size 256 */
+    U32* litLengthFreq;         /* table of litLength statistics, of size (MaxLL+1) */
+    U32* matchLengthFreq;       /* table of matchLength statistics, of size (MaxML+1) */
+    U32* offCodeFreq;           /* table of offCode statistics, of size (MaxOff+1) */
+    ZSTD_match_t* matchTable;   /* list of found matches, of size ZSTD_OPT_NUM+1 */
+    ZSTD_optimal_t* priceTable; /* All positions tracked by optimal parser, of size ZSTD_OPT_NUM+1 */
 
     U32  litSum;                 /* nb of literals */
     U32  litLengthSum;           /* nb of litLength codes */
     U32  matchLengthSum;         /* nb of matchLength codes */
-    U32  matchSum;               /* one argument to calculate `factor` */
+    U32  matchSum;               /* a strange argument used in calculating `factor` */
     U32  offCodeSum;             /* nb of offset codes */
     /* begin updated by ZSTD_setLog2Prices */
     U32  log2litSum;             /* pow2 to compare log2(litfreq) to */
     U32  log2litLengthSum;       /* pow2 to compare log2(llfreq) to */
     U32  log2matchLengthSum;     /* pow2 to compare log2(mlfreq) to */
     U32  log2offCodeSum;         /* pow2 to compare log2(offreq) to */
-    U32  factor;                 /* added to calculate ZSTD_getPrice() (but why?) */
+    U32  factor;                 /* fixed cost added when calculating ZSTD_getPrice() (but why ? seems to favor less sequences) */
     /* end : updated by ZSTD_setLog2Prices */
-    U32  staticPrices;           /* prices follow a static cost structure, statistics are irrelevant */
+    U32  staticPrices;           /* prices follow a pre-defined cost structure, statistics are irrelevant */
     U32  cachedPrice;
     U32  cachedLitLength;
     const BYTE* cachedLiterals;
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index 04f03ebcd..a626a3d13 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -13,7 +13,7 @@
 #include "zstd_lazy.h"   /* ZSTD_updateTree, ZSTD_updateTree_extDict */
 
 
-#define ZSTD_LITFREQ_ADD    2   /* sort of scaling factor for litSum and litFreq (why the need ?), but also used for matchSum ? */
+#define ZSTD_LITFREQ_ADD    2   /* scaling factor for litFreq, so that frequencies adapt faster to new stats. Also used for matchSum (?) */
 #define ZSTD_FREQ_DIV       4   /* log factor when using previous stats to init next stats */
 #define ZSTD_MAX_PRICE     (1<<30)
 
@@ -161,25 +161,26 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr, U32 litLength, const
 }
 
 
-static void ZSTD_updatePrice(optState_t* optPtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength)
+static void ZSTD_updateStats(optState_t* optPtr, U32 litLength, const BYTE* literals, U32 offsetCode, U32 matchLength)
 {
-    U32 u;
-
     /* literals */
-    optPtr->litSum += litLength*ZSTD_LITFREQ_ADD;
-    for (u=0; u < litLength; u++)
-        optPtr->litFreq[literals[u]] += ZSTD_LITFREQ_ADD;
+    {   U32 u;
+        optPtr->litSum += litLength*ZSTD_LITFREQ_ADD;
+        for (u=0; u < litLength; u++)
+            optPtr->litFreq[literals[u]] += ZSTD_LITFREQ_ADD;
+    }
 
     /* literal Length */
-    {   const U32 llCode = ZSTD_LLcode(litLength);
+    {   U32 const llCode = ZSTD_LLcode(litLength);
         optPtr->litLengthFreq[llCode]++;
         optPtr->litLengthSum++;
     }
 
-    /* match offset */
-    {   BYTE const offCode = (BYTE)ZSTD_highbit32(offset+1);
-        optPtr->offCodeSum++;
+    /* match offset code (0-2=>repCode; 3+=>offset+2) */
+    {   U32 const offCode = ZSTD_highbit32(offsetCode+1);
+        assert(offCode <= MaxOff);
         optPtr->offCodeFreq[offCode]++;
+        optPtr->offCodeSum++;
     }
 
     /* match Length */
@@ -188,8 +189,6 @@ static void ZSTD_updatePrice(optState_t* optPtr, U32 litLength, const BYTE* lite
         optPtr->matchLengthFreq[mlCode]++;
         optPtr->matchLengthSum++;
     }
-
-    ZSTD_setLog2Prices(optPtr);
 }
 
 
@@ -646,10 +645,11 @@ _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
                     }
                 }
 
-                ZSTD_updatePrice(optStatePtr, llen, anchor, offset, mlen);
+                ZSTD_updateStats(optStatePtr, llen, anchor, offset, mlen);
                 ZSTD_storeSeq(seqStorePtr, llen, anchor, offset, mlen-MINMATCH);
                 anchor = ip;
         }   }
+        ZSTD_setLog2Prices(optStatePtr);
     }   /* for (cur=0; cur < last_pos; ) */
 
     /* Save reps for next block */

From e6da37c4305be931ada88a8242b0d2f71ad73b16 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Sun, 19 Nov 2017 10:21:21 -0800
Subject: [PATCH 067/145] created (hidden) new strategy btopt0

about ~+10% faster but losing ~0.01 compression ratio
(note : amplitude vary a lot depending on files, but direction remains the same)
---
 lib/compress/zstd_opt.c | 43 ++++++++++++++++++++++++-----------------
 1 file changed, 25 insertions(+), 18 deletions(-)

diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index a626a3d13..ed8527989 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -96,7 +96,8 @@ static void ZSTD_rescaleFreqs(optState_t* optPtr, const BYTE* src, size_t srcSiz
 }
 
 
-static U32 ZSTD_getLiteralPrice(optState_t* optPtr, U32 const litLength, const BYTE* literals)
+static U32 ZSTD_getLiteralPrice(optState_t* const optPtr,
+                                U32 const litLength, const BYTE* const literals)
 {
     U32 price;
 
@@ -138,17 +139,22 @@ static U32 ZSTD_getLiteralPrice(optState_t* optPtr, U32 const litLength, const B
 }
 
 
-FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength, const int ultra)
+/* ZSTD_getPrice() :
+ * optLevel: when <2, favors small offset for decompression speed (improved cache efficiency) */
+FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr,
+                                    U32 const litLength, const BYTE* const literals, U32 const offset, U32 const matchLength,
+                                    int const optLevel)
 {
-    BYTE const offCode = (BYTE)ZSTD_highbit32(offset+1);
-    U32 const mlBase = matchLength - MINMATCH;
     U32 price;
+    U32 const offCode = ZSTD_highbit32(offset+1);
+    U32 const mlBase = matchLength - MINMATCH;
+    assert(matchLength >= MINMATCH);
 
     if (optPtr->staticPrices)  /* fixed scheme, do not use statistics */
         return ZSTD_getLiteralPrice(optPtr, litLength, literals) + ZSTD_highbit32((U32)mlBase+1) + 16 + offCode;
 
     price = offCode + optPtr->log2offCodeSum - ZSTD_highbit32(optPtr->offCodeFreq[offCode]+1);
-    if (!ultra /*static*/ && offCode >= 20) price += (offCode-19)*2; /* handicap for long distance offsets, favor decompression speed */
+    if ((optLevel<2) /*static*/ && offCode >= 20) price += (offCode-19)*2; /* handicap for long distance offsets, favor decompression speed */
 
     /* match Length */
     {   U32 const mlCode = ZSTD_MLcode(mlBase);
@@ -165,9 +171,9 @@ static void ZSTD_updateStats(optState_t* optPtr, U32 litLength, const BYTE* lite
 {
     /* literals */
     {   U32 u;
-        optPtr->litSum += litLength*ZSTD_LITFREQ_ADD;
         for (u=0; u < litLength; u++)
             optPtr->litFreq[literals[u]] += ZSTD_LITFREQ_ADD;
+        optPtr->litSum += litLength*ZSTD_LITFREQ_ADD;
     }
 
     /* literal Length */
@@ -451,7 +457,7 @@ repcodes_t ZSTD_updateRep(U32 const rep[3], U32 const offset, U32 const ll0)
 FORCE_INLINE_TEMPLATE
 size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                                       const void* src, size_t srcSize,
-                                      const int ultra, const int extDict)
+                                      const int optLevel, const int extDict)
 {
     seqStore_t* const seqStorePtr = &(ctx->seqStore);
     optState_t* const optStatePtr = &(ctx->optState);
@@ -518,7 +524,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                     U32 const end = matches[matchNb].len;
                     repcodes_t const repHistory = ZSTD_updateRep(rep, offset, ll0);
                     while (pos <= end) {
-                        U32 const matchPrice = ZSTD_getPrice(optStatePtr, litlen, anchor, offset, pos, ultra);
+                        U32 const matchPrice = ZSTD_getPrice(optStatePtr, litlen, anchor, offset, pos, optLevel);
                         if (pos > last_pos || matchPrice < opt[pos].price) {
                             DEBUGLOG(7, "rPos:%u => set initial price : %u",
                                         pos, matchPrice);
@@ -576,25 +582,26 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
 
                 /* set prices using matches found at position == cur */
                 for (matchNb = 0; matchNb < nbMatches; matchNb++) {
-                    U32 mlen = (matchNb>0) ? matches[matchNb-1].len+1 : minMatch;
-                    U32 const lastML = matches[matchNb].len;
                     U32 const offset = matches[matchNb].off;
                     repcodes_t const repHistory = ZSTD_updateRep(opt[cur].rep, offset, ll0);
+                    U32 const lastML = matches[matchNb].len;
+                    U32 const startML = (matchNb>0) ? matches[matchNb-1].len+1 : minMatch;
+                    U32 mlen;
 
                     DEBUGLOG(7, "testing match %u => offCode=%u, mlen=%u, llen=%u",
                                 matchNb, matches[matchNb].off, lastML, litlen);
 
-                    while (mlen <= lastML) {
+                    for (mlen = lastML; mlen >= startML; mlen--) {
                         U32 const pos = cur + mlen;
-                        U32 const price = basePrice + ZSTD_getPrice(optStatePtr, litlen, baseLiterals, offset, mlen, ultra);
+                        U32 const price = basePrice + ZSTD_getPrice(optStatePtr, litlen, baseLiterals, offset, mlen, optLevel);
 
                         if ((pos > last_pos) || (price < opt[pos].price)) {
                             DEBUGLOG(7, "rPos:%u => new better price (%u<%u)",
                                         pos, price, opt[pos].price);
                             SET_PRICE(pos, mlen, offset, litlen, price, repHistory);  /* note : macro modifies last_pos */
+                        } else {
+                            if (optLevel==0) break;  /* gets ~+10% speed for about 0.01 ratio loss */
                         }
-
-                        mlen++;
         }   }   }   }
 
         best_mlen = opt[last_pos].mlen;
@@ -663,20 +670,20 @@ _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
 size_t ZSTD_compressBlock_btopt(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
 {
     DEBUGLOG(5, "ZSTD_compressBlock_btopt");
-    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 0 /*ultra*/, 0 /*extDict*/);
+    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 0 /*optLevel*/, 0 /*extDict*/);
 }
 
 size_t ZSTD_compressBlock_btultra(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
 {
-    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 1 /*ultra*/, 0 /*extDict*/);
+    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 2 /*optLevel*/, 0 /*extDict*/);
 }
 
 size_t ZSTD_compressBlock_btopt_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
 {
-    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 0 /*ultra*/, 1 /*extDict*/);
+    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 1 /*optLevel*/, 1 /*extDict*/);
 }
 
 size_t ZSTD_compressBlock_btultra_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
 {
-    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 1 /*ultra*/, 1 /*extDict*/);
+    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 2 /*optLevel*/, 1 /*extDict*/);
 }

From d100670045fb39adcce509d4bbb3ceb4a0091975 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Sun, 19 Nov 2017 10:38:02 -0800
Subject: [PATCH 068/145] btopt0 : a bit faster and weaker

---
 lib/compress/zstd_opt.c | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index ed8527989..c62b8897c 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -553,11 +553,15 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                     SET_PRICE(cur, 1/*mlen*/, 0/*offset*/, litlen, price, opt[cur-1].rep);
             }   }
 
-            if (cur == last_pos) break;
-
             /* last match must start at a minimum distance of 8 from oend */
             if (inr > ilimit) continue;
 
+            if (cur == last_pos) break;
+
+             if ( (optLevel==0) /*static*/
+               && (opt[cur+1].price <= opt[cur].price) )
+                continue;  /* skip unpromising positions; about ~+6% speed, -0.01 ratio */
+
             {   U32 const ll0 = (opt[cur].mlen != 1);
                 U32 const litlen = (opt[cur].mlen == 1) ? opt[cur].litlen : 0;
                 U32 const basePrice = (cur > litlen) ? opt[cur-litlen].price : 0;
@@ -600,7 +604,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                                         pos, price, opt[pos].price);
                             SET_PRICE(pos, mlen, offset, litlen, price, repHistory);  /* note : macro modifies last_pos */
                         } else {
-                            if (optLevel==0) break;  /* gets ~+10% speed for about 0.01 ratio loss */
+                            if (optLevel==0) break;  /* gets ~+10% speed for about -0.01 ratio loss */
                         }
         }   }   }   }
 

From 99435dbbab0361c105b1bc6f5c6aa4ab39c89e96 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Sun, 19 Nov 2017 12:58:04 -0800
Subject: [PATCH 069/145] minor : search early-out on sufficient_len for hc3
 and rep

very very small speed and ratio increases
---
 lib/compress/zstd_opt.c | 28 ++++++++++++++--------------
 tests/paramgrill.c      | 12 ++++--------
 2 files changed, 18 insertions(+), 22 deletions(-)

diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index c62b8897c..7fd866f0a 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -240,9 +240,9 @@ FORCE_INLINE_TEMPLATE
 U32 ZSTD_insertBtAndGetAllMatches (
                         ZSTD_CCtx* zc,
                         const BYTE* const ip, const BYTE* const iLimit, const int extDict,
-                        U32 nbCompares, U32 const mls,
+                        U32 nbCompares, U32 const mls, U32 const sufficient_len,
                         U32 rep[ZSTD_REP_NUM], U32 const ll0,
-                        ZSTD_match_t* matches, const U32 minMatchLen)
+                        ZSTD_match_t* matches, const U32 lengthToBeat)
 {
     const BYTE* const base = zc->base;
     U32 const current = (U32)(ip-base);
@@ -267,7 +267,7 @@ U32 ZSTD_insertBtAndGetAllMatches (
     U32 dummy32;   /* to be nullified at the end */
     U32 mnum = 0;
 
-    size_t bestLength = minMatchLen-1;
+    size_t bestLength = lengthToBeat-1;
     DEBUGLOG(7, "ZSTD_insertBtAndGetAllMatches");
 
     /* check repCode */
@@ -299,7 +299,7 @@ U32 ZSTD_insertBtAndGetAllMatches (
                 matches[mnum].off = repCode - ll0;
                 matches[mnum].len = (U32)repLen;
                 mnum++;
-                if ( (repLen > ZSTD_OPT_NUM)
+                if ( (repLen > sufficient_len)
                    | (ip+repLen == iLimit) ) {  /* best possible */
                     return mnum;
     }   }   }   }
@@ -328,7 +328,7 @@ U32 ZSTD_insertBtAndGetAllMatches (
                 matches[0].off = (current - matchIndex3) + ZSTD_REP_MOVE;
                 matches[0].len = (U32)mlen;
                 mnum = 1;
-                if ( (mlen > ZSTD_OPT_NUM)
+                if ( (mlen > sufficient_len)
                    | (ip+mlen == iLimit) ) {  /* best possible */
                     return 1;
     }   }   }   }
@@ -394,10 +394,10 @@ U32 ZSTD_insertBtAndGetAllMatches (
 
 FORCE_INLINE_TEMPLATE U32 ZSTD_BtGetAllMatches (
                         ZSTD_CCtx* zc,   /* Index table will be updated */
-                        const BYTE* ip, const BYTE* const iHighLimit, const int extDict,
-                        const U32 maxNbAttempts, const U32 matchLengthSearch,
+                        const BYTE* ip, const BYTE* const iHighLimit, int const extDict,
+                        U32 const maxNbAttempts, U32 const matchLengthSearch, U32 const sufficient_len,
                         U32 rep[ZSTD_REP_NUM], U32 const ll0,
-                        ZSTD_match_t* matches, const U32 minMatchLen)
+                        ZSTD_match_t* matches, U32 const lengthToBeat)
 {
     DEBUGLOG(7, "ZSTD_BtGetAllMatches");
     if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */
@@ -405,12 +405,12 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_BtGetAllMatches (
     else ZSTD_updateTree(zc, ip, iHighLimit, maxNbAttempts, matchLengthSearch);
     switch(matchLengthSearch)
     {
-    case 3 : return ZSTD_insertBtAndGetAllMatches(zc, ip, iHighLimit, extDict, maxNbAttempts, 3, rep, ll0, matches, minMatchLen);
+    case 3 : return ZSTD_insertBtAndGetAllMatches(zc, ip, iHighLimit, extDict, maxNbAttempts, 3, sufficient_len, rep, ll0, matches, lengthToBeat);
     default :
-    case 4 : return ZSTD_insertBtAndGetAllMatches(zc, ip, iHighLimit, extDict, maxNbAttempts, 4, rep, ll0, matches, minMatchLen);
-    case 5 : return ZSTD_insertBtAndGetAllMatches(zc, ip, iHighLimit, extDict, maxNbAttempts, 5, rep, ll0, matches, minMatchLen);
+    case 4 : return ZSTD_insertBtAndGetAllMatches(zc, ip, iHighLimit, extDict, maxNbAttempts, 4, sufficient_len, rep, ll0, matches, lengthToBeat);
+    case 5 : return ZSTD_insertBtAndGetAllMatches(zc, ip, iHighLimit, extDict, maxNbAttempts, 5, sufficient_len, rep, ll0, matches, lengthToBeat);
     case 7 :
-    case 6 : return ZSTD_insertBtAndGetAllMatches(zc, ip, iHighLimit, extDict, maxNbAttempts, 6, rep, ll0, matches, minMatchLen);
+    case 6 : return ZSTD_insertBtAndGetAllMatches(zc, ip, iHighLimit, extDict, maxNbAttempts, 6, sufficient_len, rep, ll0, matches, lengthToBeat);
     }
 }
 
@@ -493,7 +493,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
         /* find first match */
         {   U32 const litlen = (U32)(ip - anchor);
             U32 const ll0 = !litlen;
-            U32 const nbMatches = ZSTD_BtGetAllMatches(ctx, ip, iend, extDict, maxSearches, mls, rep, ll0, matches, minMatch);
+            U32 const nbMatches = ZSTD_BtGetAllMatches(ctx, ip, iend, extDict, maxSearches, mls, sufficient_len, rep, ll0, matches, minMatch);
             if (!nbMatches) { ip++; continue; }
 
             /* initialize opt[0] */
@@ -566,7 +566,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                 U32 const litlen = (opt[cur].mlen == 1) ? opt[cur].litlen : 0;
                 U32 const basePrice = (cur > litlen) ? opt[cur-litlen].price : 0;
                 const BYTE* const baseLiterals = ip + cur - litlen;
-                U32 const nbMatches = ZSTD_BtGetAllMatches(ctx, inr, iend, extDict, maxSearches, mls, opt[cur].rep, ll0, matches, minMatch);
+                U32 const nbMatches = ZSTD_BtGetAllMatches(ctx, inr, iend, extDict, maxSearches, mls, sufficient_len, opt[cur].rep, ll0, matches, minMatch);
                 U32 matchNb;
                 if (!nbMatches) continue;
                 assert(baseLiterals >= prefixStart);
diff --git a/tests/paramgrill.c b/tests/paramgrill.c
index a387a44c6..5560e82f6 100644
--- a/tests/paramgrill.c
+++ b/tests/paramgrill.c
@@ -310,14 +310,10 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
 }
 
 
-const char* g_stratName[] = { "ZSTD_fast    ",
-                              "ZSTD_dfast   ",
-                              "ZSTD_greedy  ",
-                              "ZSTD_lazy    ",
-                              "ZSTD_lazy2   ",
-                              "ZSTD_btlazy2 ",
-                              "ZSTD_btopt   ",
-                              "ZSTD_btultra "};
+const char* g_stratName[ZSTD_btultra] = {
+                "ZSTD_fast    ", "ZSTD_dfast   ",
+                "ZSTD_greedy  ", "ZSTD_lazy    ", "ZSTD_lazy2   ",
+                "ZSTD_btlazy2 ", "ZSTD_btopt   ", "ZSTD_btultra "};
 
 static void BMK_printWinner(FILE* f, U32 cLevel, BMK_result_t result, ZSTD_compressionParameters params, size_t srcSize)
 {

From 42c1e642704c2c4d1f402296376b59393c25ca1c Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Sun, 19 Nov 2017 13:39:12 -0800
Subject: [PATCH 070/145] slightly improved ratio at -22

merging of repcode search into btsearch introduced a small compression ratio regressio at max level :
1.3.2 : 52728769
after repMerge patch : 52760789 (+32020)

A few minor changes have produced this difference.
They can be hard to spot.

This patch buys back about half of the difference,
by no longer inserting position at hc3 when a long match is found there.
It feels strangely counter-intuitive, but works :
after this patch : 52742555 (-18234)
---
 lib/compress/zstd_lazy.c | 15 ++++++++-------
 lib/compress/zstd_opt.c  | 10 ++++++----
 tests/paramgrill.c       |  4 ++--
 3 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/lib/compress/zstd_lazy.c b/lib/compress/zstd_lazy.c
index cd3d1530a..a2c658bd3 100644
--- a/lib/compress/zstd_lazy.c
+++ b/lib/compress/zstd_lazy.c
@@ -16,8 +16,8 @@
 *  Binary Tree search
 ***************************************/
 /** ZSTD_insertBt1() : add one or multiple positions to tree.
-*   ip : assumed <= iend-8 .
-*   @return : nb of positions added */
+ *  ip : assumed <= iend-8 .
+ * @return : nb of positions added */
 static U32 ZSTD_insertBt1(ZSTD_CCtx* zc,
                 const BYTE* const ip, const BYTE* const iend,
                 U32 nbCompares, U32 const mls, U32 const extDict)
@@ -42,7 +42,7 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc,
     U32* largerPtr  = smallerPtr + 1;
     U32 dummy32;   /* to be nullified at the end */
     U32 const windowLow = zc->lowLimit;
-    U32 matchEndIdx = current+8;
+    U32 matchEndIdx = current+8+1;
     size_t bestLength = 8;
 #ifdef ZSTD_C_PREDICT
     U32 predictedSmall = *(bt + 2*((current-1)&btMask) + 0);
@@ -122,8 +122,8 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc,
 
     *smallerPtr = *largerPtr = 0;
     if (bestLength > 384) return MIN(192, (U32)(bestLength - 384));   /* speed optimization */
-    if (matchEndIdx > current + 8) return matchEndIdx - (current + 8);
-    return 1;
+    assert(matchEndIdx > current + 8);
+    return matchEndIdx - (current + 8);
 }
 
 FORCE_INLINE_TEMPLATE
@@ -182,7 +182,7 @@ static size_t ZSTD_insertBtAndFindBestMatch (
     const U32 windowLow = zc->lowLimit;
     U32* smallerPtr = bt + 2*(current&btMask);
     U32* largerPtr  = bt + 2*(current&btMask) + 1;
-    U32 matchEndIdx = current+8;
+    U32 matchEndIdx = current+8+1;
     U32 dummy32;   /* to be nullified at the end */
     size_t bestLength = 0;
 
@@ -233,7 +233,8 @@ static size_t ZSTD_insertBtAndFindBestMatch (
 
     *smallerPtr = *largerPtr = 0;
 
-    zc->nextToUpdate = (matchEndIdx > current + 8) ? matchEndIdx - 8 : current+1;   /* skip repetitive patterns */
+    assert(matchEndIdx > current+8);
+    zc->nextToUpdate = matchEndIdx - 8;   /* skip repetitive patterns */
     return bestLength;
 }
 
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index 7fd866f0a..7508aa1bc 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -263,7 +263,7 @@ U32 ZSTD_insertBtAndGetAllMatches (
     U32 const windowLow = zc->lowLimit;
     U32* smallerPtr = bt + 2*(current&btMask);
     U32* largerPtr  = bt + 2*(current&btMask) + 1;
-    U32 matchEndIdx = current+8;   /* farthest referenced position of any match => detects repetitive patterns */
+    U32 matchEndIdx = current+8+1;   /* farthest referenced position of any match => detects repetitive patterns */
     U32 dummy32;   /* to be nullified at the end */
     U32 mnum = 0;
 
@@ -328,8 +328,9 @@ U32 ZSTD_insertBtAndGetAllMatches (
                 matches[0].off = (current - matchIndex3) + ZSTD_REP_MOVE;
                 matches[0].len = (U32)mlen;
                 mnum = 1;
-                if ( (mlen > sufficient_len)
-                   | (ip+mlen == iLimit) ) {  /* best possible */
+                if ( (mlen > sufficient_len) |
+                     (ip+mlen == iLimit) ) {  /* best possible length */
+                    zc->nextToUpdate = current+1;  /* skip insertion */
                     return 1;
     }   }   }   }
 
@@ -387,7 +388,8 @@ U32 ZSTD_insertBtAndGetAllMatches (
 
     *smallerPtr = *largerPtr = 0;
 
-    zc->nextToUpdate = (matchEndIdx > current + 8) ? matchEndIdx - 8 : current+1;  /* skip repetitive patterns */
+    assert(matchEndIdx > current+8);
+    zc->nextToUpdate = matchEndIdx - 8;  /* skip repetitive patterns */
     return mnum;
 }
 
diff --git a/tests/paramgrill.c b/tests/paramgrill.c
index 5560e82f6..081a284e4 100644
--- a/tests/paramgrill.c
+++ b/tests/paramgrill.c
@@ -310,8 +310,8 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
 }
 
 
-const char* g_stratName[ZSTD_btultra] = {
-                "ZSTD_fast    ", "ZSTD_dfast   ",
+const char* g_stratName[ZSTD_btultra+1] = {
+                "(none)       ", "ZSTD_fast    ", "ZSTD_dfast   ",
                 "ZSTD_greedy  ", "ZSTD_lazy    ", "ZSTD_lazy2   ",
                 "ZSTD_btlazy2 ", "ZSTD_btopt   ", "ZSTD_btultra "};
 

From 3f457264d153e1a5e08cc2403eb5d6f2887b6c44 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Sun, 19 Nov 2017 14:40:21 -0800
Subject: [PATCH 071/145] slightly improved compression speed

---
 lib/compress/zstd_compress_internal.h | 18 +++++++++-------
 lib/compress/zstd_lazy.c              | 30 +++++++++++++--------------
 lib/compress/zstd_opt.c               |  5 ++---
 3 files changed, 27 insertions(+), 26 deletions(-)

diff --git a/lib/compress/zstd_compress_internal.h b/lib/compress/zstd_compress_internal.h
index 862558b50..4fd55c438 100644
--- a/lib/compress/zstd_compress_internal.h
+++ b/lib/compress/zstd_compress_internal.h
@@ -347,13 +347,17 @@ MEM_STATIC size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* co
     const BYTE* const pStart = pIn;
     const BYTE* const pInLoopLimit = pInLimit - (sizeof(size_t)-1);
 
-    while (pIn < pInLoopLimit) {
-        size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
-        if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; }
-        pIn += ZSTD_NbCommonBytes(diff);
-        return (size_t)(pIn - pStart);
-    }
-    if (MEM_64bits()) if ((pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; }
+    if (pIn < pInLoopLimit) {
+        { size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
+          if (diff) return ZSTD_NbCommonBytes(diff); }
+        pIn+=sizeof(size_t); pMatch+=sizeof(size_t);
+        while (pIn < pInLoopLimit) {
+            size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
+            if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; }
+            pIn += ZSTD_NbCommonBytes(diff);
+            return (size_t)(pIn - pStart);
+    }   }
+    if (MEM_64bits() && (pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; }
     if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; }
     if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
     return (size_t)(pIn - pStart);
diff --git a/lib/compress/zstd_lazy.c b/lib/compress/zstd_lazy.c
index a2c658bd3..9937e24b5 100644
--- a/lib/compress/zstd_lazy.c
+++ b/lib/compress/zstd_lazy.c
@@ -85,8 +85,8 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc,
         if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
             assert(matchIndex+matchLength >= dictLimit);   /* might be wrong if extDict is incorrectly set to 0 */
             match = base + matchIndex;
-            if (match[matchLength] == ip[matchLength])
-                matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iend) +1;
+            //if (match[matchLength] == ip[matchLength]) matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iend) +1;
+            matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
         } else {
             match = dictBase + matchIndex;
             matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
@@ -196,8 +196,8 @@ static size_t ZSTD_insertBtAndFindBestMatch (
 
         if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
             match = base + matchIndex;
-            if (match[matchLength] == ip[matchLength])
-                matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iend) +1;
+            //if (match[matchLength] == ip[matchLength]) matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iend) +1;
+            matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
         } else {
             match = dictBase + matchIndex;
             matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
@@ -355,14 +355,14 @@ size_t ZSTD_HcFindBestMatch_generic (
     U32 matchIndex = ZSTD_insertAndFindFirstIndex (zc, ip, mls);
 
     for ( ; (matchIndex>lowLimit) & (nbAttempts>0) ; nbAttempts--) {
-        const BYTE* match;
         size_t currentMl=0;
         if ((!extDict) || matchIndex >= dictLimit) {
-            match = base + matchIndex;
+            const BYTE* const match = base + matchIndex;
             if (match[ml] == ip[ml])   /* potentially better */
                 currentMl = ZSTD_count(ip, match, iLimit);
         } else {
-            match = dictBase + matchIndex;
+            const BYTE* const match = dictBase + matchIndex;
+            assert(match+4 <= dictEnd);
             if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */
                 currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dictEnd, prefixStart) + 4;
         }
@@ -400,10 +400,10 @@ FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_selectMLS (
 
 
 FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_extDict_selectMLS (
-                        ZSTD_CCtx* zc,
+                        ZSTD_CCtx* const zc,
                         const BYTE* ip, const BYTE* const iLimit,
-                        size_t* offsetPtr,
-                        const U32 maxNbAttempts, const U32 matchLengthSearch)
+                        size_t* const offsetPtr,
+                        U32 const maxNbAttempts, U32 const matchLengthSearch)
 {
     switch(matchLengthSearch)
     {
@@ -522,9 +522,8 @@ size_t ZSTD_compressBlock_lazy_generic(ZSTD_CCtx* ctx,
          */
         /* catch up */
         if (offset) {
-            while ( (start > anchor)
-                 && (start > base+offset-ZSTD_REP_MOVE)
-                 && (start[-1] == (start-offset+ZSTD_REP_MOVE)[-1]) )  /* only search for offset within prefix */
+            while ( ((start > anchor) & (start - (offset-ZSTD_REP_MOVE) > base))
+                 && (start[-1] == (start-(offset-ZSTD_REP_MOVE))[-1]) )  /* only search for offset within prefix */
                 { start--; matchLength++; }
             offset_2 = offset_1; offset_1 = (U32)(offset - ZSTD_REP_MOVE);
         }
@@ -536,9 +535,8 @@ _storeSequence:
         }
 
         /* check immediate repcode */
-        while ( (ip <= ilimit)
-             && ((offset_2>0)
-             & (MEM_read32(ip) == MEM_read32(ip - offset_2)) )) {
+        while ( ((ip <= ilimit) & (offset_2>0))
+             && (MEM_read32(ip) == MEM_read32(ip - offset_2)) ) {
             /* store sequence */
             matchLength = ZSTD_count(ip+4, ip+4-offset_2, iend) + 4;
             offset = offset_2; offset_2 = offset_1; offset_1 = (U32)offset; /* swap repcodes */
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index 7508aa1bc..9eb338e18 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -345,9 +345,8 @@ U32 ZSTD_insertBtAndGetAllMatches (
         if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
             assert(matchIndex+matchLength >= dictLimit);  /* ensure the condition is correct when !extDict */
             match = base + matchIndex;
-            if (match[matchLength] == ip[matchLength]) {
-                matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iLimit) +1;
-            }
+            //if (match[matchLength] == ip[matchLength]) { matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iLimit) +1; }
+            matchLength += ZSTD_count(ip+matchLength, match+matchLength, iLimit);
         } else {
             match = dictBase + matchIndex;
             matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dictEnd, prefixStart);

From 899f2a29f6f70f7812c3f79259b593c3dde67401 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Mon, 20 Nov 2017 11:53:20 -0800
Subject: [PATCH 072/145] strategy ZSTD_btopt pinned to (0) variant (faster
 one)

---
 lib/compress/zstd_lazy.c | 2 --
 lib/compress/zstd_opt.c  | 3 +--
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/lib/compress/zstd_lazy.c b/lib/compress/zstd_lazy.c
index 9937e24b5..6d4804961 100644
--- a/lib/compress/zstd_lazy.c
+++ b/lib/compress/zstd_lazy.c
@@ -85,7 +85,6 @@ static U32 ZSTD_insertBt1(ZSTD_CCtx* zc,
         if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
             assert(matchIndex+matchLength >= dictLimit);   /* might be wrong if extDict is incorrectly set to 0 */
             match = base + matchIndex;
-            //if (match[matchLength] == ip[matchLength]) matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iend) +1;
             matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
         } else {
             match = dictBase + matchIndex;
@@ -196,7 +195,6 @@ static size_t ZSTD_insertBtAndFindBestMatch (
 
         if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
             match = base + matchIndex;
-            //if (match[matchLength] == ip[matchLength]) matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iend) +1;
             matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
         } else {
             match = dictBase + matchIndex;
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index 9eb338e18..b9a2cf85f 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -345,7 +345,6 @@ U32 ZSTD_insertBtAndGetAllMatches (
         if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
             assert(matchIndex+matchLength >= dictLimit);  /* ensure the condition is correct when !extDict */
             match = base + matchIndex;
-            //if (match[matchLength] == ip[matchLength]) { matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iLimit) +1; }
             matchLength += ZSTD_count(ip+matchLength, match+matchLength, iLimit);
         } else {
             match = dictBase + matchIndex;
@@ -685,7 +684,7 @@ size_t ZSTD_compressBlock_btultra(ZSTD_CCtx* ctx, const void* src, size_t srcSiz
 
 size_t ZSTD_compressBlock_btopt_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
 {
-    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 1 /*optLevel*/, 1 /*extDict*/);
+    return ZSTD_compressBlock_opt_generic(ctx, src, srcSize, 0 /*optLevel*/, 1 /*extDict*/);
 }
 
 size_t ZSTD_compressBlock_btultra_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize)

From 287db17c8c3005b8630c9cb3f753034a6d5521a4 Mon Sep 17 00:00:00 2001
From: Dusta <dusta@users.noreply.github.com>
Date: Mon, 20 Nov 2017 21:35:28 +0100
Subject: [PATCH 073/145] Missing dot

---
 README.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 377ae0843..99f320c45 100644
--- a/README.md
+++ b/README.md
@@ -57,7 +57,7 @@ Compression Speed vs Ratio | Decompression Speed
 ![Compression Speed vs Ratio](doc/images/Cspeed4.png "Compression Speed vs Ratio") | ![Decompression Speed](doc/images/Dspeed4.png "Decompression Speed")
 
 Several algorithms can produce higher compression ratios, but at slower speeds, falling outside of the graph.
-For a larger picture including very slow modes, [click on this link](doc/images/DCspeed5.png) .
+For a larger picture including very slow modes, [click on this link](doc/images/DCspeed5.png).
 
 
 ### The case for Small Data compression
@@ -84,7 +84,7 @@ Training works if there is some correlation in a family of small data samples. T
 Hence, deploying one dictionary per type of data will provide the greatest benefits.
 Dictionary gains are mostly effective in the first few KB. Then, the compression algorithm will gradually use previously decoded content to better compress the rest of the file.
 
-#### Dictionary compression How To :
+#### Dictionary compression How To:
 
 1) Create the dictionary
 
@@ -109,7 +109,7 @@ If your system is compatible with a standard `make` (or `gmake`) binary generato
 you can simply run it at the root directory.
 It will generate `zstd` within root directory.
 
-Other available options include :
+Other available options include:
 - `make install` : create and install zstd binary, library and man page
 - `make test` : create and run `zstd` and test tools on local platform
 
@@ -125,9 +125,9 @@ A Meson project is provided within `contrib/meson`.
 
 #### Visual Studio (Windows)
 
-Going into `build` directory, you will find additional possibilities :
-- Projects for Visual Studio 2005, 2008 and 2010
-  + VS2010 project is compatible with VS2012, VS2013 and VS2015
+Going into `build` directory, you will find additional possibilities:
+- Projects for Visual Studio 2005, 2008 and 2010.
+  + VS2010 project is compatible with VS2012, VS2013 and VS2015.
 - Automated build scripts for Visual compiler by @KrzysFR , in `build/VS_scripts`,
   which will build `zstd` cli and `libzstd` library without any need to open Visual Studio solution.
 

From 4154aec679e98b76c3e19ccdcb105e89faf9af37 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 21 Nov 2017 10:26:17 -0800
Subject: [PATCH 074/145] fixed comment, as suggested by @terrelln

---
 doc/zstd_manual.html    | 5 +++--
 lib/compress/zstd_opt.c | 5 +++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/doc/zstd_manual.html b/doc/zstd_manual.html
index 9697ebd57..e50f46661 100644
--- a/doc/zstd_manual.html
+++ b/doc/zstd_manual.html
@@ -111,7 +111,7 @@ unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize);
   @return : content size to be decompressed, as a 64-bits value _if known and not empty_, 0 otherwise. 
 </p></pre><BR>
 
-<h3>Helper functions</h3><pre></pre><b><pre>#define ZSTD_COMPRESSBOUND(srcSize)   ((srcSize) + ((srcSize)>>8) + (((srcSize) < 128 KB) ? ((128 KB - (srcSize)) >> 11) </b>/* margin, from 64 to 0 */ : 0))  /* this formula ensures that bound(A) + bound(B) <= bound(A+B) as long as A and B >= 128 KB */<b>
+<h3>Helper functions</h3><pre></pre><b><pre>#define ZSTD_COMPRESSBOUND(srcSize)   ((srcSize) + ((srcSize)>>8) + (((srcSize) < (128<<10)) ? (((128<<10) - (srcSize)) >> 11) </b>/* margin, from 64 to 0 */ : 0))  /* this formula ensures that bound(A) + bound(B) <= bound(A+B) as long as A and B >= 128 KB */<b>
 size_t      ZSTD_compressBound(size_t srcSize); </b>/*!< maximum compressed size in worst case scenario */<b>
 unsigned    ZSTD_isError(size_t code);          </b>/*!< tells if a `size_t` function result is an error code */<b>
 const char* ZSTD_getErrorName(size_t code);     </b>/*!< provides readable string from an error code */<b>
@@ -906,7 +906,8 @@ size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long
 <pre><b>size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned value);
 </b><p>  Set one compression parameter, selected by enum ZSTD_cParameter.
   Note : when `value` is an enum, cast it to unsigned for proper type checking.
-  @result : 0, or an error code (which can be tested with ZSTD_isError()). 
+  @result : informational value (typically, the one being set, possibly corrected),
+            or an error code (which can be tested with ZSTD_isError()). 
 </p></pre><BR>
 
 <pre><b>size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize);
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index b9a2cf85f..1defcb8fe 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -606,7 +606,8 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                         } else {
                             if (optLevel==0) break;  /* gets ~+10% speed for about -0.01 ratio loss */
                         }
-        }   }   }   }
+            }   }   }
+        }  /* for (cur = 1; cur <= last_pos; cur++) */
 
         best_mlen = opt[last_pos].mlen;
         best_off = opt[last_pos].off;
@@ -661,7 +662,7 @@ _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
                 anchor = ip;
         }   }
         ZSTD_setLog2Prices(optStatePtr);
-    }   /* for (cur=0; cur < last_pos; ) */
+    }   while (ip < ilimit)
 
     /* Save reps for next block */
     { int i; for (i=0; i<ZSTD_REP_NUM; i++) seqStorePtr->repToConfirm[i] = rep[i]; }

From f8d5c478afe143ffff63ac67c3ade593974efa27 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 21 Nov 2017 10:36:14 -0800
Subject: [PATCH 075/145] fixed comment, reported by @gyscos

---
 lib/compress/zstd_opt.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index 1defcb8fe..66a7da19c 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -662,7 +662,7 @@ _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
                 anchor = ip;
         }   }
         ZSTD_setLog2Prices(optStatePtr);
-    }   while (ip < ilimit)
+    }   /* while (ip < ilimit) */
 
     /* Save reps for next block */
     { int i; for (i=0; i<ZSTD_REP_NUM; i++) seqStorePtr->repToConfirm[i] = rep[i]; }

From 31a191b17895d115b35fa4c254a9b99b67bbe58a Mon Sep 17 00:00:00 2001
From: Scott Baker <scott@perturb.org>
Date: Wed, 22 Nov 2017 20:29:46 -0800
Subject: [PATCH 076/145] Include information about the benchmark
 output/methodology

Addresses #930
---
 programs/zstd.1.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/programs/zstd.1.md b/programs/zstd.1.md
index eea685489..9e4c5d305 100644
--- a/programs/zstd.1.md
+++ b/programs/zstd.1.md
@@ -258,6 +258,9 @@ BENCHMARK
 * `--priority=rt`:
     set process priority to real-time
 
+**Output Format:** CompressionLevel#Filename : IntputSize -> OutputSize (CompressionRatio), CompressionSpeed, DecompressionSpeed
+
+**Methodology:** For both compression and decompression speed, the entire input is compressed/decompressed in-memory to measure speed. A run lasts at least 1 sec, so when files are small, they are compressed/decompressed several times per run, in order to improve measurement accuracy.
 
 ADVANCED COMPRESSION OPTIONS
 ----------------------------

From c857ee850ad6bd830b44fcf54692478e1206da53 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 24 Nov 2017 16:44:28 -0800
Subject: [PATCH 077/145] minor update

---
 programs/platform.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/programs/platform.h b/programs/platform.h
index a4d7850fd..81dee23f9 100644
--- a/programs/platform.h
+++ b/programs/platform.h
@@ -21,10 +21,10 @@ extern "C" {
 *  Compiler Options
 ****************************************/
 #if defined(_MSC_VER)
-#  define _CRT_SECURE_NO_WARNINGS   /* Disable Visual Studio warning messages for fopen, strncpy, strerror */
-#  define _CRT_SECURE_NO_DEPRECATE  /* VS2005 - must be declared before <io.h> and <windows.h> */
-#  if (_MSC_VER <= 1800)            /* (1800 = Visual Studio 2013) */
-#    define snprintf sprintf_s      /* snprintf unsupported by Visual <= 2013 */
+#  define _CRT_SECURE_NO_WARNINGS    /* Disable Visual Studio warning messages for fopen, strncpy, strerror */
+#  if (_MSC_VER <= 1800)             /* 1800 == Visual Studio 2013 */
+#    define _CRT_SECURE_NO_DEPRECATE /* VS2005 - must be declared before <io.h> and <windows.h> */
+#    define snprintf sprintf_s       /* snprintf unsupported by Visual <= 2013 */
 #  endif
 #endif
 
@@ -117,7 +117,7 @@ static __inline int IS_CONSOLE(FILE* stdStream)
 
 
 /******************************
-*  OS-specific Includes
+*  OS-specific IO behaviors
 ******************************/
 #if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(_WIN32)
 #  include <fcntl.h>   /* _O_BINARY */
@@ -125,7 +125,7 @@ static __inline int IS_CONSOLE(FILE* stdStream)
 #  if !defined(__DJGPP__)
 #    include <windows.h> /* DeviceIoControl, HANDLE, FSCTL_SET_SPARSE */
 #    include <winioctl.h> /* FSCTL_SET_SPARSE */
-#    define SET_BINARY_MODE(file) { int unused=_setmode(_fileno(file), _O_BINARY); (void)unused; }
+#    define SET_BINARY_MODE(file) { int const unused=_setmode(_fileno(file), _O_BINARY); (void)unused; }
 #    define SET_SPARSE_FILE_MODE(file) { DWORD dw; DeviceIoControl((HANDLE) _get_osfhandle(_fileno(file)), FSCTL_SET_SPARSE, 0, 0, 0, 0, &dw, 0); }
 #  else
 #    define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)

From 2fd765498a750f009404feedd26f8e8f60f83a1e Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 24 Nov 2017 17:20:54 -0800
Subject: [PATCH 078/145] updated man page

following patch #931 by @scottchiefbaker
---
 programs/zstd.1 | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/programs/zstd.1 b/programs/zstd.1
index 8187c7403..eb53e2c33 100644
--- a/programs/zstd.1
+++ b/programs/zstd.1
@@ -1,5 +1,5 @@
 .
-.TH "ZSTD" "1" "September 2017" "zstd 1.3.1" "User Commands"
+.TH "ZSTD" "1" "November 2017" "zstd 1.3.2" "User Commands"
 .
 .SH "NAME"
 \fBzstd\fR \- zstd, zstdmt, unzstd, zstdcat \- Compress or decompress \.zst files
@@ -60,11 +60,11 @@ In most places where an integer argument is expected, an optional suffix is supp
 .
 .TP
 \fBKiB\fR
-Multiply the integer by 1,024 (2\e \fBKi\fR, \fBK\fR, and \fBKB\fR are accepted as synonyms for \fBKiB\fR\.
+Multiply the integer by 1,024 (2^10)\. \fBKi\fR, \fBK\fR, and \fBKB\fR are accepted as synonyms for \fBKiB\fR\.
 .
 .TP
 \fBMiB\fR
-Multiply the integer by 1,048,576 (2\e \fBMi\fR, \fBM\fR, and \fBMB\fR are accepted as synonyms for \fBMiB\fR\.
+Multiply the integer by 1,048,576 (2^20)\. \fBMi\fR, \fBM\fR, and \fBMB\fR are accepted as synonyms for \fBMiB\fR\.
 .
 .SS "Operation mode"
 If multiple operation mode options are given, the last one takes effect\.
@@ -261,6 +261,12 @@ cut file(s) into independent blocks of size # (default: no block)
 \fB\-\-priority=rt\fR
 set process priority to real\-time
 .
+.P
+\fBOutput Format:\fR CompressionLevel#Filename : IntputSize \-> OutputSize (CompressionRatio), CompressionSpeed, DecompressionSpeed
+.
+.P
+\fBMethodology:\fR For both compression and decompression speed, the entire input is compressed/decompressed in\-memory to measure speed\. A run lasts at least 1 sec, so when files are small, they are compressed/decompressed several times per run, in order to improve measurement accuracy\.
+.
 .SH "ADVANCED COMPRESSION OPTIONS"
 .
 .SS "\-\-zstd[=options]:"

From bd88f633acda0de4f9eaef6b0914c3b569a34724 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Mon, 27 Nov 2017 12:15:23 -0800
Subject: [PATCH 079/145] zstreamtest : in `-T#s`, s considered a suffix
 meaning "seconds"

avoid unintentionnally triggering `seedset`,
so that seed gets automatically determined when not set.
---
 doc/zstd_manual.html | 62 +++++++++++++++++++++++---------------------
 lib/zstd.h           | 17 +++++++-----
 tests/zstreamtest.c  | 31 +++++++++++-----------
 3 files changed, 58 insertions(+), 52 deletions(-)

diff --git a/doc/zstd_manual.html b/doc/zstd_manual.html
index e50f46661..872dbf637 100644
--- a/doc/zstd_manual.html
+++ b/doc/zstd_manual.html
@@ -19,16 +19,17 @@
 <li><a href="#Chapter9">Streaming decompression - HowTo</a></li>
 <li><a href="#Chapter10">START OF ADVANCED AND EXPERIMENTAL FUNCTIONS</a></li>
 <li><a href="#Chapter11">Advanced types</a></li>
-<li><a href="#Chapter12">Frame size functions</a></li>
-<li><a href="#Chapter13">Context memory usage</a></li>
-<li><a href="#Chapter14">Advanced compression functions</a></li>
-<li><a href="#Chapter15">Advanced decompression functions</a></li>
-<li><a href="#Chapter16">Advanced streaming functions</a></li>
-<li><a href="#Chapter17">Buffer-less and synchronous inner streaming functions</a></li>
-<li><a href="#Chapter18">Buffer-less streaming compression (synchronous mode)</a></li>
-<li><a href="#Chapter19">Buffer-less streaming decompression (synchronous mode)</a></li>
-<li><a href="#Chapter20">New advanced API (experimental)</a></li>
-<li><a href="#Chapter21">Block level API</a></li>
+<li><a href="#Chapter12">Custom memory allocation functions</a></li>
+<li><a href="#Chapter13">Frame size functions</a></li>
+<li><a href="#Chapter14">Context memory usage</a></li>
+<li><a href="#Chapter15">Advanced compression functions</a></li>
+<li><a href="#Chapter16">Advanced decompression functions</a></li>
+<li><a href="#Chapter17">Advanced streaming functions</a></li>
+<li><a href="#Chapter18">Buffer-less and synchronous inner streaming functions</a></li>
+<li><a href="#Chapter19">Buffer-less streaming compression (synchronous mode)</a></li>
+<li><a href="#Chapter20">Buffer-less streaming decompression (synchronous mode)</a></li>
+<li><a href="#Chapter21">New advanced API (experimental)</a></li>
+<li><a href="#Chapter22">Block level API</a></li>
 </ol>
 <hr>
 <a name="Chapter1"></a><h2>Introduction</h2><pre>
@@ -346,17 +347,15 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
     ZSTD_frameParameters fParams;
 } ZSTD_parameters;
 </b></pre><BR>
-<h3>Custom memory allocation functions</h3><pre></pre><b><pre>typedef void* (*ZSTD_allocFunction) (void* opaque, size_t size);
-typedef void  (*ZSTD_freeFunction) (void* opaque, void* address);
-typedef struct { ZSTD_allocFunction customAlloc; ZSTD_freeFunction customFree; void* opaque; } ZSTD_customMem;
-</b>/* use this constant to defer to stdlib's functions */<b>
-static const ZSTD_customMem ZSTD_defaultCMem = { NULL, NULL, NULL };
-</pre></b><BR>
-<a name="Chapter12"></a><h2>Frame size functions</h2><pre></pre>
+<a name="Chapter12"></a><h2>Custom memory allocation functions</h2><pre></pre>
+
+<pre><b>typedef struct { ZSTD_allocFunction customAlloc; ZSTD_freeFunction customFree; void* opaque; } ZSTD_customMem;
+</b></pre><BR>
+<a name="Chapter13"></a><h2>Frame size functions</h2><pre></pre>
 
 <pre><b>size_t ZSTD_findFrameCompressedSize(const void* src, size_t srcSize);
 </b><p>  `src` should point to the start of a ZSTD encoded frame or skippable frame
-  `srcSize` must be at least as large as the frame
+  `srcSize` must be >= first frame size
   @return : the compressed size of the first frame starting at `src`,
             suitable to pass to `ZSTD_decompress` or similar,
             or an error code if input is invalid 
@@ -391,7 +390,7 @@ static const ZSTD_customMem ZSTD_defaultCMem = { NULL, NULL, NULL };
    @return : size of the Frame Header 
 </p></pre><BR>
 
-<a name="Chapter13"></a><h2>Context memory usage</h2><pre></pre>
+<a name="Chapter14"></a><h2>Context memory usage</h2><pre></pre>
 
 <pre><b>size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx);
 size_t ZSTD_sizeof_DCtx(const ZSTD_DCtx* dctx);
@@ -450,7 +449,7 @@ size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMet
  
 </p></pre><BR>
 
-<a name="Chapter14"></a><h2>Advanced compression functions</h2><pre></pre>
+<a name="Chapter15"></a><h2>Advanced compression functions</h2><pre></pre>
 
 <pre><b>ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem);
 </b><p>  Create a ZSTD compression context using external alloc and free functions 
@@ -462,7 +461,8 @@ size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMet
              It must outlive context usage.
   workspaceSize: Use ZSTD_estimateCCtxSize() or ZSTD_estimateCStreamSize()
                  to determine how large workspace must be to support scenario.
- @return : pointer to ZSTD_CCtx*, or NULL if error (size too small)
+ @return : pointer to ZSTD_CCtx* (same address as workspace, but different type),
+           or NULL if error (typically size too small)
   Note : zstd will never resize nor malloc() when using a static cctx.
          If it needs more memory than available, it will simply error out.
   Note 2 : there is no corresponding "free" function.
@@ -505,7 +505,8 @@ size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMet
                  to determine how large workspace must be.
   cParams : use ZSTD_getCParams() to transform a compression level
             into its relevants cParams.
- @return : pointer to ZSTD_CDict*, or NULL if error (size too small)
+ @return : pointer to ZSTD_CDict* (same address as workspace, but different type),
+           or NULL if error (typically, size too small).
   Note : there is no corresponding "free" function.
          Since workspace was allocated externally, it must be freed externally.
  
@@ -545,7 +546,7 @@ size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMet
 </b><p>   Same as ZSTD_compress_usingCDict(), with fine-tune control over frame parameters 
 </p></pre><BR>
 
-<a name="Chapter15"></a><h2>Advanced decompression functions</h2><pre></pre>
+<a name="Chapter16"></a><h2>Advanced decompression functions</h2><pre></pre>
 
 <pre><b>unsigned ZSTD_isFrame(const void* buffer, size_t size);
 </b><p>  Tells if the content of `buffer` starts with a valid Frame Identifier.
@@ -564,7 +565,8 @@ size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMet
              It must outlive context usage.
   workspaceSize: Use ZSTD_estimateDCtxSize() or ZSTD_estimateDStreamSize()
                  to determine how large workspace must be to support scenario.
- @return : pointer to ZSTD_DCtx*, or NULL if error (size too small)
+ @return : pointer to ZSTD_DCtx* (same address as workspace, but different type),
+           or NULL if error (typically size too small)
   Note : zstd will never resize nor malloc() when using a static dctx.
          If it needs more memory than available, it will simply error out.
   Note 2 : static dctx is incompatible with legacy support
@@ -627,7 +629,7 @@ size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMet
   When identifying the exact failure cause, it's possible to use ZSTD_getFrameHeader(), which will provide a more precise error code. 
 </p></pre><BR>
 
-<a name="Chapter16"></a><h2>Advanced streaming functions</h2><pre></pre>
+<a name="Chapter17"></a><h2>Advanced streaming functions</h2><pre></pre>
 
 <h3>Advanced Streaming compression functions</h3><pre></pre><b><pre>ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);
 ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize);    </b>/**< same as ZSTD_initStaticCCtx() */<b>
@@ -657,14 +659,14 @@ size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t di
 size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* zds, const ZSTD_DDict* ddict);  </b>/**< note : ddict is referenced, it must outlive decompression session */<b>
 size_t ZSTD_resetDStream(ZSTD_DStream* zds);  </b>/**< re-use decompression parameters from previous init; saves dictionary loading */<b>
 </pre></b><BR>
-<a name="Chapter17"></a><h2>Buffer-less and synchronous inner streaming functions</h2><pre>
+<a name="Chapter18"></a><h2>Buffer-less and synchronous inner streaming functions</h2><pre>
   This is an advanced API, giving full control over buffer management, for users which need direct control over memory.
   But it's also a complex one, with several restrictions, documented below.
   Prefer normal streaming API for an easier experience.
  
 <BR></pre>
 
-<a name="Chapter18"></a><h2>Buffer-less streaming compression (synchronous mode)</h2><pre>
+<a name="Chapter19"></a><h2>Buffer-less streaming compression (synchronous mode)</h2><pre>
   A ZSTD_CCtx object is required to track streaming operations.
   Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage resource.
   ZSTD_CCtx object can be re-used multiple times within successive compression operations.
@@ -700,7 +702,7 @@ size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict);
 size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize);   </b>/* compression parameters are already set within cdict. pledgedSrcSize must be correct. If srcSize is not known, use macro ZSTD_CONTENTSIZE_UNKNOWN */<b>
 size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, unsigned long long pledgedSrcSize); </b>/**<  note: if pledgedSrcSize is not known, use ZSTD_CONTENTSIZE_UNKNOWN */<b>
 </pre></b><BR>
-<a name="Chapter19"></a><h2>Buffer-less streaming decompression (synchronous mode)</h2><pre>
+<a name="Chapter20"></a><h2>Buffer-less streaming decompression (synchronous mode)</h2><pre>
   A ZSTD_DCtx object is required to track streaming operations.
   Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it.
   A ZSTD_DCtx object can be re-used multiple times.
@@ -786,7 +788,7 @@ size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long
 </pre></b><BR>
 <pre><b>typedef enum { ZSTDnit_frameHeader, ZSTDnit_blockHeader, ZSTDnit_block, ZSTDnit_lastBlock, ZSTDnit_checksum, ZSTDnit_skippableFrame } ZSTD_nextInputType_e;
 </b></pre><BR>
-<a name="Chapter20"></a><h2>New advanced API (experimental)</h2><pre></pre>
+<a name="Chapter21"></a><h2>New advanced API (experimental)</h2><pre></pre>
 
 <pre><b>typedef enum {
     </b>/* Question : should we have a format ZSTD_f_auto ?<b>
@@ -1169,7 +1171,7 @@ size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t
  
 </p></pre><BR>
 
-<a name="Chapter21"></a><h2>Block level API</h2><pre></pre>
+<a name="Chapter22"></a><h2>Block level API</h2><pre></pre>
 
 <pre><b></b><p>    Frame metadata cost is typically ~18 bytes, which can be non-negligible for very small blocks (< 100 bytes).
     User will have to take in charge required information to regenerate data, such as compressed and content sizes.
diff --git a/lib/zstd.h b/lib/zstd.h
index 919d1e2e0..fe37cec8b 100644
--- a/lib/zstd.h
+++ b/lib/zstd.h
@@ -432,12 +432,12 @@ typedef struct {
 
 typedef struct ZSTD_CCtx_params_s ZSTD_CCtx_params;
 
-/*= Custom memory allocation functions */
+/*--- Custom memory allocation functions ---*/
 typedef void* (*ZSTD_allocFunction) (void* opaque, size_t size);
 typedef void  (*ZSTD_freeFunction) (void* opaque, void* address);
 typedef struct { ZSTD_allocFunction customAlloc; ZSTD_freeFunction customFree; void* opaque; } ZSTD_customMem;
 /* use this constant to defer to stdlib's functions */
-static const ZSTD_customMem ZSTD_defaultCMem = { NULL, NULL, NULL };
+static ZSTD_customMem const ZSTD_defaultCMem = { NULL, NULL, NULL };
 
 
 /***************************************
@@ -446,7 +446,7 @@ static const ZSTD_customMem ZSTD_defaultCMem = { NULL, NULL, NULL };
 
 /*! ZSTD_findFrameCompressedSize() :
  *  `src` should point to the start of a ZSTD encoded frame or skippable frame
- *  `srcSize` must be at least as large as the frame
+ *  `srcSize` must be >= first frame size
  *  @return : the compressed size of the first frame starting at `src`,
  *            suitable to pass to `ZSTD_decompress` or similar,
  *            or an error code if input is invalid */
@@ -557,7 +557,8 @@ ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem);
  *             It must outlive context usage.
  *  workspaceSize: Use ZSTD_estimateCCtxSize() or ZSTD_estimateCStreamSize()
  *                 to determine how large workspace must be to support scenario.
- * @return : pointer to ZSTD_CCtx*, or NULL if error (size too small)
+ * @return : pointer to ZSTD_CCtx* (same address as workspace, but different type),
+ *           or NULL if error (typically size too small)
  *  Note : zstd will never resize nor malloc() when using a static cctx.
  *         If it needs more memory than available, it will simply error out.
  *  Note 2 : there is no corresponding "free" function.
@@ -587,7 +588,7 @@ ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_advanced(const void* dict, size_t dictS
                                                   ZSTD_compressionParameters cParams,
                                                   ZSTD_customMem customMem);
 
-/*! ZSTD_initStaticCDict_advanced() :
+/*! ZSTD_initStaticCDict() :
  *  Generate a digested dictionary in provided memory area.
  *  workspace: The memory area to emplace the dictionary into.
  *             Provided pointer must 8-bytes aligned.
@@ -596,7 +597,8 @@ ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_advanced(const void* dict, size_t dictS
  *                 to determine how large workspace must be.
  *  cParams : use ZSTD_getCParams() to transform a compression level
  *            into its relevants cParams.
- * @return : pointer to ZSTD_CDict*, or NULL if error (size too small)
+ * @return : pointer to ZSTD_CDict* (same address as workspace, but different type),
+ *           or NULL if error (typically, size too small).
  *  Note : there is no corresponding "free" function.
  *         Since workspace was allocated externally, it must be freed externally.
  */
@@ -660,7 +662,8 @@ ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem);
  *             It must outlive context usage.
  *  workspaceSize: Use ZSTD_estimateDCtxSize() or ZSTD_estimateDStreamSize()
  *                 to determine how large workspace must be to support scenario.
- * @return : pointer to ZSTD_DCtx*, or NULL if error (size too small)
+ * @return : pointer to ZSTD_DCtx* (same address as workspace, but different type),
+ *           or NULL if error (typically size too small)
  *  Note : zstd will never resize nor malloc() when using a static dctx.
  *         If it needs more memory than available, it will simply error out.
  *  Note 2 : static dctx is incompatible with legacy support
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index 4cdd6235b..b8c437a41 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -209,7 +209,7 @@ static size_t SEQ_generateRoundTrip(ZSTD_CCtx* cctx, ZSTD_DCtx* dctx,
     return 0;
 }
 
-static int basicUnitTests(U32 seed, double compressibility, ZSTD_customMem customMem)
+static int basicUnitTests(U32 seed, double compressibility)
 {
     size_t const CNBufferSize = COMPRESSIBLE_NOISE_LENGTH;
     void* CNBuffer = malloc(CNBufferSize);
@@ -221,8 +221,8 @@ static int basicUnitTests(U32 seed, double compressibility, ZSTD_customMem custo
     size_t cSize;
     int testResult = 0;
     U32 testNb = 1;
-    ZSTD_CStream* zc = ZSTD_createCStream_advanced(customMem);
-    ZSTD_DStream* zd = ZSTD_createDStream_advanced(customMem);
+    ZSTD_CStream* zc = ZSTD_createCStream();
+    ZSTD_DStream* zd = ZSTD_createDStream();
     ZSTDMT_CCtx* mtctx = ZSTDMT_createCCtx(2);
 
     ZSTD_inBuffer  inBuff, inBuff2;
@@ -431,7 +431,7 @@ static int basicUnitTests(U32 seed, double compressibility, ZSTD_customMem custo
     /* Complex context re-use scenario */
     DISPLAYLEVEL(3, "test%3i : context re-use : ", testNb++);
     ZSTD_freeCStream(zc);
-    zc = ZSTD_createCStream_advanced(customMem);
+    zc = ZSTD_createCStream();
     if (zc==NULL) goto _output_error;   /* memory allocation issue */
     /* use 1 */
     {   size_t const inSize = 513;
@@ -548,7 +548,7 @@ static int basicUnitTests(U32 seed, double compressibility, ZSTD_customMem custo
     DISPLAYLEVEL(3, "test%3i : ZSTD_initCStream_usingCDict_advanced with masked dictID : ", testNb++);
     {   ZSTD_compressionParameters const cParams = ZSTD_getCParams(1, CNBufferSize, dictionary.filled);
         ZSTD_frameParameters const fParams = { 1 /* contentSize */, 1 /* checksum */, 1 /* noDictID */};
-        ZSTD_CDict* const cdict = ZSTD_createCDict_advanced(dictionary.start, dictionary.filled, ZSTD_dlm_byRef, ZSTD_dm_auto, cParams, customMem);
+        ZSTD_CDict* const cdict = ZSTD_createCDict_advanced(dictionary.start, dictionary.filled, ZSTD_dlm_byRef, ZSTD_dm_auto, cParams, ZSTD_defaultCMem);
         size_t const initError = ZSTD_initCStream_usingCDict_advanced(zc, cdict, fParams, CNBufferSize);
         if (ZSTD_isError(initError)) goto _output_error;
         cSize = 0;
@@ -1702,24 +1702,23 @@ typedef enum { simple_api, mt_api, advanced_api } e_api;
 
 int main(int argc, const char** argv)
 {
-    U32 seed=0;
-    int seedset=0;
-    int argNb;
+    U32 seed = 0;
+    int seedset = 0;
     int nbTests = nbTestsDefault;
     int testNb = 0;
     int proba = FUZ_COMPRESSIBILITY_DEFAULT;
-    int result=0;
+    int result = 0;
     int mainPause = 0;
     int bigTests = (sizeof(size_t) == 8);
     e_api selected_api = simple_api;
     const char* const programName = argv[0];
-    ZSTD_customMem const customNULL = ZSTD_defaultCMem;
     U32 useOpaqueAPI = 0;
+    int argNb;
 
     /* Check command line */
     for(argNb=1; argNb<argc; argNb++) {
         const char* argument = argv[argNb];
-        if(!argument) continue;   /* Protection if argument empty */
+        assert(argument != NULL);
 
         /* Parsing commands. Aggregated commands are allowed */
         if (argument[0]=='-') {
@@ -1769,15 +1768,17 @@ int main(int argc, const char** argv)
                         g_clockTime += *argument - '0';
                         argument++;
                     }
-                    if (*argument=='m') g_clockTime *=60, argument++;
-                    if (*argument=='n') argument++;
+                    if (*argument=='m') {    /* -T1m == -T60 */
+                        g_clockTime *=60, argument++;
+                        if (*argument=='n') argument++; /* -T1mn == -T60 */
+                    } else if (*argument=='s') argument++; /* -T10s == -T10 */
                     g_clockTime *= CLOCKS_PER_SEC;
                     break;
 
                 case 's':   /* manually select seed */
                     argument++;
-                    seed=0;
                     seedset=1;
+                    seed=0;
                     while ((*argument>='0') && (*argument<='9')) {
                         seed *= 10;
                         seed += *argument - '0';
@@ -1827,7 +1828,7 @@ int main(int argc, const char** argv)
     if (nbTests<=0) nbTests=1;
 
     if (testNb==0) {
-        result = basicUnitTests(0, ((double)proba) / 100, customNULL);  /* constant seed for predictability */
+        result = basicUnitTests(0, ((double)proba) / 100);  /* constant seed for predictability */
     }
 
     if (!result) {

From 743b23878eaa5c71c019a70327d52d95c6016b62 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Mon, 27 Nov 2017 13:47:35 -0800
Subject: [PATCH 080/145] install: changed variable MANDIR into MAN1DIR

MANDIR still exists, and is now the parent of MAN1DIR
---
 programs/Makefile | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/programs/Makefile b/programs/Makefile
index e1c5f50b6..37788db39 100644
--- a/programs/Makefile
+++ b/programs/Makefile
@@ -65,6 +65,7 @@ endif
 else
 endif
 
+# Sort files in alphabetical order for reproducible builds
 ZSTDLIB_FILES := $(sort $(wildcard $(ZSTD_FILES)) $(wildcard $(ZSTDLEGACY_FILES)) $(wildcard $(ZDICT_FILES)))
 
 # Define *.exe as extension for Windows systems
@@ -262,9 +263,10 @@ mandir      ?= $(datarootdir)/man
 man1dir     ?= $(mandir)/man1
 
 ifneq (,$(filter $(shell uname),OpenBSD FreeBSD NetBSD DragonFly SunOS))
-MANDIR  ?= $(PREFIX)/man/man1
+MANDIR  ?= $(PREFIX)/man
+MAN1DIR ?= $(MANDIR)/man1
 else
-MANDIR  ?= $(man1dir)
+MAN1DIR ?= $(man1dir)
 endif
 
 ifneq (,$(filter $(shell uname),SunOS))
@@ -281,7 +283,7 @@ INSTALL_MAN     ?= $(INSTALL_DATA)
 .PHONY: install
 install: zstd
 	@echo Installing binaries
-	@$(INSTALL) -d -m 755 $(DESTDIR)$(BINDIR)/ $(DESTDIR)$(MANDIR)/
+	@$(INSTALL) -d -m 755 $(DESTDIR)$(BINDIR)/ $(DESTDIR)$(MAN1DIR)/
 	@$(INSTALL_PROGRAM) zstd $(DESTDIR)$(BINDIR)/zstd
 	@ln -sf zstd $(DESTDIR)$(BINDIR)/zstdcat
 	@ln -sf zstd $(DESTDIR)$(BINDIR)/unzstd
@@ -289,9 +291,9 @@ install: zstd
 	@$(INSTALL_SCRIPT) zstdless $(DESTDIR)$(BINDIR)/zstdless
 	@$(INSTALL_SCRIPT) zstdgrep $(DESTDIR)$(BINDIR)/zstdgrep
 	@echo Installing man pages
-	@$(INSTALL_MAN) zstd.1 $(DESTDIR)$(MANDIR)/zstd.1
-	@ln -sf zstd.1 $(DESTDIR)$(MANDIR)/zstdcat.1
-	@ln -sf zstd.1 $(DESTDIR)$(MANDIR)/unzstd.1
+	@$(INSTALL_MAN) zstd.1 $(DESTDIR)$(MAN1DIR)/zstd.1
+	@ln -sf zstd.1 $(DESTDIR)$(MAN1DIR)/zstdcat.1
+	@ln -sf zstd.1 $(DESTDIR)$(MAN1DIR)/unzstd.1
 	@echo zstd installation completed
 
 .PHONY: uninstall
@@ -301,9 +303,9 @@ uninstall:
 	@$(RM) $(DESTDIR)$(BINDIR)/zstdcat
 	@$(RM) $(DESTDIR)$(BINDIR)/unzstd
 	@$(RM) $(DESTDIR)$(BINDIR)/zstd
-	@$(RM) $(DESTDIR)$(MANDIR)/zstdcat.1
-	@$(RM) $(DESTDIR)$(MANDIR)/unzstd.1
-	@$(RM) $(DESTDIR)$(MANDIR)/zstd.1
+	@$(RM) $(DESTDIR)$(MAN1DIR)/zstdcat.1
+	@$(RM) $(DESTDIR)$(MAN1DIR)/unzstd.1
+	@$(RM) $(DESTDIR)$(MAN1DIR)/zstd.1
 	@echo zstd programs successfully uninstalled
 
 endif

From e9d1987fd7bbeb669fe23a6f396159b4579c9d21 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Mon, 27 Nov 2017 17:01:51 -0800
Subject: [PATCH 081/145] btopt: minor speed optimization

matchPrice is always right at beginning
---
 lib/compress/zstd_opt.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index 66a7da19c..459fe6571 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -523,14 +523,11 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                     U32 const offset = matches[matchNb].off;
                     U32 const end = matches[matchNb].len;
                     repcodes_t const repHistory = ZSTD_updateRep(rep, offset, ll0);
-                    while (pos <= end) {
+                    for ( ; pos <= end ; pos++) {
                         U32 const matchPrice = ZSTD_getPrice(optStatePtr, litlen, anchor, offset, pos, optLevel);
-                        if (pos > last_pos || matchPrice < opt[pos].price) {
-                            DEBUGLOG(7, "rPos:%u => set initial price : %u",
-                                        pos, matchPrice);
-                            SET_PRICE(pos, pos, offset, litlen, matchPrice, repHistory);   /* note : macro modifies last_pos */
-                        }
-                        pos++;
+                        DEBUGLOG(7, "rPos:%u => set initial price : %u",
+                                    pos, matchPrice);
+                        SET_PRICE(pos, pos, offset, litlen, matchPrice, repHistory);   /* note : macro modifies last_pos */
             }   }   }
         }
 

From eee87cd6f20522d34db862ec9ef000572c26164a Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Mon, 27 Nov 2017 17:13:59 -0800
Subject: [PATCH 082/145] btopt: minor refactor : removed one SET_PRICE() macro
 invocation

direct assignment makes operation cleaner.
Also allows some (very minor) optimization (non-measurable)
---
 lib/compress/zstd_opt.c | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index 459fe6571..c1ebea4d9 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -517,18 +517,28 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
             }   }
 
             /* set prices for first matches starting position == 0 */
-            {   U32 pos = minMatch;
+            {   U32 pos;
                 U32 matchNb;
+                for (pos = 0; pos < minMatch; pos++) {
+                    opt[pos].mlen = 1;
+                    opt[pos].price = ZSTD_MAX_PRICE;
+                }
                 for (matchNb = 0; matchNb < nbMatches; matchNb++) {
                     U32 const offset = matches[matchNb].off;
                     U32 const end = matches[matchNb].len;
                     repcodes_t const repHistory = ZSTD_updateRep(rep, offset, ll0);
-                    for ( ; pos <= end ; pos++) {
+                    for ( ; pos <= end ; pos++ ) {
                         U32 const matchPrice = ZSTD_getPrice(optStatePtr, litlen, anchor, offset, pos, optLevel);
                         DEBUGLOG(7, "rPos:%u => set initial price : %u",
                                     pos, matchPrice);
-                        SET_PRICE(pos, pos, offset, litlen, matchPrice, repHistory);   /* note : macro modifies last_pos */
-            }   }   }
+                        opt[pos].mlen = pos;
+                        opt[pos].off = offset;
+                        opt[pos].litlen = litlen;
+                        opt[pos].price = matchPrice;
+                        memcpy(opt[pos].rep, &repHistory, sizeof(repHistory));
+                }   }
+                last_pos = pos-1;
+            }
         }
 
         /* check further positions */

From 62c746dcf90c9f69f404df08533795d72083361d Mon Sep 17 00:00:00 2001
From: "W. Felix Handte" <w@felixhandte.com>
Date: Tue, 28 Nov 2017 12:06:48 -0500
Subject: [PATCH 083/145] Add Test on LZ4 Format Input Buffer Overrun

---
 tests/Makefile | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/tests/Makefile b/tests/Makefile
index 11d55a75d..f944fd5a8 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -374,9 +374,9 @@ test-pool: poolTests
 test-lz4: ZSTD = LD_LIBRARY_PATH=/usr/local/lib $(PRGDIR)/zstd
 test-lz4: ZSTD_LZ4 = LD_LIBRARY_PATH=/usr/local/lib ./lz4
 test-lz4: ZSTD_UNLZ4 = LD_LIBRARY_PATH=/usr/local/lib ./unlz4
-test-lz4: zstd decodecorpus
-	ln -s $(PRGDIR)/zstd lz4
-	ln -s $(PRGDIR)/zstd unlz4
+test-lz4: zstd decodecorpus datagen
+	[ -f lz4 ] || ln -s $(PRGDIR)/zstd lz4
+	[ -f unlz4 ] || ln -s $(PRGDIR)/zstd unlz4
 
 	./decodecorpus -ptmp
 	# lz4 -> zstd
@@ -402,6 +402,8 @@ test-lz4: zstd decodecorpus
 	$(ZSTD) -d | \
 	cmp - tmp
 
+	./datagen -g384KB | $(ZSTD) --format=lz4 | $(ZSTD) -d > /dev/null
+
 	rm tmp lz4 unlz4
 
 endif

From baff9dd15eb65eaf54f0dee9ee5fadc9ce16d6ab Mon Sep 17 00:00:00 2001
From: "W. Felix Handte" <w@felixhandte.com>
Date: Tue, 17 Oct 2017 01:19:29 -0400
Subject: [PATCH 084/145] Fix LZ4 Compression Buffer Overflow

Fixes issue where, when `zstd --format=lz4` is fed an input larger than 128KB,
the read overruns the input buffer. This changes Zstd to use LZ4 with chained
64KB blocks. This is technically a breaking change in that some third party
LZ4 implementations may not support linked blocks. However, progress should not
be allowed to be stopped by such petty concerns as backwards compatibility!
---
 programs/fileio.c | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/programs/fileio.c b/programs/fileio.c
index 8bee6086c..eb004f916 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -616,11 +616,16 @@ static unsigned long long FIO_compressLzmaFrame(cRess_t* ress,
 #endif
 
 #ifdef ZSTD_LZ4COMPRESS
+#if LZ4_VERSION_NUMBER <= 10600
+#define LZ4F_blockLinked blockLinked
+#define LZ4F_max64KB max64KB
+#endif
 static int FIO_LZ4_GetBlockSize_FromBlockId (int id) { return (1 << (8 + (2 * id))); }
 static unsigned long long FIO_compressLz4Frame(cRess_t* ress,
                             const char* srcFileName, U64 const srcFileSize,
                             int compressionLevel, U64* readsize)
 {
+    const size_t blockSize = FIO_LZ4_GetBlockSize_FromBlockId(LZ4F_max64KB);
     unsigned long long inFileSize = 0, outFileSize = 0;
 
     LZ4F_preferences_t prefs;
@@ -632,21 +637,19 @@ static unsigned long long FIO_compressLz4Frame(cRess_t* ress,
 
     memset(&prefs, 0, sizeof(prefs));
 
-#if LZ4_VERSION_NUMBER <= 10600
-#define LZ4F_blockIndependent blockIndependent
-#define LZ4F_max4MB max4MB
-#endif
+    assert(blockSize <= ress->srcBufferSize);
+    assert(LZ4F_compressBound(blockSize) <= ress->dstBufferSize);
 
     prefs.autoFlush = 1;
     prefs.compressionLevel = compressionLevel;
-    prefs.frameInfo.blockMode = LZ4F_blockIndependent; /* stick to defaults for lz4 cli */
-    prefs.frameInfo.blockSizeID = LZ4F_max4MB;
+    prefs.frameInfo.blockMode = LZ4F_blockLinked;
+    prefs.frameInfo.blockSizeID = LZ4F_max64KB;
     prefs.frameInfo.contentChecksumFlag = (contentChecksum_t)g_checksumFlag;
 #if LZ4_VERSION_NUMBER >= 10600
     prefs.frameInfo.contentSize = (srcFileSize==UTIL_FILESIZE_UNKNOWN) ? 0 : srcFileSize;
 #endif
 
-    {   size_t blockSize = FIO_LZ4_GetBlockSize_FromBlockId(LZ4F_max4MB);
+    {
         size_t readSize;
         size_t headerSize = LZ4F_compressBegin(ctx, ress->dstBuffer, ress->dstBufferSize, &prefs);
         if (LZ4F_isError(headerSize))

From 03f30d9dcbb8c20fc239d4a10b5df377ea8dc532 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 28 Nov 2017 12:14:46 -0800
Subject: [PATCH 085/145] separate rawLiterals, fullLiterals and match costs

removed one SET_PRICE() macro invocation
---
 lib/compress/zstd_opt.c | 120 ++++++++++++++++++++++++++++++++++++----
 1 file changed, 110 insertions(+), 10 deletions(-)

diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index c1ebea4d9..83696f64d 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -96,6 +96,55 @@ static void ZSTD_rescaleFreqs(optState_t* optPtr, const BYTE* src, size_t srcSiz
 }
 
 
+static U32 ZSTD_rawLiteralsCost(const optState_t* const optPtr,
+                                 const BYTE* const literals, U32 const litLength)
+{
+    if (optPtr->staticPrices) return (litLength*6);  /* 6 bit per literal - no statistic used */
+    if (litLength == 0) return 0;
+
+    /* literals */
+    {   U32 u;
+        U32 cost = litLength * optPtr->log2litSum;
+        for (u=0; u < litLength; u++)
+            cost -= ZSTD_highbit32(optPtr->litFreq[literals[u]]+1);
+        return cost;
+    }
+}
+
+static U32 ZSTD_litLengthPrice(const optState_t* const optPtr, U32 const litLength)
+{
+    if (optPtr->staticPrices) return ZSTD_highbit32((U32)litLength+1);
+
+    /* literal Length */
+    {   U32 const llCode = ZSTD_LLcode(litLength);
+        U32 const price = LL_bits[llCode] + optPtr->log2litLengthSum - ZSTD_highbit32(optPtr->litLengthFreq[llCode]+1);
+        return price;
+    }
+}
+
+static U32 ZSTD_fullLiteralsCost(const optState_t* const optPtr,
+                                 const BYTE* const literals, U32 const litLength)
+{
+    return ZSTD_rawLiteralsCost(optPtr, literals, litLength) + ZSTD_litLengthPrice(optPtr, litLength);
+}
+
+static U32 ZSTD_updateRawLiteralsCost(const optState_t* const optPtr,
+                            U32 const previousCost,
+                            const BYTE* const literals, U32 const litLength)
+{
+    return previousCost + ZSTD_rawLiteralsCost(optPtr, literals, litLength);
+}
+
+static U32 ZSTD_newLiteralsCost(const optState_t* const optPtr,
+                                U32 const previousCost, BYTE const newLiteral)
+{
+    return previousCost
+         + optPtr->log2litSum - ZSTD_highbit32(optPtr->litFreq[newLiteral]+1);
+}
+
+
+
+
 static U32 ZSTD_getLiteralPrice(optState_t* const optPtr,
                                 U32 const litLength, const BYTE* const literals)
 {
@@ -139,10 +188,10 @@ static U32 ZSTD_getLiteralPrice(optState_t* const optPtr,
 }
 
 
-/* ZSTD_getPrice() :
+/* ZSTD_getMatchPrice() :
  * optLevel: when <2, favors small offset for decompression speed (improved cache efficiency) */
-FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr,
-                                    U32 const litLength, const BYTE* const literals, U32 const offset, U32 const matchLength,
+FORCE_INLINE_TEMPLATE U32 ZSTD_getMatchPrice(optState_t* optPtr,
+                                    U32 const offset, U32 const matchLength,
                                     int const optLevel)
 {
     U32 price;
@@ -151,7 +200,7 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr,
     assert(matchLength >= MINMATCH);
 
     if (optPtr->staticPrices)  /* fixed scheme, do not use statistics */
-        return ZSTD_getLiteralPrice(optPtr, litLength, literals) + ZSTD_highbit32((U32)mlBase+1) + 16 + offCode;
+        return ZSTD_highbit32((U32)mlBase+1) + 16 + offCode;
 
     price = offCode + optPtr->log2offCodeSum - ZSTD_highbit32(optPtr->offCodeFreq[offCode]+1);
     if ((optLevel<2) /*static*/ && offCode >= 20) price += (offCode-19)*2; /* handicap for long distance offsets, favor decompression speed */
@@ -161,7 +210,18 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr,
         price += ML_bits[mlCode] + optPtr->log2matchLengthSum - ZSTD_highbit32(optPtr->matchLengthFreq[mlCode]+1);
     }
 
-    price += ZSTD_getLiteralPrice(optPtr, litLength, literals) + optPtr->factor;
+    price += + optPtr->factor;
+    DEBUGLOG(8, "ZSTD_getMatchPrice(ml:%u) = %u", matchLength, price);
+    return price;
+}
+
+/* ZSTD_getPrice() :
+ * optLevel: when <2, favors small offset for decompression speed (improved cache efficiency) */
+FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr,
+                                    U32 const litLength, const BYTE* const literals, U32 const offset, U32 const matchLength,
+                                    int const optLevel)
+{
+    U32 const price = ZSTD_getLiteralPrice(optPtr, litLength, literals) + ZSTD_getMatchPrice(optPtr, offset, matchLength, optLevel);
     DEBUGLOG(8, "ZSTD_getPrice(ll:%u, ml:%u) = %u", litLength, matchLength, price);
     return price;
 }
@@ -454,6 +514,39 @@ repcodes_t ZSTD_updateRep(U32 const rep[3], U32 const offset, U32 const ll0)
         memcpy(opt[pos].rep, &rep_, sizeof(rep_));            \
     }
 
+typedef struct {
+    const BYTE* anchor;
+    U32 litlen;
+    U32 rawLitCost;
+} cachedLiteralPrice_t;
+
+static U32 ZSTD_updateCachedLPrice(const optState_t* const optStatePtr,
+                            cachedLiteralPrice_t* const cachedLitPrice,
+                            const BYTE* const anchor, U32 const litlen)
+{
+    U32 startCost;
+    U32 remainingLength;
+    const BYTE* startPosition;
+
+    if (anchor == cachedLitPrice->anchor) {
+        startCost = cachedLitPrice->rawLitCost;
+        startPosition = anchor + cachedLitPrice->litlen;
+        assert(litlen >= cachedLitPrice->litlen);
+        remainingLength = litlen - cachedLitPrice->litlen;
+    } else {
+        startCost = 0;
+        startPosition = anchor;
+        remainingLength = litlen;
+    }
+
+    {   U32 const rawLitCost = startCost + ZSTD_rawLiteralsCost(optStatePtr, startPosition, remainingLength);
+        cachedLitPrice->anchor = anchor;
+        cachedLitPrice->litlen = litlen;
+        cachedLitPrice->rawLitCost = rawLitCost;
+        return rawLitCost + ZSTD_litLengthPrice(optStatePtr, litlen);
+    }
+}
+
 FORCE_INLINE_TEMPLATE
 size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                                       const void* src, size_t srcSize,
@@ -476,6 +569,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
 
     ZSTD_optimal_t* const opt = optStatePtr->priceTable;
     ZSTD_match_t* const matches = optStatePtr->matchTable;
+    cachedLiteralPrice_t cachedLitPrice;
     U32 rep[ZSTD_REP_NUM];
 
     /* init */
@@ -484,6 +578,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
     ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize);
     ip += (ip==prefixStart);
     { int i; for (i=0; i<ZSTD_REP_NUM; i++) rep[i]=seqStorePtr->rep[i]; }
+    memset(&cachedLitPrice, 0, sizeof(cachedLitPrice));
 
     /* Match Loop */
     while (ip < ilimit) {
@@ -517,7 +612,8 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
             }   }
 
             /* set prices for first matches starting position == 0 */
-            {   U32 pos;
+            {   U32 const literalsPrice = ZSTD_updateCachedLPrice(optStatePtr, &cachedLitPrice, anchor, litlen);
+                U32 pos;
                 U32 matchNb;
                 for (pos = 0; pos < minMatch; pos++) {
                     opt[pos].mlen = 1;
@@ -528,7 +624,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                     U32 const end = matches[matchNb].len;
                     repcodes_t const repHistory = ZSTD_updateRep(rep, offset, ll0);
                     for ( ; pos <= end ; pos++ ) {
-                        U32 const matchPrice = ZSTD_getPrice(optStatePtr, litlen, anchor, offset, pos, optLevel);
+                        U32 const matchPrice = literalsPrice + ZSTD_getMatchPrice(optStatePtr, offset, pos, optLevel);
                         DEBUGLOG(7, "rPos:%u => set initial price : %u",
                                     pos, matchPrice);
                         opt[pos].mlen = pos;
@@ -550,14 +646,18 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
             {   U32 const litlen = (opt[cur-1].mlen == 1) ? opt[cur-1].litlen + 1 : 1;
                 U32 price;
                 if (cur > litlen) {
-                    price = opt[cur - litlen].price + ZSTD_getLiteralPrice(optStatePtr, litlen, inr-litlen);
+                    price = opt[cur - litlen].price + ZSTD_fullLiteralsCost(optStatePtr, inr-litlen, litlen);
                 } else {
-                    price = ZSTD_getLiteralPrice(optStatePtr, litlen, anchor);
+                    price = ZSTD_updateCachedLPrice(optStatePtr, &cachedLitPrice, anchor, litlen);
                 }
                 if (price <= opt[cur].price) {
                     DEBUGLOG(7, "rPos:%u : better price (%u<%u) using literal",
                                 cur, price, opt[cur].price);
-                    SET_PRICE(cur, 1/*mlen*/, 0/*offset*/, litlen, price, opt[cur-1].rep);
+                    opt[cur].mlen = 1;
+                    opt[cur].off = 0;
+                    opt[cur].litlen = litlen;
+                    opt[cur].price = price;
+                    memcpy(opt[cur].rep, opt[cur-1].rep, sizeof(opt[cur].rep));
             }   }
 
             /* last match must start at a minimum distance of 8 from oend */

From b71405dc51cd6fb05ea2417ac6ed0516ef24d2f0 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 28 Nov 2017 12:32:24 -0800
Subject: [PATCH 086/145] removed a bunch of code related to cached literal
 price

optState was used both to evaluate price
and to cache cost of previously calculated literals.
This created a strong dependency, forcing parser to request cost in a strict order.
This limitation is forbids future parser with skipping capabilities.

After this patch, caching literals price still exists,
but is now explicit, in a stack structure.
---
 lib/compress/zstd_compress_internal.h |   3 -
 lib/compress/zstd_opt.c               | 115 +++++---------------------
 2 files changed, 22 insertions(+), 96 deletions(-)

diff --git a/lib/compress/zstd_compress_internal.h b/lib/compress/zstd_compress_internal.h
index 4fd55c438..e33ec4086 100644
--- a/lib/compress/zstd_compress_internal.h
+++ b/lib/compress/zstd_compress_internal.h
@@ -93,9 +93,6 @@ typedef struct {
     U32  factor;                 /* fixed cost added when calculating ZSTD_getPrice() (but why ? seems to favor less sequences) */
     /* end : updated by ZSTD_setLog2Prices */
     U32  staticPrices;           /* prices follow a pre-defined cost structure, statistics are irrelevant */
-    U32  cachedPrice;
-    U32  cachedLitLength;
-    const BYTE* cachedLiterals;
 } optState_t;
 
 typedef struct {
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index 83696f64d..fe52fed58 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -32,10 +32,9 @@ static void ZSTD_setLog2Prices(optState_t* optPtr)
 }
 
 
-static void ZSTD_rescaleFreqs(optState_t* optPtr, const BYTE* src, size_t srcSize)
+static void ZSTD_rescaleFreqs(optState_t* const optPtr,
+                              const BYTE* const src, size_t const srcSize)
 {
-    optPtr->cachedLiterals = NULL;
-    optPtr->cachedPrice = optPtr->cachedLitLength = 0;
     optPtr->staticPrices = 0;
 
     if (optPtr->litLengthSum == 0) {  /* first init */
@@ -97,7 +96,7 @@ static void ZSTD_rescaleFreqs(optState_t* optPtr, const BYTE* src, size_t srcSiz
 
 
 static U32 ZSTD_rawLiteralsCost(const optState_t* const optPtr,
-                                 const BYTE* const literals, U32 const litLength)
+                                const BYTE* const literals, U32 const litLength)
 {
     if (optPtr->staticPrices) return (litLength*6);  /* 6 bit per literal - no statistic used */
     if (litLength == 0) return 0;
@@ -128,69 +127,10 @@ static U32 ZSTD_fullLiteralsCost(const optState_t* const optPtr,
     return ZSTD_rawLiteralsCost(optPtr, literals, litLength) + ZSTD_litLengthPrice(optPtr, litLength);
 }
 
-static U32 ZSTD_updateRawLiteralsCost(const optState_t* const optPtr,
-                            U32 const previousCost,
-                            const BYTE* const literals, U32 const litLength)
-{
-    return previousCost + ZSTD_rawLiteralsCost(optPtr, literals, litLength);
-}
-
-static U32 ZSTD_newLiteralsCost(const optState_t* const optPtr,
-                                U32 const previousCost, BYTE const newLiteral)
-{
-    return previousCost
-         + optPtr->log2litSum - ZSTD_highbit32(optPtr->litFreq[newLiteral]+1);
-}
-
-
-
-
-static U32 ZSTD_getLiteralPrice(optState_t* const optPtr,
-                                U32 const litLength, const BYTE* const literals)
-{
-    U32 price;
-
-    if (optPtr->staticPrices)
-        return ZSTD_highbit32((U32)litLength+1) + (litLength*6);  /* 6 bit per literal - no statistic used */
-
-    if (litLength == 0)
-        return optPtr->log2litLengthSum - ZSTD_highbit32(optPtr->litLengthFreq[0]+1);
-
-    /* literals */
-    if (optPtr->cachedLiterals == literals) {
-        U32 u;
-        U32 const additional = litLength - optPtr->cachedLitLength;
-        const BYTE* const literals2 = optPtr->cachedLiterals + optPtr->cachedLitLength;
-        price = optPtr->cachedPrice + additional * optPtr->log2litSum;
-        for (u=0; u < additional; u++)
-            price -= ZSTD_highbit32(optPtr->litFreq[literals2[u]]+1);
-        optPtr->cachedPrice = price;
-        optPtr->cachedLitLength = litLength;
-    } else {
-        U32 u;
-        price = litLength * optPtr->log2litSum;
-        for (u=0; u < litLength; u++)
-            price -= ZSTD_highbit32(optPtr->litFreq[literals[u]]+1);
-
-        if (litLength >= 12) {
-            optPtr->cachedLiterals = literals;
-            optPtr->cachedPrice = price;
-            optPtr->cachedLitLength = litLength;
-        }
-    }
-
-    /* literal Length */
-    {   U32 const llCode = ZSTD_LLcode(litLength);
-        price += LL_bits[llCode] + optPtr->log2litLengthSum - ZSTD_highbit32(optPtr->litLengthFreq[llCode]+1);
-    }
-
-    return price;
-}
-
 
 /* ZSTD_getMatchPrice() :
  * optLevel: when <2, favors small offset for decompression speed (improved cache efficiency) */
-FORCE_INLINE_TEMPLATE U32 ZSTD_getMatchPrice(optState_t* optPtr,
+FORCE_INLINE_TEMPLATE U32 ZSTD_getMatchPrice(const optState_t* const optPtr,
                                     U32 const offset, U32 const matchLength,
                                     int const optLevel)
 {
@@ -210,24 +150,14 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_getMatchPrice(optState_t* optPtr,
         price += ML_bits[mlCode] + optPtr->log2matchLengthSum - ZSTD_highbit32(optPtr->matchLengthFreq[mlCode]+1);
     }
 
-    price += + optPtr->factor;
+    price += optPtr->factor;
     DEBUGLOG(8, "ZSTD_getMatchPrice(ml:%u) = %u", matchLength, price);
     return price;
 }
 
-/* ZSTD_getPrice() :
- * optLevel: when <2, favors small offset for decompression speed (improved cache efficiency) */
-FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr,
-                                    U32 const litLength, const BYTE* const literals, U32 const offset, U32 const matchLength,
-                                    int const optLevel)
-{
-    U32 const price = ZSTD_getLiteralPrice(optPtr, litLength, literals) + ZSTD_getMatchPrice(optPtr, offset, matchLength, optLevel);
-    DEBUGLOG(8, "ZSTD_getPrice(ll:%u, ml:%u) = %u", litLength, matchLength, price);
-    return price;
-}
-
-
-static void ZSTD_updateStats(optState_t* optPtr, U32 litLength, const BYTE* literals, U32 offsetCode, U32 matchLength)
+static void ZSTD_updateStats(optState_t* const optPtr,
+                            U32 litLength, const BYTE* literals,
+                            U32 offsetCode, U32 matchLength)
 {
     /* literals */
     {   U32 u;
@@ -275,13 +205,13 @@ MEM_STATIC U32 ZSTD_readMINMATCH(const void* memPtr, U32 length)
 
 /* Update hashTable3 up to ip (excluded)
    Assumption : always within prefix (i.e. not within extDict) */
-static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* zc, const BYTE* ip)
+static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* const cctx, const BYTE* const ip)
 {
-    U32* const hashTable3  = zc->hashTable3;
-    U32 const hashLog3  = zc->hashLog3;
-    const BYTE* const base = zc->base;
-    U32 idx = zc->nextToUpdate3;
-    U32 const target = zc->nextToUpdate3 = (U32)(ip - base);
+    U32* const hashTable3  = cctx->hashTable3;
+    U32 const hashLog3  = cctx->hashLog3;
+    const BYTE* const base = cctx->base;
+    U32 idx = cctx->nextToUpdate3;
+    U32 const target = cctx->nextToUpdate3 = (U32)(ip - base);
     size_t const hash3 = ZSTD_hash3Ptr(ip, hashLog3);
 
     while(idx < target) {
@@ -298,11 +228,11 @@ static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* zc, const BYTE* ip)
 ***************************************/
 FORCE_INLINE_TEMPLATE
 U32 ZSTD_insertBtAndGetAllMatches (
-                        ZSTD_CCtx* zc,
-                        const BYTE* const ip, const BYTE* const iLimit, const int extDict,
-                        U32 nbCompares, U32 const mls, U32 const sufficient_len,
-                        U32 rep[ZSTD_REP_NUM], U32 const ll0,
-                        ZSTD_match_t* matches, const U32 lengthToBeat)
+                    ZSTD_CCtx* zc,
+                    const BYTE* const ip, const BYTE* const iLimit, int const extDict,
+                    U32 nbCompares, U32 const mls, U32 const sufficient_len,
+                    U32 rep[ZSTD_REP_NUM], U32 const ll0,
+                    ZSTD_match_t* matches, const U32 lengthToBeat)
 {
     const BYTE* const base = zc->base;
     U32 const current = (U32)(ip-base);
@@ -671,12 +601,11 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
 
             {   U32 const ll0 = (opt[cur].mlen != 1);
                 U32 const litlen = (opt[cur].mlen == 1) ? opt[cur].litlen : 0;
-                U32 const basePrice = (cur > litlen) ? opt[cur-litlen].price : 0;
-                const BYTE* const baseLiterals = ip + cur - litlen;
+                U32 const previousPrice = (cur > litlen) ? opt[cur-litlen].price : 0;
+                U32 const basePrice = previousPrice + ZSTD_fullLiteralsCost(optStatePtr, inr-litlen, litlen);
                 U32 const nbMatches = ZSTD_BtGetAllMatches(ctx, inr, iend, extDict, maxSearches, mls, sufficient_len, opt[cur].rep, ll0, matches, minMatch);
                 U32 matchNb;
                 if (!nbMatches) continue;
-                assert(baseLiterals >= prefixStart);
 
                 {   U32 const maxML = matches[nbMatches-1].len;
                     DEBUGLOG(7, "rPos:%u, found %u matches, of maxLength=%u",
@@ -704,7 +633,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
 
                     for (mlen = lastML; mlen >= startML; mlen--) {
                         U32 const pos = cur + mlen;
-                        U32 const price = basePrice + ZSTD_getPrice(optStatePtr, litlen, baseLiterals, offset, mlen, optLevel);
+                        U32 const price = basePrice + ZSTD_getMatchPrice(optStatePtr, offset, mlen, optLevel);
 
                         if ((pos > last_pos) || (price < opt[pos].price)) {
                             DEBUGLOG(7, "rPos:%u => new better price (%u<%u)",

From 0a0a21293436a5f19e3fc79b1e4d69dc3acabc1b Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 28 Nov 2017 14:07:03 -0800
Subject: [PATCH 087/145] zstd_opt: changed cost formula

There was a flaw in the formula
which compared literal cost with match cost :
at a given position,
a non-null literal suite is going to be part of next sequence,
while if position ends a previous match, to immediately start another match,
next sequence will have a litlength of zero.
A litlength of zero has a non-null cost.
It follows that literals cost should be compared to match cost + litlength==0.

Not doing so gave a structural advantage to matches, which would be selected more often.
I believe that's what led to the creation of the strange heuristic which added a complex cost to matches.
The heuristic was actually compensating.
It was probably created through multiple trials, settling for best outcome on a given scenario (I suspect silesia.tar).
The problem with this heuristic is that it's hard to understand,
and unfortunately, any future change in the parser would impact the way it should be calculated and its effects.

The "proper" formula makes it possible to remove this heuristic.

Now, the problem is : in a head to head comparison, it's sometimes better, sometimes worse.
Note that all differences are small (< 0.01 ratio).
In general, the newer formula is better for smaller files (for example, calgary.tar and enwik7).
I suspect that's because starting statistics are pretty poor (another area of improvement).
However, for silesia.tar specifically, it's worse at level 22 (while being better at level 17, so even compression level has an impact ...).

It's a pity that zstd -22 gets worse on silesia.tar.
That being said, I like that the new code gets rid of strange variables,
which were introducing complexity for any future evolution (faster variants being in mind).
Therefore, in spite of this detrimental side effect, I tend to be in favor of it.
---
 lib/common/zstd_internal.h            |  6 +-
 lib/compress/zstd_compress_internal.h |  4 +-
 lib/compress/zstd_opt.c               | 92 +++++++++++++++++++--------
 programs/bench.c                      |  2 +-
 4 files changed, 71 insertions(+), 33 deletions(-)

diff --git a/lib/common/zstd_internal.h b/lib/common/zstd_internal.h
index 01d343da6..2f8124825 100644
--- a/lib/common/zstd_internal.h
+++ b/lib/common/zstd_internal.h
@@ -253,16 +253,14 @@ MEM_STATIC U32 ZSTD_highbit32(U32 val)   /* compress, dictBuilder, decodeCorpus
 #   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* GCC Intrinsic */
         return 31 - __builtin_clz(val);
 #   else   /* Software version */
-        static const int DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
+        static const U32 DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
         U32 v = val;
-        int r;
         v |= v >> 1;
         v |= v >> 2;
         v |= v >> 4;
         v |= v >> 8;
         v |= v >> 16;
-        r = DeBruijnClz[(U32)(v * 0x07C4ACDDU) >> 27];
-        return r;
+        return DeBruijnClz[(v * 0x07C4ACDDU) >> 27];
 #   endif
     }
 }
diff --git a/lib/compress/zstd_compress_internal.h b/lib/compress/zstd_compress_internal.h
index e33ec4086..1308541f4 100644
--- a/lib/compress/zstd_compress_internal.h
+++ b/lib/compress/zstd_compress_internal.h
@@ -64,7 +64,7 @@ typedef struct {
 } ZSTD_match_t;
 
 typedef struct {
-    U32 price;
+    int price;
     U32 off;
     U32 mlen;
     U32 litlen;
@@ -83,14 +83,12 @@ typedef struct {
     U32  litSum;                 /* nb of literals */
     U32  litLengthSum;           /* nb of litLength codes */
     U32  matchLengthSum;         /* nb of matchLength codes */
-    U32  matchSum;               /* a strange argument used in calculating `factor` */
     U32  offCodeSum;             /* nb of offset codes */
     /* begin updated by ZSTD_setLog2Prices */
     U32  log2litSum;             /* pow2 to compare log2(litfreq) to */
     U32  log2litLengthSum;       /* pow2 to compare log2(llfreq) to */
     U32  log2matchLengthSum;     /* pow2 to compare log2(mlfreq) to */
     U32  log2offCodeSum;         /* pow2 to compare log2(offreq) to */
-    U32  factor;                 /* fixed cost added when calculating ZSTD_getPrice() (but why ? seems to favor less sequences) */
     /* end : updated by ZSTD_setLog2Prices */
     U32  staticPrices;           /* prices follow a pre-defined cost structure, statistics are irrelevant */
 } optState_t;
diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index fe52fed58..6218d3682 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -27,8 +27,6 @@ static void ZSTD_setLog2Prices(optState_t* optPtr)
     optPtr->log2litLengthSum = ZSTD_highbit32(optPtr->litLengthSum+1);
     optPtr->log2matchLengthSum = ZSTD_highbit32(optPtr->matchLengthSum+1);
     optPtr->log2offCodeSum = ZSTD_highbit32(optPtr->offCodeSum+1);
-    optPtr->factor = 1 + ((optPtr->litSum>>5) / optPtr->litLengthSum)
-                       + ((optPtr->litSum<<1) / (optPtr->litSum + optPtr->matchSum));  /* => {0,1}, == (optPtr->matchSum <= optPtr->litSum) */
 }
 
 
@@ -58,7 +56,6 @@ static void ZSTD_rescaleFreqs(optState_t* const optPtr,
         for (u=0; u<=MaxML; u++)
             optPtr->matchLengthFreq[u] = 1;
         optPtr->matchLengthSum = MaxML+1;
-        optPtr->matchSum = (ZSTD_LITFREQ_ADD << Litbits);
         for (u=0; u<=MaxOff; u++)
             optPtr->offCodeFreq[u] = 1;
         optPtr->offCodeSum = (MaxOff+1);
@@ -77,13 +74,10 @@ static void ZSTD_rescaleFreqs(optState_t* const optPtr,
             optPtr->litLengthSum += optPtr->litLengthFreq[u];
         }
         optPtr->matchLengthSum = 0;
-        optPtr->matchSum = 0;
         for (u=0; u<=MaxML; u++) {
             optPtr->matchLengthFreq[u] = 1 + (optPtr->matchLengthFreq[u]>>ZSTD_FREQ_DIV);
             optPtr->matchLengthSum += optPtr->matchLengthFreq[u];
-            optPtr->matchSum += optPtr->matchLengthFreq[u] * (u + 3);
         }
-        optPtr->matchSum *= ZSTD_LITFREQ_ADD;
         optPtr->offCodeSum = 0;
         for (u=0; u<=MaxOff; u++) {
             optPtr->offCodeFreq[u] = 1 + (optPtr->offCodeFreq[u]>>ZSTD_FREQ_DIV);
@@ -95,8 +89,8 @@ static void ZSTD_rescaleFreqs(optState_t* const optPtr,
 }
 
 
-static U32 ZSTD_rawLiteralsCost(const optState_t* const optPtr,
-                                const BYTE* const literals, U32 const litLength)
+static U32 ZSTD_rawLiteralsCost(const BYTE* const literals, U32 const litLength,
+                                const optState_t* const optPtr)
 {
     if (optPtr->staticPrices) return (litLength*6);  /* 6 bit per literal - no statistic used */
     if (litLength == 0) return 0;
@@ -110,7 +104,7 @@ static U32 ZSTD_rawLiteralsCost(const optState_t* const optPtr,
     }
 }
 
-static U32 ZSTD_litLengthPrice(const optState_t* const optPtr, U32 const litLength)
+static U32 ZSTD_litLengthPrice(U32 const litLength, const optState_t* const optPtr)
 {
     if (optPtr->staticPrices) return ZSTD_highbit32((U32)litLength+1);
 
@@ -121,17 +115,44 @@ static U32 ZSTD_litLengthPrice(const optState_t* const optPtr, U32 const litLeng
     }
 }
 
-static U32 ZSTD_fullLiteralsCost(const optState_t* const optPtr,
-                                 const BYTE* const literals, U32 const litLength)
+static U32 ZSTD_fullLiteralsCost(const BYTE* const literals, U32 const litLength,
+                                 const optState_t* const optPtr)
 {
-    return ZSTD_rawLiteralsCost(optPtr, literals, litLength) + ZSTD_litLengthPrice(optPtr, litLength);
+    return ZSTD_rawLiteralsCost(literals, litLength, optPtr)
+         + ZSTD_litLengthPrice(litLength, optPtr);
+}
+
+static int ZSTD_litLengthContribution(U32 const litLength, const optState_t* const optPtr)
+{
+    if (optPtr->staticPrices) return ZSTD_highbit32(litLength+1);
+
+    /* literal Length */
+    {   U32 const llCode = ZSTD_LLcode(litLength);
+        int const contribution = LL_bits[llCode]
+                        + ZSTD_highbit32(optPtr->litLengthFreq[0]+1)
+                        - ZSTD_highbit32(optPtr->litLengthFreq[llCode]+1);
+#if 1
+        return contribution;
+#else
+        return MAX(0, contribution); /* sometimes better, sometimes not ... */
+#endif
+    }
+}
+
+static int ZSTD_literalsContribution(const BYTE* const literals, U32 const litLength,
+                                     const optState_t* const optPtr)
+{
+    int const contribution = ZSTD_rawLiteralsCost(literals, litLength, optPtr)
+                           + ZSTD_litLengthContribution(litLength, optPtr);
+    return contribution;
 }
 
 
 /* ZSTD_getMatchPrice() :
  * optLevel: when <2, favors small offset for decompression speed (improved cache efficiency) */
-FORCE_INLINE_TEMPLATE U32 ZSTD_getMatchPrice(const optState_t* const optPtr,
+FORCE_INLINE_TEMPLATE U32 ZSTD_getMatchPrice(
                                     U32 const offset, U32 const matchLength,
+                                    const optState_t* const optPtr,
                                     int const optLevel)
 {
     U32 price;
@@ -150,7 +171,7 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_getMatchPrice(const optState_t* const optPtr,
         price += ML_bits[mlCode] + optPtr->log2matchLengthSum - ZSTD_highbit32(optPtr->matchLengthFreq[mlCode]+1);
     }
 
-    price += optPtr->factor;
+    //price += optPtr->factor;
     DEBUGLOG(8, "ZSTD_getMatchPrice(ml:%u) = %u", matchLength, price);
     return price;
 }
@@ -450,9 +471,10 @@ typedef struct {
     U32 rawLitCost;
 } cachedLiteralPrice_t;
 
-static U32 ZSTD_updateCachedLPrice(const optState_t* const optStatePtr,
+static U32 ZSTD_rawLiteralsCost_cached(
                             cachedLiteralPrice_t* const cachedLitPrice,
-                            const BYTE* const anchor, U32 const litlen)
+                            const BYTE* const anchor, U32 const litlen,
+                            const optState_t* const optStatePtr)
 {
     U32 startCost;
     U32 remainingLength;
@@ -469,14 +491,33 @@ static U32 ZSTD_updateCachedLPrice(const optState_t* const optStatePtr,
         remainingLength = litlen;
     }
 
-    {   U32 const rawLitCost = startCost + ZSTD_rawLiteralsCost(optStatePtr, startPosition, remainingLength);
+    {   U32 const rawLitCost = startCost + ZSTD_rawLiteralsCost(startPosition, remainingLength, optStatePtr);
         cachedLitPrice->anchor = anchor;
         cachedLitPrice->litlen = litlen;
         cachedLitPrice->rawLitCost = rawLitCost;
-        return rawLitCost + ZSTD_litLengthPrice(optStatePtr, litlen);
+        return rawLitCost;
     }
 }
 
+static U32 ZSTD_fullLiteralsCost_cached(
+                            cachedLiteralPrice_t* const cachedLitPrice,
+                            const BYTE* const anchor, U32 const litlen,
+                            const optState_t* const optStatePtr)
+{
+    return ZSTD_rawLiteralsCost_cached(cachedLitPrice, anchor, litlen, optStatePtr)
+         + ZSTD_litLengthPrice(litlen, optStatePtr);
+}
+
+static int ZSTD_literalsContribution_cached(
+                            cachedLiteralPrice_t* const cachedLitPrice,
+                            const BYTE* const anchor, U32 const litlen,
+                            const optState_t* const optStatePtr)
+{
+    int const contribution = ZSTD_rawLiteralsCost_cached(cachedLitPrice, anchor, litlen, optStatePtr)
+                           + ZSTD_litLengthContribution(litlen, optStatePtr);
+    return contribution;
+}
+
 FORCE_INLINE_TEMPLATE
 size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                                       const void* src, size_t srcSize,
@@ -542,7 +583,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
             }   }
 
             /* set prices for first matches starting position == 0 */
-            {   U32 const literalsPrice = ZSTD_updateCachedLPrice(optStatePtr, &cachedLitPrice, anchor, litlen);
+            {   U32 const literalsPrice = ZSTD_fullLiteralsCost_cached(&cachedLitPrice, anchor, litlen, optStatePtr);
                 U32 pos;
                 U32 matchNb;
                 for (pos = 0; pos < minMatch; pos++) {
@@ -554,7 +595,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                     U32 const end = matches[matchNb].len;
                     repcodes_t const repHistory = ZSTD_updateRep(rep, offset, ll0);
                     for ( ; pos <= end ; pos++ ) {
-                        U32 const matchPrice = literalsPrice + ZSTD_getMatchPrice(optStatePtr, offset, pos, optLevel);
+                        U32 const matchPrice = literalsPrice + ZSTD_getMatchPrice(offset, pos, optStatePtr, optLevel);
                         DEBUGLOG(7, "rPos:%u => set initial price : %u",
                                     pos, matchPrice);
                         opt[pos].mlen = pos;
@@ -574,12 +615,13 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
 
             /* Fix current position with one literal if cheaper */
             {   U32 const litlen = (opt[cur-1].mlen == 1) ? opt[cur-1].litlen + 1 : 1;
-                U32 price;
+                int price;  /* note : contribution can be negative */
                 if (cur > litlen) {
-                    price = opt[cur - litlen].price + ZSTD_fullLiteralsCost(optStatePtr, inr-litlen, litlen);
+                    price = opt[cur - litlen].price + ZSTD_literalsContribution(inr-litlen, litlen, optStatePtr);
                 } else {
-                    price = ZSTD_updateCachedLPrice(optStatePtr, &cachedLitPrice, anchor, litlen);
+                    price = ZSTD_literalsContribution_cached(&cachedLitPrice, anchor, litlen, optStatePtr);
                 }
+                assert(price < 1000000000); /* overflow check */
                 if (price <= opt[cur].price) {
                     DEBUGLOG(7, "rPos:%u : better price (%u<%u) using literal",
                                 cur, price, opt[cur].price);
@@ -602,7 +644,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
             {   U32 const ll0 = (opt[cur].mlen != 1);
                 U32 const litlen = (opt[cur].mlen == 1) ? opt[cur].litlen : 0;
                 U32 const previousPrice = (cur > litlen) ? opt[cur-litlen].price : 0;
-                U32 const basePrice = previousPrice + ZSTD_fullLiteralsCost(optStatePtr, inr-litlen, litlen);
+                U32 const basePrice = previousPrice + ZSTD_fullLiteralsCost(inr-litlen, litlen, optStatePtr);
                 U32 const nbMatches = ZSTD_BtGetAllMatches(ctx, inr, iend, extDict, maxSearches, mls, sufficient_len, opt[cur].rep, ll0, matches, minMatch);
                 U32 matchNb;
                 if (!nbMatches) continue;
@@ -633,7 +675,7 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
 
                     for (mlen = lastML; mlen >= startML; mlen--) {
                         U32 const pos = cur + mlen;
-                        U32 const price = basePrice + ZSTD_getMatchPrice(optStatePtr, offset, mlen, optLevel);
+                        int const price = basePrice + ZSTD_getMatchPrice(offset, mlen, optStatePtr, optLevel);
 
                         if ((pos > last_pos) || (price < opt[pos].price)) {
                             DEBUGLOG(7, "rPos:%u => new better price (%u<%u)",
diff --git a/programs/bench.c b/programs/bench.c
index 1df8aeb0d..2f30c65ac 100644
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -191,7 +191,7 @@ static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
                         const char* displayName, int cLevel,
                         const size_t* fileSizes, U32 nbFiles,
                         const void* dictBuffer, size_t dictBufferSize,
-                        const ZSTD_compressionParameters* comprParams)
+                        const ZSTD_compressionParameters* const comprParams)
 {
     size_t const blockSize = ((g_blockSize>=32 && !g_decodeOnly) ? g_blockSize : srcSize) + (!srcSize) /* avoid div by 0 */ ;
     U32 const maxNbBlocks = (U32) ((srcSize + (blockSize-1)) / blockSize) + nbFiles;

From f5747afe0fffa5fb1c993c5366d6a6c7f73783a0 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 28 Nov 2017 15:02:48 -0800
Subject: [PATCH 088/145] add integer overflow trapping to debug builds

doc: https://gcc.gnu.org/onlinedocs/gcc-4.0.2/gcc/Code-Gen-Options.html
---
 tests/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/Makefile b/tests/Makefile
index 11d55a75d..89a109c78 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -32,7 +32,7 @@ CFLAGS     += -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow                 \
               -Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement \
               -Wstrict-prototypes -Wundef -Wformat-security                   \
               -Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings      \
-              -Wredundant-decls
+              -Wredundant-decls -ftrapv
 CFLAGS     += $(DEBUGFLAGS) $(MOREFLAGS)
 FLAGS       = $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)
 

From bc42bc3b1dcfb0d9bcffa4e4710ac0dd42a3ec27 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 28 Nov 2017 16:08:43 -0800
Subject: [PATCH 089/145] removed one invocation of SET_PRICE() macro

---
 lib/compress/zstd_opt.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index 6218d3682..d44b5be58 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -680,7 +680,12 @@ size_t ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                         if ((pos > last_pos) || (price < opt[pos].price)) {
                             DEBUGLOG(7, "rPos:%u => new better price (%u<%u)",
                                         pos, price, opt[pos].price);
-                            SET_PRICE(pos, mlen, offset, litlen, price, repHistory);  /* note : macro modifies last_pos */
+                            while (last_pos < pos) { opt[last_pos+1].price = ZSTD_MAX_PRICE; last_pos++; }
+                            opt[pos].mlen = mlen;
+                            opt[pos].off = offset;
+                            opt[pos].litlen = litlen;
+                            opt[pos].price = price;
+                            memcpy(opt[pos].rep, &repHistory, sizeof(repHistory));
                         } else {
                             if (optLevel==0) break;  /* gets ~+10% speed for about -0.01 ratio loss */
                         }

From f98ee994c4569de52d60b70bc1e2dae75e0c9b90 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 29 Nov 2017 15:19:00 -0800
Subject: [PATCH 090/145] zstd_opt: added comments, as requested by @terrelln

---
 lib/compress/zstd_opt.c | 38 +++++++++++++++++++++++---------------
 1 file changed, 23 insertions(+), 15 deletions(-)

diff --git a/lib/compress/zstd_opt.c b/lib/compress/zstd_opt.c
index d44b5be58..7171ff537 100644
--- a/lib/compress/zstd_opt.c
+++ b/lib/compress/zstd_opt.c
@@ -89,6 +89,9 @@ static void ZSTD_rescaleFreqs(optState_t* const optPtr,
 }
 
 
+/* ZSTD_rawLiteralsCost() :
+ * cost of literals (only) in given segment (which length can be null)
+ * does not include cost of literalLength symbol */
 static U32 ZSTD_rawLiteralsCost(const BYTE* const literals, U32 const litLength,
                                 const optState_t* const optPtr)
 {
@@ -104,6 +107,8 @@ static U32 ZSTD_rawLiteralsCost(const BYTE* const literals, U32 const litLength,
     }
 }
 
+/* ZSTD_litLengthPrice() :
+ * cost of literalLength symbol */
 static U32 ZSTD_litLengthPrice(U32 const litLength, const optState_t* const optPtr)
 {
     if (optPtr->staticPrices) return ZSTD_highbit32((U32)litLength+1);
@@ -115,6 +120,9 @@ static U32 ZSTD_litLengthPrice(U32 const litLength, const optState_t* const optP
     }
 }
 
+/* ZSTD_litLengthPrice() :
+ * cost of the literal part of a sequence,
+ * including literals themselves, and literalLength symbol */
 static U32 ZSTD_fullLiteralsCost(const BYTE* const literals, U32 const litLength,
                                  const optState_t* const optPtr)
 {
@@ -122,6 +130,10 @@ static U32 ZSTD_fullLiteralsCost(const BYTE* const literals, U32 const litLength
          + ZSTD_litLengthPrice(litLength, optPtr);
 }
 
+/* ZSTD_litLengthContribution() :
+ * @return ( cost(litlength) - cost(0) )
+ * this value can then be added to rawLiteralsCost()
+ * to provide a cost which is directly comparable to a match ending at same position */
 static int ZSTD_litLengthContribution(U32 const litLength, const optState_t* const optPtr)
 {
     if (optPtr->staticPrices) return ZSTD_highbit32(litLength+1);
@@ -139,6 +151,10 @@ static int ZSTD_litLengthContribution(U32 const litLength, const optState_t* con
     }
 }
 
+/* ZSTD_literalsContribution() :
+ * creates a fake cost for the literals part of a sequence
+ * which can be compared to the ending cost of a match
+ * should a new match start at this position */
 static int ZSTD_literalsContribution(const BYTE* const literals, U32 const litLength,
                                      const optState_t* const optPtr)
 {
@@ -147,8 +163,9 @@ static int ZSTD_literalsContribution(const BYTE* const literals, U32 const litLe
     return contribution;
 }
 
-
 /* ZSTD_getMatchPrice() :
+ * Provides the cost of the match part (offset + matchLength) of a sequence
+ * Must be combined with ZSTD_fullLiteralsCost() to get the full cost of a sequence.
  * optLevel: when <2, favors small offset for decompression speed (improved cache efficiency) */
 FORCE_INLINE_TEMPLATE U32 ZSTD_getMatchPrice(
                                     U32 const offset, U32 const matchLength,
@@ -171,14 +188,13 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_getMatchPrice(
         price += ML_bits[mlCode] + optPtr->log2matchLengthSum - ZSTD_highbit32(optPtr->matchLengthFreq[mlCode]+1);
     }
 
-    //price += optPtr->factor;
     DEBUGLOG(8, "ZSTD_getMatchPrice(ml:%u) = %u", matchLength, price);
     return price;
 }
 
 static void ZSTD_updateStats(optState_t* const optPtr,
-                            U32 litLength, const BYTE* literals,
-                            U32 offsetCode, U32 matchLength)
+                             U32 litLength, const BYTE* literals,
+                             U32 offsetCode, U32 matchLength)
 {
     /* literals */
     {   U32 u;
@@ -209,7 +225,9 @@ static void ZSTD_updateStats(optState_t* const optPtr,
 }
 
 
-/* function safe only for comparisons */
+/* ZSTD_readMINMATCH() :
+ * function safe only for comparisons
+ * assumption : memPtr must be at least 4 bytes before end of buffer */
 MEM_STATIC U32 ZSTD_readMINMATCH(const void* memPtr, U32 length)
 {
     switch (length)
@@ -454,16 +472,6 @@ repcodes_t ZSTD_updateRep(U32 const rep[3], U32 const offset, U32 const ll0)
     return newReps;
 }
 
-/* update opt[pos] and last_pos */
-#define SET_PRICE(pos, mlen_, offset_, litlen_, price_, rep_) \
-    {                                                         \
-        while (last_pos < pos)  { opt[last_pos+1].price = ZSTD_MAX_PRICE; last_pos++; } \
-        opt[pos].mlen = mlen_;                                \
-        opt[pos].off = offset_;                               \
-        opt[pos].litlen = litlen_;                            \
-        opt[pos].price = price_;                              \
-        memcpy(opt[pos].rep, &rep_, sizeof(rep_));            \
-    }
 
 typedef struct {
     const BYTE* anchor;

From 998a93b784798a6cab9d4a536a207f863ea3bcf3 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 29 Nov 2017 16:13:05 -0800
Subject: [PATCH 091/145] simplified ZSTD_CCtx_setParametersUsingCCtxParams()

Any ZSTD_CCtx_setParameter() shall just write the requested parameter, without further action.
Any action shall be taken at parameter application only (during init).
It makes it possible to just copy CCtxParams from external container to internal state,
and get rid of the more complex code which was trying to compensate for missing actions.
---
 lib/compress/zstd_compress.c | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 858eaca30..e6e0c0210 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -271,11 +271,11 @@ size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned v
     case ZSTD_p_forceMaxWindow :  /* Force back-references to remain < windowSize,
                                    * even when referencing into Dictionary content
                                    * default : 0 when using a CDict, 1 when using a Prefix */
-        cctx->loadedDictEnd = 0;
+        cctx->loadedDictEnd = 0;  /* ? */
         return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 
     case ZSTD_p_nbThreads:
-        if (value > 1 && cctx->staticSize) {
+        if ((value > 1) && cctx->staticSize) {
             return ERROR(parameter_unsupported);  /* MT not compatible with static alloc */
         }
         return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
@@ -465,14 +465,17 @@ size_t ZSTD_CCtxParam_setParameter(
  * The multithreading parameters jobSize and overlapSizeLog are set only if
  * nbThreads > 1.
  *
- * Pledged srcSize is treated as unknown.
+ * pledgedSrcSize is considered unknown
  */
 size_t ZSTD_CCtx_setParametersUsingCCtxParams(
-        ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params)
+        ZSTD_CCtx* const cctx, const ZSTD_CCtx_params* const params)
 {
     if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
     if (cctx->cdict) return ERROR(stage_wrong);
 
+#if 1
+    cctx->requestedParams = *params;
+#else
     /* Assume the compression and frame parameters are validated */
     cctx->requestedParams.cParams = params->cParams;
     cctx->requestedParams.fParams = params->fParams;
@@ -492,6 +495,7 @@ size_t ZSTD_CCtx_setParametersUsingCCtxParams(
 
     /* Copy long distance matching parameters */
     cctx->requestedParams.ldmParams = params->ldmParams;
+#endif
 
     /* customMem is used only for create/free params and can be ignored */
     return 0;
@@ -2858,6 +2862,7 @@ size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
                 if (cctx->mtctx == NULL) return ERROR(memory_allocation);
             }
             DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbThreads=%u", params.nbThreads);
+            DEBUGLOG(2, "params.windowLog = %u", params.cParams.windowLog);
             CHECK_F( ZSTDMT_initCStream_internal(
                         cctx->mtctx,
                         prefixDict.dict, prefixDict.dictSize, ZSTD_dm_rawContent,

From d3c59edac9e0bf544b7414e5442448f7a67b55ff Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 29 Nov 2017 16:42:20 -0800
Subject: [PATCH 092/145] removed long-range-mode tests from `zstreamtest
 --no-big-tests`

---
 lib/compress/zstd_compress.c   |  3 ++-
 lib/compress/zstdmt_compress.c |  2 +-
 tests/zstreamtest.c            | 33 +++++++++++++++++++--------------
 3 files changed, 22 insertions(+), 16 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index e6e0c0210..dd12b171b 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -241,6 +241,7 @@ static ZSTD_CCtx_params ZSTD_assignParamsToCCtxParams(
 
 size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned value)
 {
+    DEBUGLOG(4, "ZSTD_CCtx_setParameter");
     if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
 
     switch(param)
@@ -320,6 +321,7 @@ size_t ZSTD_CCtxParam_setParameter(
         return CCtxParams->compressionLevel;
 
     case ZSTD_p_windowLog :
+        DEBUGLOG(4, "setting windowLog=%u", value);
         if (value) {  /* 0 : does not change current windowLog */
             CLAMPCHECK(value, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX);
             ZSTD_cLevelToCCtxParams(CCtxParams);
@@ -2862,7 +2864,6 @@ size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
                 if (cctx->mtctx == NULL) return ERROR(memory_allocation);
             }
             DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbThreads=%u", params.nbThreads);
-            DEBUGLOG(2, "params.windowLog = %u", params.cParams.windowLog);
             CHECK_F( ZSTDMT_initCStream_internal(
                         cctx->mtctx,
                         prefixDict.dict, prefixDict.dictSize, ZSTD_dm_rawContent,
diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c
index 2926d3b48..ce813dccc 100644
--- a/lib/compress/zstdmt_compress.c
+++ b/lib/compress/zstdmt_compress.c
@@ -140,7 +140,7 @@ static size_t ZSTDMT_sizeof_bufferPool(ZSTDMT_bufferPool* bufPool)
     return poolSize + totalBufferSize;
 }
 
-static void ZSTDMT_setBufferSize(ZSTDMT_bufferPool* bufPool, size_t bSize)
+static void ZSTDMT_setBufferSize(ZSTDMT_bufferPool* const bufPool, size_t const bSize)
 {
     ZSTD_pthread_mutex_lock(&bufPool->poolMutex);
     DEBUGLOG(4, "ZSTDMT_setBufferSize: bSize = %u", (U32)bSize);
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index b8c437a41..0a09cfa15 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -1486,43 +1486,47 @@ static int fuzzerTests_newAPI(U32 seed, U32 nbTests, unsigned startTest, double
                 cParams = ZSTD_adjustCParams(cParams, 0, 0);
 
                 if (FUZ_rand(&lseed) & 1) {
+                    DISPLAYLEVEL(5, "t%u: windowLog : %u \n", testNb, cParams.windowLog);
                     CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_windowLog, cParams.windowLog, useOpaqueAPI) );
                     assert(cParams.windowLog >= ZSTD_WINDOWLOG_MIN);   /* guaranteed by ZSTD_adjustCParams() */
                     windowLogMalus = (cParams.windowLog - ZSTD_WINDOWLOG_MIN) / 5;
-                    DISPLAYLEVEL(5, "t%u: windowLog : %u \n", testNb, cParams.windowLog);
                 }
                 if (FUZ_rand(&lseed) & 1) {
-                    CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_hashLog, cParams.hashLog, useOpaqueAPI) );
                     DISPLAYLEVEL(5, "t%u: hashLog : %u \n", testNb, cParams.hashLog);
+                    CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_hashLog, cParams.hashLog, useOpaqueAPI) );
                 }
                 if (FUZ_rand(&lseed) & 1) {
-                    CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_chainLog, cParams.chainLog, useOpaqueAPI) );
                     DISPLAYLEVEL(5, "t%u: chainLog : %u \n", testNb, cParams.chainLog);
+                    CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_chainLog, cParams.chainLog, useOpaqueAPI) );
                 }
                 if (FUZ_rand(&lseed) & 1) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_searchLog, cParams.searchLog, useOpaqueAPI) );
                 if (FUZ_rand(&lseed) & 1) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_minMatch, cParams.searchLength, useOpaqueAPI) );
                 if (FUZ_rand(&lseed) & 1) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_targetLength, cParams.targetLength, useOpaqueAPI) );
 
                 /* mess with long distance matching parameters */
-                if (FUZ_rand(&lseed) & 1) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_enableLongDistanceMatching, FUZ_rand(&lseed) & 63, useOpaqueAPI) );
-                if (FUZ_rand(&lseed) & 3) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_ldmHashLog, FUZ_randomClampedLength(&lseed, ZSTD_HASHLOG_MIN, 23), useOpaqueAPI) );
-                if (FUZ_rand(&lseed) & 3) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_ldmMinMatch, FUZ_randomClampedLength(&lseed, ZSTD_LDM_MINMATCH_MIN, ZSTD_LDM_MINMATCH_MAX), useOpaqueAPI) );
-                if (FUZ_rand(&lseed) & 3) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_ldmBucketSizeLog, FUZ_randomClampedLength(&lseed, 0, ZSTD_LDM_BUCKETSIZELOG_MAX), useOpaqueAPI) );
-                if (FUZ_rand(&lseed) & 3) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_ldmHashEveryLog, FUZ_randomClampedLength(&lseed, 0, ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN), useOpaqueAPI) );
+                if (bigTests) {
+                    if (FUZ_rand(&lseed) & 1) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_enableLongDistanceMatching, FUZ_rand(&lseed) & 63, useOpaqueAPI) );
+                    if (FUZ_rand(&lseed) & 3) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_ldmHashLog, FUZ_randomClampedLength(&lseed, ZSTD_HASHLOG_MIN, 23), useOpaqueAPI) );
+                    if (FUZ_rand(&lseed) & 3) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_ldmMinMatch, FUZ_randomClampedLength(&lseed, ZSTD_LDM_MINMATCH_MIN, ZSTD_LDM_MINMATCH_MAX), useOpaqueAPI) );
+                    if (FUZ_rand(&lseed) & 3) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_ldmBucketSizeLog, FUZ_randomClampedLength(&lseed, 0, ZSTD_LDM_BUCKETSIZELOG_MAX), useOpaqueAPI) );
+                    if (FUZ_rand(&lseed) & 3) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_ldmHashEveryLog, FUZ_randomClampedLength(&lseed, 0, ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN), useOpaqueAPI) );
+                }
 
                 /* mess with frame parameters */
                 if (FUZ_rand(&lseed) & 1) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_checksumFlag, FUZ_rand(&lseed) & 1, useOpaqueAPI) );
                 if (FUZ_rand(&lseed) & 1) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_dictIDFlag, FUZ_rand(&lseed) & 1, useOpaqueAPI) );
                 if (FUZ_rand(&lseed) & 1) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_contentSizeFlag, FUZ_rand(&lseed) & 1, useOpaqueAPI) );
-                if (FUZ_rand(&lseed) & 1) CHECK_Z( ZSTD_CCtx_setPledgedSrcSize(zc, pledgedSrcSize) );
-                DISPLAYLEVEL(5, "t%u: pledgedSrcSize : %u \n", testNb, (U32)pledgedSrcSize);
+                if (FUZ_rand(&lseed) & 1) {
+                    DISPLAYLEVEL(5, "t%u: pledgedSrcSize : %u \n", testNb, (U32)pledgedSrcSize);
+                    CHECK_Z( ZSTD_CCtx_setPledgedSrcSize(zc, pledgedSrcSize) );
+                }
 
                 /* multi-threading parameters */
                 {   U32 const nbThreadsCandidate = (FUZ_rand(&lseed) & 4) + 1;
                     U32 const nbThreadsAdjusted = (windowLogMalus < nbThreadsCandidate) ? nbThreadsCandidate - windowLogMalus : 1;
                     U32 const nbThreads = MIN(nbThreadsAdjusted, nbThreadsMax);
-                    CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_nbThreads, nbThreads, useOpaqueAPI) );
                     DISPLAYLEVEL(5, "t%u: nbThreads : %u \n", testNb, nbThreads);
+                    CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_nbThreads, nbThreads, useOpaqueAPI) );
                     if (nbThreads > 1) {
                         U32 const jobLog = FUZ_rand(&lseed) % (testLog+1);
                         CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_overlapSizeLog, FUZ_rand(&lseed) % 10, useOpaqueAPI) );
@@ -1530,10 +1534,11 @@ static int fuzzerTests_newAPI(U32 seed, U32 nbTests, unsigned startTest, double
                     }
                 }
 
-                if (FUZ_rand(&lseed) & 1) CHECK_Z (setCCtxParameter(zc, cctxParams, ZSTD_p_forceMaxWindow, FUZ_rand(&lseed) & 1, useOpaqueAPI) );
+                if (FUZ_rand(&lseed) & 1) CHECK_Z( setCCtxParameter(zc, cctxParams, ZSTD_p_forceMaxWindow, FUZ_rand(&lseed) & 1, useOpaqueAPI) );
 
                 /* Apply parameters */
                 if (useOpaqueAPI) {
+                    DISPLAYLEVEL(6," t%u: applying CCtxParams \n", testNb);
                     CHECK_Z (ZSTD_CCtx_setParametersUsingCCtxParams(zc, cctxParams) );
                 }
 
@@ -1573,8 +1578,8 @@ static int fuzzerTests_newAPI(U32 seed, U32 nbTests, unsigned startTest, double
                 outBuff.size = outBuff.pos + dstBuffSize;
 
                 CHECK_Z( ZSTD_compress_generic(zc, &outBuff, &inBuff, flush) );
-                DISPLAYLEVEL(6, "compress consumed %u bytes (total : %u) \n",
-                    (U32)inBuff.pos, (U32)(totalTestSize + inBuff.pos));
+                DISPLAYLEVEL(6, "t%u: compress consumed %u bytes (total : %u) \n",
+                    testNb, (U32)inBuff.pos, (U32)(totalTestSize + inBuff.pos));
 
                 XXH64_update(&xxhState, srcBuffer+srcStart, inBuff.pos);
                 memcpy(copyBuffer+totalTestSize, srcBuffer+srcStart, inBuff.pos);

From 78290874a5e91e9d9c95ffea67592caa8425ba50 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 29 Nov 2017 17:01:14 -0800
Subject: [PATCH 093/145] fixed Visual warning on minor interface discrepancy

---
 lib/compress/zstd_compress.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index dd12b171b..bc2d8a576 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -470,7 +470,7 @@ size_t ZSTD_CCtxParam_setParameter(
  * pledgedSrcSize is considered unknown
  */
 size_t ZSTD_CCtx_setParametersUsingCCtxParams(
-        ZSTD_CCtx* const cctx, const ZSTD_CCtx_params* const params)
+        ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params)
 {
     if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
     if (cctx->cdict) return ERROR(stage_wrong);

From 9a2f6f477ba8cefa0040bb0323203aadde1e7c32 Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Wed, 29 Nov 2017 19:11:12 -0800
Subject: [PATCH 094/145] Use util.h for timing

---
 programs/bench.c     | 15 +++++++-------
 programs/dibio.c     | 16 +++++++--------
 programs/fileio.c    | 12 ++++++-----
 programs/util.h      |  4 ++++
 tests/decodecorpus.c | 21 +++++++++-----------
 tests/fuzzer.c       | 28 ++++++++++++--------------
 tests/paramgrill.c   | 47 +++++++++++++++++++++-----------------------
 tests/zbufftest.c    | 35 +++++++++++++++------------------
 tests/zstreamtest.c  | 43 +++++++++++++++++++---------------------
 9 files changed, 106 insertions(+), 115 deletions(-)

diff --git a/programs/bench.c b/programs/bench.c
index 1df8aeb0d..384b982f4 100644
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -34,7 +34,6 @@
 #include <stdlib.h>      /* malloc, free */
 #include <string.h>      /* memset */
 #include <stdio.h>       /* fprintf, fopen */
-#include <time.h>        /* clock_t, clock, CLOCKS_PER_SEC */
 
 #include "mem.h"
 #define ZSTD_STATIC_LINKING_ONLY
@@ -72,12 +71,14 @@ static U32 g_compressibilityDefault = 50;
 #define DISPLAYLEVEL(l, ...) if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); }
 static int g_displayLevel = 2;   /* 0 : no display;   1: errors;   2 : + result + interaction + warnings;   3 : + progression;   4 : + information */
 
-#define DISPLAYUPDATE(l, ...) if (g_displayLevel>=l) { \
-            if ((clock() - g_time > refreshRate) || (g_displayLevel>=4)) \
-            { g_time = clock(); DISPLAY(__VA_ARGS__); \
-            if (g_displayLevel>=4) fflush(stderr); } }
-static const clock_t refreshRate = CLOCKS_PER_SEC * 15 / 100;
-static clock_t g_time = 0;
+#define SEC_TO_MICRO 1000000
+static const U64 g_refreshRate = SEC_TO_MICRO / 6;
+static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
+
+#define DISPLAYUPDATE(l, ...) { if (g_displayLevel>=l) { \
+            if ((UTIL_clockSpanMicro(g_displayClock) > g_refreshRate) || (g_displayLevel>=4)) \
+            { g_displayClock = UTIL_getTime(); DISPLAY(__VA_ARGS__); \
+            if (g_displayLevel>=4) fflush(stderr); } } }
 
 
 /* *************************************
diff --git a/programs/dibio.c b/programs/dibio.c
index dea3ec44f..9cc5264d2 100644
--- a/programs/dibio.c
+++ b/programs/dibio.c
@@ -26,7 +26,6 @@
 #include <stdlib.h>         /* malloc, free */
 #include <string.h>         /* memset */
 #include <stdio.h>          /* fprintf, fopen, ftello64 */
-#include <time.h>           /* clock_t, clock, CLOCKS_PER_SEC */
 #include <errno.h>          /* errno */
 
 #include "mem.h"            /* read */
@@ -55,15 +54,14 @@ static const size_t g_maxMemory = (sizeof(size_t) == 4) ? (2 GB - 64 MB) : ((siz
 #define DISPLAY(...)         fprintf(stderr, __VA_ARGS__)
 #define DISPLAYLEVEL(l, ...) if (displayLevel>=l) { DISPLAY(__VA_ARGS__); }
 
-#define DISPLAYUPDATE(l, ...) if (displayLevel>=l) { \
-            if ((DIB_clockSpan(g_time) > refreshRate) || (displayLevel>=4)) \
-            { g_time = clock(); DISPLAY(__VA_ARGS__); \
-            if (displayLevel>=4) fflush(stderr); } }
-static const clock_t refreshRate = CLOCKS_PER_SEC * 2 / 10;
-static clock_t g_time = 0;
-
-static clock_t DIB_clockSpan(clock_t nPrevious) { return clock() - nPrevious; }
+#define SEC_TO_MICRO 1000000
+static const U64 g_refreshRate = SEC_TO_MICRO / 6;
+static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
 
+#define DISPLAYUPDATE(l, ...) { if (displayLevel>=l) { \
+            if ((UTIL_clockSpanMicro(g_displayClock) > g_refreshRate) || (displayLevel>=4)) \
+            { g_displayClock = UTIL_getTime(); DISPLAY(__VA_ARGS__); \
+            if (displayLevel>=4) fflush(stderr); } } }
 
 /*-*************************************
 *  Exceptions
diff --git a/programs/fileio.c b/programs/fileio.c
index eb004f916..0ea1ad152 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -29,7 +29,6 @@
 #include <stdio.h>      /* fprintf, fopen, fread, _fileno, stdin, stdout */
 #include <stdlib.h>     /* malloc, free */
 #include <string.h>     /* strcmp, strlen */
-#include <time.h>       /* clock */
 #include <errno.h>      /* errno */
 
 #if defined (_MSC_VER)
@@ -40,6 +39,7 @@
 #include "bitstream.h"
 #include "mem.h"
 #include "fileio.h"
+#include "util.h"
 #define ZSTD_STATIC_LINKING_ONLY   /* ZSTD_magicNumber, ZSTD_frameHeaderSize_max */
 #include "zstd.h"
 #if defined(ZSTD_GZCOMPRESS) || defined(ZSTD_GZDECOMPRESS)
@@ -81,12 +81,14 @@
 static int g_displayLevel = 2;   /* 0 : no display;  1: errors;  2: + result + interaction + warnings;  3: + progression;  4: + information */
 void FIO_setNotificationLevel(unsigned level) { g_displayLevel=level; }
 
+#define SEC_TO_MICRO 1000000
+static const U64 g_refreshRate = SEC_TO_MICRO / 6;
+static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
+
 #define DISPLAYUPDATE(l, ...) { if (g_displayLevel>=l) { \
-            if ((clock() - g_time > refreshRate) || (g_displayLevel>=4)) \
-            { g_time = clock(); DISPLAY(__VA_ARGS__); \
+            if ((UTIL_clockSpanMicro(g_displayClock) > g_refreshRate) || (g_displayLevel>=4)) \
+            { g_displayClock = UTIL_getTime(); DISPLAY(__VA_ARGS__); \
             if (g_displayLevel>=4) fflush(stderr); } } }
-static const clock_t refreshRate = CLOCKS_PER_SEC * 15 / 100;
-static clock_t g_time = 0;
 
 #undef MIN  /* in case it would be already defined */
 #define MIN(a,b)    ((a) < (b) ? (a) : (b))
diff --git a/programs/util.h b/programs/util.h
index e44d7459d..41155694e 100644
--- a/programs/util.h
+++ b/programs/util.h
@@ -118,6 +118,7 @@ static int g_utilDisplayLevel;
 *  Time functions
 ******************************************/
 #if defined(_WIN32)   /* Windows */
+    #define UTIL_TIME_INITIALIZER { { 0, 0 } }
     typedef LARGE_INTEGER UTIL_time_t;
     UTIL_STATIC UTIL_time_t UTIL_getTime(void) { UTIL_time_t x; QueryPerformanceCounter(&x); return x; }
     UTIL_STATIC U64 UTIL_getSpanTimeMicro(UTIL_time_t clockStart, UTIL_time_t clockEnd)
@@ -144,6 +145,7 @@ static int g_utilDisplayLevel;
     }
 #elif defined(__APPLE__) && defined(__MACH__)
     #include <mach/mach_time.h>
+    #define UTIL_TIME_INITIALIZER 0
     typedef U64 UTIL_time_t;
     UTIL_STATIC UTIL_time_t UTIL_getTime(void) { return mach_absolute_time(); }
     UTIL_STATIC U64 UTIL_getSpanTimeMicro(UTIL_time_t clockStart, UTIL_time_t clockEnd)
@@ -168,6 +170,7 @@ static int g_utilDisplayLevel;
     }
 #elif (PLATFORM_POSIX_VERSION >= 200112L)
     #include <time.h>
+    #define UTIL_TIME_INITIALIZER { 0, 0 }
     typedef struct timespec UTIL_freq_t;
     typedef struct timespec UTIL_time_t;
     UTIL_STATIC UTIL_time_t UTIL_getTime(void)
@@ -207,6 +210,7 @@ static int g_utilDisplayLevel;
     }
 #else   /* relies on standard C (note : clock_t measurements can be wrong when using multi-threading) */
     typedef clock_t UTIL_time_t;
+    #define UTIL_TIME_INITIALIZER 0
     UTIL_STATIC UTIL_time_t UTIL_getTime(void) { return clock(); }
     UTIL_STATIC U64 UTIL_getSpanTimeMicro(UTIL_time_t clockStart, UTIL_time_t clockEnd) { return 1000000ULL * (clockEnd - clockStart) / CLOCKS_PER_SEC; }
     UTIL_STATIC U64 UTIL_getSpanTimeNano(UTIL_time_t clockStart, UTIL_time_t clockEnd) { return 1000000000ULL * (clockEnd - clockStart) / CLOCKS_PER_SEC; }
diff --git a/tests/decodecorpus.c b/tests/decodecorpus.c
index e697e519c..7d7b64664 100644
--- a/tests/decodecorpus.c
+++ b/tests/decodecorpus.c
@@ -14,8 +14,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <time.h>
 
+#include "util.h"
 #include "zstd.h"
 #include "zstd_internal.h"
 #include "mem.h"
@@ -49,20 +49,17 @@ static U32 g_displayLevel = 2;
 
 #define DISPLAYUPDATE(...)                                                     \
     do {                                                                       \
-        if ((clockSpan(g_displayClock) > g_refreshRate) ||                     \
+        if ((UTIL_clockSpanMicro(g_displayClock) > g_refreshRate) ||           \
             (g_displayLevel >= 4)) {                                           \
-            g_displayClock = clock();                                          \
+            g_displayClock = UTIL_getTime();                                   \
             DISPLAY(__VA_ARGS__);                                              \
             if (g_displayLevel >= 4) fflush(stderr);                           \
         }                                                                      \
     } while (0)
-static const clock_t g_refreshRate = CLOCKS_PER_SEC / 6;
-static clock_t g_displayClock = 0;
 
-static clock_t clockSpan(clock_t cStart)
-{
-    return clock() - cStart;   /* works even when overflow; max span ~ 30mn */
-}
+#define SEC_TO_MICRO 1000000
+static const U64 g_refreshRate = SEC_TO_MICRO / 6;
+static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
 
 #define CHECKERR(code)                                                         \
     do {                                                                       \
@@ -1531,14 +1528,14 @@ static int runTestMode(U32 seed, unsigned numFiles, unsigned const testDurationS
 {
     unsigned fnum;
 
-    clock_t const startClock = clock();
-    clock_t const maxClockSpan = testDurationS * CLOCKS_PER_SEC;
+    UTIL_time_t const startClock = UTIL_getTime();
+    U64 const maxClockSpan = testDurationS * SEC_TO_MICRO;
 
     if (numFiles == 0 && !testDurationS) numFiles = 1;
 
     DISPLAY("seed: %u\n", seed);
 
-    for (fnum = 0; fnum < numFiles || clockSpan(startClock) < maxClockSpan; fnum++) {
+    for (fnum = 0; fnum < numFiles || UTIL_clockSpanMicro(startClock) < maxClockSpan; fnum++) {
         if (fnum < numFiles)
             DISPLAYUPDATE("\r%u/%u        ", fnum, numFiles);
         else
diff --git a/tests/fuzzer.c b/tests/fuzzer.c
index be9dc3e06..980c36176 100644
--- a/tests/fuzzer.c
+++ b/tests/fuzzer.c
@@ -25,7 +25,6 @@
 #include <stdlib.h>       /* free */
 #include <stdio.h>        /* fgets, sscanf */
 #include <string.h>       /* strcmp */
-#include <time.h>         /* clock_t */
 #define ZSTD_STATIC_LINKING_ONLY  /* ZSTD_compressContinue, ZSTD_compressBlock */
 #include "zstd.h"         /* ZSTD_VERSION_STRING */
 #include "zstd_errors.h"  /* ZSTD_getErrorCode */
@@ -36,6 +35,7 @@
 #include "mem.h"
 #define XXH_STATIC_LINKING_ONLY
 #include "xxhash.h"       /* XXH64 */
+#include "util.h"
 
 
 /*-************************************
@@ -56,25 +56,23 @@ static const U32 nbTestsDefault = 30000;
 #define DISPLAYLEVEL(l, ...)  if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); }
 static U32 g_displayLevel = 2;
 
-#define DISPLAYUPDATE(l, ...) if (g_displayLevel>=l) { \
-            if ((FUZ_clockSpan(g_displayClock) > g_refreshRate) || (g_displayLevel>=4)) \
-            { g_displayClock = clock(); DISPLAY(__VA_ARGS__); \
-            if (g_displayLevel>=4) fflush(stdout); } }
-static const clock_t g_refreshRate = CLOCKS_PER_SEC / 6;
-static clock_t g_displayClock = 0;
+#define SEC_TO_MICRO 1000000
+static const U64 g_refreshRate = SEC_TO_MICRO / 6;
+static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
 
+#define DISPLAYUPDATE(l, ...) if (g_displayLevel>=l) { \
+            if ((UTIL_clockSpanMicro(g_displayClock) > g_refreshRate) || (g_displayLevel>=4)) \
+            { g_displayClock = UTIL_getTime(); DISPLAY(__VA_ARGS__); \
+            if (g_displayLevel>=4) fflush(stderr); } }
 
 /*-*******************************************************
 *  Fuzzer functions
 *********************************************************/
+#undef MIN
+#undef MAX
 #define MIN(a,b) ((a)<(b)?(a):(b))
 #define MAX(a,b) ((a)>(b)?(a):(b))
 
-static clock_t FUZ_clockSpan(clock_t cStart)
-{
-    return clock() - cStart;   /* works even when overflow; max span ~ 30mn */
-}
-
 #define FUZ_rotl32(x,r) ((x << r) | (x >> (32 - r)))
 static unsigned FUZ_rand(unsigned* src)
 {
@@ -1208,8 +1206,8 @@ static int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, U32 const maxD
     U32 result = 0;
     U32 testNb = 0;
     U32 coreSeed = seed, lseed = 0;
-    clock_t const startClock = clock();
-    clock_t const maxClockSpan = maxDurationS * CLOCKS_PER_SEC;
+    UTIL_time_t const startClock = UTIL_getTime();
+    U64 const maxClockSpan = maxDurationS * SEC_TO_MICRO;
     int const cLevelLimiter = bigTests ? 3 : 2;
 
     /* allocation */
@@ -1234,7 +1232,7 @@ static int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, U32 const maxD
     for (testNb=1; testNb < startTest; testNb++) FUZ_rand(&coreSeed);
 
     /* main test loop */
-    for ( ; (testNb <= nbTests) || (FUZ_clockSpan(startClock) < maxClockSpan); testNb++ ) {
+    for ( ; (testNb <= nbTests) || (UTIL_clockSpanMicro(startClock) < maxClockSpan); testNb++ ) {
         size_t sampleSize, maxTestSize, totalTestSize;
         size_t cSize, totalCSize, totalGenSize;
         U64 crcOrig;
diff --git a/tests/paramgrill.c b/tests/paramgrill.c
index 081a284e4..e258932da 100644
--- a/tests/paramgrill.c
+++ b/tests/paramgrill.c
@@ -17,13 +17,14 @@
 #include <stdio.h>     /* fprintf, fopen, ftello64 */
 #include <string.h>    /* strcmp */
 #include <math.h>      /* log */
-#include <time.h>      /* clock_t */
+#include <time.h>
 
 #include "mem.h"
 #define ZSTD_STATIC_LINKING_ONLY   /* ZSTD_parameters, ZSTD_estimateCCtxSize */
 #include "zstd.h"
 #include "datagen.h"
 #include "xxhash.h"
+#include "util.h"
 
 
 /*-************************************
@@ -38,8 +39,9 @@
 #define MB *(1<<20)
 #define GB *(1ULL<<30)
 
+#define SEC_TO_MICRO 1000000
 #define NBLOOPS    2
-#define TIMELOOP  (2 * CLOCKS_PER_SEC)
+#define TIMELOOP  (2 * SEC_TO_MICRO)
 
 #define NB_LEVELS_TRACKED 30
 
@@ -49,8 +51,8 @@ static const size_t maxMemory = (sizeof(size_t)==4)  ?  (2 GB - 64 MB) : (size_t
 static const size_t sampleSize = 10000000;
 
 static const double g_grillDuration_s = 90000;   /* about 24 hours */
-static const clock_t g_maxParamTime = 15 * CLOCKS_PER_SEC;
-static const clock_t g_maxVariationTime = 60 * CLOCKS_PER_SEC;
+static const U64 g_maxParamTime = 15 * SEC_TO_MICRO;
+static const U64 g_maxVariationTime = 60 * SEC_TO_MICRO;
 static const int g_maxNbVariations = 64;
 
 
@@ -88,13 +90,9 @@ void BMK_SetNbIterations(int nbLoops)
 *  Private functions
 *********************************************************/
 
-/* works even if overflow ; max span ~ 30 mn */
-static clock_t BMK_clockSpan(clock_t cStart) { return clock() - cStart; }
-
 /* accuracy in seconds only, span can be multiple years */
 static double BMK_timeSpan(time_t tStart) { return difftime(time(NULL), tStart); }
 
-
 static size_t BMK_findMaxMem(U64 requiredMem)
 {
     size_t const step = 64 MB;
@@ -221,7 +219,7 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
         size_t cSize = 0;
         double fastestC = 100000000., fastestD = 100000000.;
         double ratio = 0.;
-        clock_t const benchStart = clock();
+        UTIL_time_t const benchStart = UTIL_getTime();
 
         DISPLAY("\r%79s\r", "");
         memset(&params, 0, sizeof(params));
@@ -229,9 +227,10 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
         for (loopNb = 1; loopNb <= g_nbIterations; loopNb++) {
             int nbLoops;
             U32 blockNb;
-            clock_t roundStart, roundClock;
+            UTIL_time_t roundStart;
+            U64 roundClock;
 
-            { clock_t const benchTime = BMK_clockSpan(benchStart);
+            { U64 const benchTime = UTIL_clockSpanMicro(benchStart);
               if (benchTime > g_maxParamTime) break; }
 
             /* Compression */
@@ -239,10 +238,9 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
             memset(compressedBuffer, 0xE5, maxCompressedSize);
 
             nbLoops = 0;
-            roundStart = clock();
-            while (clock() == roundStart);
-            roundStart = clock();
-            while (BMK_clockSpan(roundStart) < TIMELOOP) {
+            UTIL_waitForNextTick();
+            roundStart = UTIL_getTime();
+            while (UTIL_clockSpanMicro(roundStart) < TIMELOOP) {
                 for (blockNb=0; blockNb<nbBlocks; blockNb++)
                     blockTable[blockNb].cSize = ZSTD_compress_advanced(ctx,
                                                     blockTable[blockNb].cPtr,  blockTable[blockNb].cRoom,
@@ -251,13 +249,13 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
                                                     params);
                 nbLoops++;
             }
-            roundClock = BMK_clockSpan(roundStart);
+            roundClock = UTIL_clockSpanMicro(roundStart);
 
             cSize = 0;
             for (blockNb=0; blockNb<nbBlocks; blockNb++)
                 cSize += blockTable[blockNb].cSize;
             ratio = (double)srcSize / (double)cSize;
-            if ((double)roundClock < fastestC * CLOCKS_PER_SEC * nbLoops) fastestC = ((double)roundClock / CLOCKS_PER_SEC) / nbLoops;
+            if ((double)roundClock < fastestC * SEC_TO_MICRO * nbLoops) fastestC = ((double)roundClock / SEC_TO_MICRO) / nbLoops;
             DISPLAY("\r");
             DISPLAY("%1u-%s : %9u ->", loopNb, name, (U32)srcSize);
             DISPLAY(" %9u (%4.3f),%7.1f MB/s", (U32)cSize, ratio, (double)srcSize / fastestC / 1000000.);
@@ -269,17 +267,16 @@ static size_t BMK_benchParam(BMK_result_t* resultPtr,
             memset(resultBuffer, 0xD6, srcSize);
 
             nbLoops = 0;
-            roundStart = clock();
-            while (clock() == roundStart);
-            roundStart = clock();
-            for ( ; BMK_clockSpan(roundStart) < TIMELOOP; nbLoops++) {
+            UTIL_waitForNextTick();
+            roundStart = UTIL_getTime();
+            for ( ; UTIL_clockSpanMicro(roundStart) < TIMELOOP; nbLoops++) {
                 for (blockNb=0; blockNb<nbBlocks; blockNb++)
                     blockTable[blockNb].resSize = ZSTD_decompress(blockTable[blockNb].resPtr, blockTable[blockNb].srcSize,
                                                                   blockTable[blockNb].cPtr, blockTable[blockNb].cSize);
             }
-            roundClock = BMK_clockSpan(roundStart);
+            roundClock = UTIL_clockSpanMicro(roundStart);
 
-            if ((double)roundClock < fastestD * CLOCKS_PER_SEC * nbLoops) fastestD = ((double)roundClock / CLOCKS_PER_SEC) / nbLoops;
+            if ((double)roundClock < fastestD * SEC_TO_MICRO * nbLoops) fastestD = ((double)roundClock / SEC_TO_MICRO) / nbLoops;
             DISPLAY("\r");
             DISPLAY("%1u-%s : %9u -> ", loopNb, name, (U32)srcSize);
             DISPLAY("%9u (%4.3f),%7.1f MB/s, ", (U32)cSize, ratio, (double)srcSize / fastestC / 1000000.);
@@ -521,9 +518,9 @@ static void playAround(FILE* f, winnerInfo_t* winners,
                        ZSTD_CCtx* ctx)
 {
     int nbVariations = 0;
-    clock_t const clockStart = clock();
+    UTIL_time_t const clockStart = UTIL_getTime();
 
-    while (BMK_clockSpan(clockStart) < g_maxVariationTime) {
+    while (UTIL_clockSpanMicro(clockStart) < g_maxVariationTime) {
         ZSTD_compressionParameters p = params;
 
         if (nbVariations++ > g_maxNbVariations) break;
diff --git a/tests/zbufftest.c b/tests/zbufftest.c
index ce5e5518a..f770c8395 100644
--- a/tests/zbufftest.c
+++ b/tests/zbufftest.c
@@ -24,7 +24,6 @@
 **************************************/
 #include <stdlib.h>       /* free */
 #include <stdio.h>        /* fgets, sscanf */
-#include <time.h>         /* clock_t, clock() */
 #include <string.h>       /* strcmp */
 #include "mem.h"
 #define ZSTD_STATIC_LINKING_ONLY   /* ZSTD_maxCLevel */
@@ -34,6 +33,7 @@
 #include "datagen.h"      /* RDG_genBuffer */
 #define XXH_STATIC_LINKING_ONLY
 #include "xxhash.h"       /* XXH64_* */
+#include "util.h"
 
 
 /*-************************************
@@ -58,26 +58,25 @@ static const U32 prime2 = 2246822519U;
 #define DISPLAYLEVEL(l, ...)  if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); }
 static U32 g_displayLevel = 2;
 
-#define DISPLAYUPDATE(l, ...) if (g_displayLevel>=l) { \
-            if ((FUZ_GetClockSpan(g_displayClock) > g_refreshRate) || (g_displayLevel>=4)) \
-            { g_displayClock = clock(); DISPLAY(__VA_ARGS__); \
-            if (g_displayLevel>=4) fflush(stderr); } }
-static const clock_t g_refreshRate = CLOCKS_PER_SEC * 15 / 100;
-static clock_t g_displayClock = 0;
+#define SEC_TO_MICRO 1000000
+static const U64 g_refreshRate = SEC_TO_MICRO / 6;
+static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
 
-static clock_t g_clockTime = 0;
+#define DISPLAYUPDATE(l, ...) if (g_displayLevel>=l) { \
+            if ((UTIL_clockSpanMicro(g_displayClock) > g_refreshRate) || (g_displayLevel>=4)) \
+            { g_displayClock = UTIL_getTime(); DISPLAY(__VA_ARGS__); \
+            if (g_displayLevel>=4) fflush(stderr); } }
+
+static U64 g_clockTime = 0;
 
 
 /*-*******************************************************
 *  Fuzzer functions
 *********************************************************/
+#undef MIN
+#undef MAX
+#define MIN(a,b) ((a)<(b)?(a):(b))
 #define MAX(a,b) ((a)>(b)?(a):(b))
-
-static clock_t FUZ_GetClockSpan(clock_t clockStart)
-{
-    return clock() - clockStart;  /* works even when overflow. Max span ~ 30 mn */
-}
-
 /*! FUZ_rand() :
     @return : a 27 bits random value, from a 32-bits `seed`.
     `seed` is also modified */
@@ -256,8 +255,6 @@ static size_t FUZ_randomLength(U32* seed, U32 maxLog)
     return FUZ_rLogLength(seed, logLength);
 }
 
-#define MIN(a,b)   ( (a) < (b) ? (a) : (b) )
-
 #define CHECK(cond, ...) if (cond) { DISPLAY("Error => "); DISPLAY(__VA_ARGS__); \
                          DISPLAY(" (seed %u, test nb %u)  \n", seed, testNb); goto _output_error; }
 
@@ -278,7 +275,7 @@ static int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compres
     U32 coreSeed = seed;
     ZBUFF_CCtx* zc;
     ZBUFF_DCtx* zd;
-    clock_t startClock = clock();
+    UTIL_time_t startClock = UTIL_getTime();
 
     /* allocations */
     zc = ZBUFF_createCCtx();
@@ -308,7 +305,7 @@ static int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compres
         FUZ_rand(&coreSeed);
 
     /* test loop */
-    for ( ; (testNb <= nbTests) || (FUZ_GetClockSpan(startClock) < g_clockTime) ; testNb++ ) {
+    for ( ; (testNb <= nbTests) || (UTIL_clockSpanMicro(startClock) < g_clockTime) ; testNb++ ) {
         U32 lseed;
         const BYTE* srcBuffer;
         const BYTE* dict;
@@ -548,7 +545,7 @@ int main(int argc, const char** argv)
                     }
                     if (*argument=='m') g_clockTime *=60, argument++;
                     if (*argument=='n') argument++;
-                    g_clockTime *= CLOCKS_PER_SEC;
+                    g_clockTime *= SEC_TO_MICRO;
                     break;
 
                 case 's':
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index b8c437a41..aad9cba71 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -24,7 +24,6 @@
 **************************************/
 #include <stdlib.h>       /* free */
 #include <stdio.h>        /* fgets, sscanf */
-#include <time.h>         /* clock_t, clock() */
 #include <string.h>       /* strcmp */
 #include <assert.h>       /* assert */
 #include "mem.h"
@@ -37,6 +36,7 @@
 #define XXH_STATIC_LINKING_ONLY   /* XXH64_state_t */
 #include "xxhash.h"       /* XXH64_* */
 #include "seqgen.h"
+#include "util.h"
 
 
 /*-************************************
@@ -62,26 +62,25 @@ static const U32 prime32 = 2654435761U;
                                   if (g_displayLevel>=4) fflush(stderr); }
 static U32 g_displayLevel = 2;
 
-#define DISPLAYUPDATE(l, ...) if (g_displayLevel>=l) { \
-            if ((FUZ_GetClockSpan(g_displayClock) > g_refreshRate) || (g_displayLevel>=4)) \
-            { g_displayClock = clock(); DISPLAY(__VA_ARGS__); \
-              if (g_displayLevel>=4) fflush(stderr); } }
-static const clock_t g_refreshRate = CLOCKS_PER_SEC / 6;
-static clock_t g_displayClock = 0;
+#define SEC_TO_MICRO 1000000
+static const U64 g_refreshRate = SEC_TO_MICRO / 6;
+static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
 
-static clock_t g_clockTime = 0;
+#define DISPLAYUPDATE(l, ...) if (g_displayLevel>=l) { \
+            if ((UTIL_clockSpanMicro(g_displayClock) > g_refreshRate) || (g_displayLevel>=4)) \
+            { g_displayClock = UTIL_getTime(); DISPLAY(__VA_ARGS__); \
+            if (g_displayLevel>=4) fflush(stderr); } }
+
+static U64 g_clockTime = 0;
 
 
 /*-*******************************************************
 *  Fuzzer functions
 *********************************************************/
+#undef MIN
+#undef MAX
+#define MIN(a,b) ((a)<(b)?(a):(b))
 #define MAX(a,b) ((a)>(b)?(a):(b))
-
-static clock_t FUZ_GetClockSpan(clock_t clockStart)
-{
-    return clock() - clockStart;  /* works even when overflow. Max span ~ 30 mn */
-}
-
 /*! FUZ_rand() :
     @return : a 27 bits random value, from a 32-bits `seed`.
     `seed` is also modified */
@@ -815,8 +814,6 @@ static size_t FUZ_randomLength(U32* seed, U32 maxLog)
     return FUZ_rLogLength(seed, logLength);
 }
 
-#define MIN(a,b)   ( (a) < (b) ? (a) : (b) )
-
 /* Return value in range minVal <= v <= maxVal */
 static U32 FUZ_randomClampedLength(U32* seed, U32 minVal, U32 maxVal)
 {
@@ -842,7 +839,7 @@ static int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compres
     ZSTD_CStream* zc = ZSTD_createCStream();   /* will be re-created sometimes */
     ZSTD_DStream* zd = ZSTD_createDStream();   /* will be re-created sometimes */
     ZSTD_DStream* const zd_noise = ZSTD_createDStream();
-    clock_t const startClock = clock();
+    UTIL_time_t const startClock = UTIL_getTime();
     const BYTE* dict = NULL;  /* can keep same dict on 2 consecutive tests */
     size_t dictSize = 0;
     U32 oldTestLog = 0;
@@ -872,7 +869,7 @@ static int fuzzerTests(U32 seed, U32 nbTests, unsigned startTest, double compres
         FUZ_rand(&coreSeed);
 
     /* test loop */
-    for ( ; (testNb <= nbTests) || (FUZ_GetClockSpan(startClock) < g_clockTime) ; testNb++ ) {
+    for ( ; (testNb <= nbTests) || (UTIL_clockSpanMicro(startClock) < g_clockTime) ; testNb++ ) {
         U32 lseed;
         const BYTE* srcBuffer;
         size_t totalTestSize, totalGenSize, cSize;
@@ -1092,7 +1089,7 @@ static int fuzzerTests_MT(U32 seed, U32 nbTests, unsigned startTest, double comp
     ZSTDMT_CCtx* zc = ZSTDMT_createCCtx(nbThreads);   /* will be reset sometimes */
     ZSTD_DStream* zd = ZSTD_createDStream();   /* will be reset sometimes */
     ZSTD_DStream* const zd_noise = ZSTD_createDStream();
-    clock_t const startClock = clock();
+    UTIL_time_t const startClock = UTIL_getTime();
     const BYTE* dict=NULL;   /* can keep same dict on 2 consecutive tests */
     size_t dictSize = 0;
     U32 oldTestLog = 0;
@@ -1123,7 +1120,7 @@ static int fuzzerTests_MT(U32 seed, U32 nbTests, unsigned startTest, double comp
         FUZ_rand(&coreSeed);
 
     /* test loop */
-    for ( ; (testNb <= nbTests) || (FUZ_GetClockSpan(startClock) < g_clockTime) ; testNb++ ) {
+    for ( ; (testNb <= nbTests) || (UTIL_clockSpanMicro(startClock) < g_clockTime) ; testNb++ ) {
         U32 lseed;
         const BYTE* srcBuffer;
         size_t totalTestSize, totalGenSize, cSize;
@@ -1364,7 +1361,7 @@ static int fuzzerTests_newAPI(U32 seed, U32 nbTests, unsigned startTest, double
     ZSTD_CCtx* zc = ZSTD_createCCtx();   /* will be reset sometimes */
     ZSTD_DStream* zd = ZSTD_createDStream();   /* will be reset sometimes */
     ZSTD_DStream* const zd_noise = ZSTD_createDStream();
-    clock_t const startClock = clock();
+    UTIL_time_t const startClock = UTIL_getTime();
     const BYTE* dict = NULL;   /* can keep same dict on 2 consecutive tests */
     size_t dictSize = 0;
     U32 oldTestLog = 0;
@@ -1397,7 +1394,7 @@ static int fuzzerTests_newAPI(U32 seed, U32 nbTests, unsigned startTest, double
         FUZ_rand(&coreSeed);
 
     /* test loop */
-    for ( ; (testNb <= nbTests) || (FUZ_GetClockSpan(startClock) < g_clockTime) ; testNb++ ) {
+    for ( ; (testNb <= nbTests) || (UTIL_clockSpanMicro(startClock) < g_clockTime) ; testNb++ ) {
         U32 lseed;
         const BYTE* srcBuffer;
         size_t totalTestSize, totalGenSize, cSize;
@@ -1772,7 +1769,7 @@ int main(int argc, const char** argv)
                         g_clockTime *=60, argument++;
                         if (*argument=='n') argument++; /* -T1mn == -T60 */
                     } else if (*argument=='s') argument++; /* -T10s == -T10 */
-                    g_clockTime *= CLOCKS_PER_SEC;
+                    g_clockTime *= SEC_TO_MICRO;
                     break;
 
                 case 's':   /* manually select seed */

From dab8cfa3c73be56ad3424f0299f1bb3740ac104d Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Thu, 30 Nov 2017 19:40:53 -0800
Subject: [PATCH 095/145] Combine definitions of SEC_TO_MICRO

---
 programs/bench.c     | 1 -
 programs/dibio.c     | 1 -
 programs/fileio.c    | 1 -
 programs/util.h      | 1 +
 tests/decodecorpus.c | 1 -
 tests/fuzzer.c       | 1 -
 tests/paramgrill.c   | 1 -
 tests/zbufftest.c    | 1 -
 tests/zstreamtest.c  | 1 -
 9 files changed, 1 insertion(+), 8 deletions(-)

diff --git a/programs/bench.c b/programs/bench.c
index 384b982f4..63b98e532 100644
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -71,7 +71,6 @@ static U32 g_compressibilityDefault = 50;
 #define DISPLAYLEVEL(l, ...) if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); }
 static int g_displayLevel = 2;   /* 0 : no display;   1: errors;   2 : + result + interaction + warnings;   3 : + progression;   4 : + information */
 
-#define SEC_TO_MICRO 1000000
 static const U64 g_refreshRate = SEC_TO_MICRO / 6;
 static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
 
diff --git a/programs/dibio.c b/programs/dibio.c
index 9cc5264d2..112259ddc 100644
--- a/programs/dibio.c
+++ b/programs/dibio.c
@@ -54,7 +54,6 @@ static const size_t g_maxMemory = (sizeof(size_t) == 4) ? (2 GB - 64 MB) : ((siz
 #define DISPLAY(...)         fprintf(stderr, __VA_ARGS__)
 #define DISPLAYLEVEL(l, ...) if (displayLevel>=l) { DISPLAY(__VA_ARGS__); }
 
-#define SEC_TO_MICRO 1000000
 static const U64 g_refreshRate = SEC_TO_MICRO / 6;
 static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
 
diff --git a/programs/fileio.c b/programs/fileio.c
index 0ea1ad152..c9b6b04e1 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -81,7 +81,6 @@
 static int g_displayLevel = 2;   /* 0 : no display;  1: errors;  2: + result + interaction + warnings;  3: + progression;  4: + information */
 void FIO_setNotificationLevel(unsigned level) { g_displayLevel=level; }
 
-#define SEC_TO_MICRO 1000000
 static const U64 g_refreshRate = SEC_TO_MICRO / 6;
 static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
 
diff --git a/programs/util.h b/programs/util.h
index 41155694e..37098f2f7 100644
--- a/programs/util.h
+++ b/programs/util.h
@@ -216,6 +216,7 @@ static int g_utilDisplayLevel;
     UTIL_STATIC U64 UTIL_getSpanTimeNano(UTIL_time_t clockStart, UTIL_time_t clockEnd) { return 1000000000ULL * (clockEnd - clockStart) / CLOCKS_PER_SEC; }
 #endif
 
+#define SEC_TO_MICRO 1000000
 
 /* returns time span in microseconds */
 UTIL_STATIC U64 UTIL_clockSpanMicro( UTIL_time_t clockStart )
diff --git a/tests/decodecorpus.c b/tests/decodecorpus.c
index 7d7b64664..407653119 100644
--- a/tests/decodecorpus.c
+++ b/tests/decodecorpus.c
@@ -57,7 +57,6 @@ static U32 g_displayLevel = 2;
         }                                                                      \
     } while (0)
 
-#define SEC_TO_MICRO 1000000
 static const U64 g_refreshRate = SEC_TO_MICRO / 6;
 static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
 
diff --git a/tests/fuzzer.c b/tests/fuzzer.c
index 980c36176..46671a15c 100644
--- a/tests/fuzzer.c
+++ b/tests/fuzzer.c
@@ -56,7 +56,6 @@ static const U32 nbTestsDefault = 30000;
 #define DISPLAYLEVEL(l, ...)  if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); }
 static U32 g_displayLevel = 2;
 
-#define SEC_TO_MICRO 1000000
 static const U64 g_refreshRate = SEC_TO_MICRO / 6;
 static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
 
diff --git a/tests/paramgrill.c b/tests/paramgrill.c
index e258932da..ae14aa074 100644
--- a/tests/paramgrill.c
+++ b/tests/paramgrill.c
@@ -39,7 +39,6 @@
 #define MB *(1<<20)
 #define GB *(1ULL<<30)
 
-#define SEC_TO_MICRO 1000000
 #define NBLOOPS    2
 #define TIMELOOP  (2 * SEC_TO_MICRO)
 
diff --git a/tests/zbufftest.c b/tests/zbufftest.c
index f770c8395..9b6f7bad6 100644
--- a/tests/zbufftest.c
+++ b/tests/zbufftest.c
@@ -58,7 +58,6 @@ static const U32 prime2 = 2246822519U;
 #define DISPLAYLEVEL(l, ...)  if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); }
 static U32 g_displayLevel = 2;
 
-#define SEC_TO_MICRO 1000000
 static const U64 g_refreshRate = SEC_TO_MICRO / 6;
 static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
 
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index aad9cba71..207b2e015 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -62,7 +62,6 @@ static const U32 prime32 = 2654435761U;
                                   if (g_displayLevel>=4) fflush(stderr); }
 static U32 g_displayLevel = 2;
 
-#define SEC_TO_MICRO 1000000
 static const U64 g_refreshRate = SEC_TO_MICRO / 6;
 static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
 

From 453fb5e830356559b8a54a5655219a874a39509e Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 1 Dec 2017 10:30:53 -0800
Subject: [PATCH 096/145] removed -ftrapv from tests/ debug flags

-ftrapv is apparently buggy for gcc.
versions >= 5 are supposed to work better,
but even then, some complaints say it's still flaky when optimizations are enabled.
I even saw a post saying it only works if one creates its own signal handler,
which would make this flag no longer transparent.

on clang, it seems to work correctly.
But we would need to add a method to selectively add flags depending on compiler.
That's too much troubles for the intended benefit
(just catch integer overflows, which we can also do using ubsan).
---
 tests/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/Makefile b/tests/Makefile
index 8cc953ec8..f944fd5a8 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -32,7 +32,7 @@ CFLAGS     += -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow                 \
               -Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement \
               -Wstrict-prototypes -Wundef -Wformat-security                   \
               -Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings      \
-              -Wredundant-decls -ftrapv
+              -Wredundant-decls
 CFLAGS     += $(DEBUGFLAGS) $(MOREFLAGS)
 FLAGS       = $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)
 

From 4413ed27e450d7154ffbfa7c17b9313c2fd466fa Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 1 Dec 2017 16:27:24 -0800
Subject: [PATCH 097/145] circleci : make libzstd-nomt had its own test

---
 circle.yml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/circle.yml b/circle.yml
index b488c1a7b..7e042d104 100644
--- a/circle.yml
+++ b/circle.yml
@@ -9,7 +9,7 @@ dependencies:
 test:
   override:
     - ? |
-        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then cc -v; make all   && make clean && make -C lib libzstd-nomt && make clean; fi &&
+        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then cc -v; make all   && make clean; fi &&
         if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make gnu90build   && make clean; fi
       :
         parallel: true
@@ -58,6 +58,10 @@ test:
         if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then true; fi # Could add another test here
       :
         parallel: true
+    - ? |
+        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make -C lib libzstd-nomt && make clean; fi
+      :
+        parallel: true
 
   post:
     - echo Circle CI tests finished

From 519cf3b400b6f87578938ceff3762dc4d85ad07c Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 1 Dec 2017 16:31:40 -0800
Subject: [PATCH 098/145] circleci: add CFLAGS=-O0 environment variable

for faster compilation
---
 circle.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/circle.yml b/circle.yml
index 7e042d104..e7f17979c 100644
--- a/circle.yml
+++ b/circle.yml
@@ -1,3 +1,7 @@
+machine:
+  environment:
+    CFLAGS: -O0   # for faster compilation, will preserve warnings
+
 dependencies:
   override:
     - sudo dpkg --add-architecture i386

From 363355448b5032d062673cb5faf56a742571d190 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 1 Dec 2017 17:02:55 -0800
Subject: [PATCH 099/145] circleci: removed one test node

---
 circle.yml | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/circle.yml b/circle.yml
index e7f17979c..cc494905c 100644
--- a/circle.yml
+++ b/circle.yml
@@ -59,11 +59,7 @@ test:
         parallel: true
     - ? |
         if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make -j regressiontest && make clean; fi &&
-        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then true; fi # Could add another test here
-      :
-        parallel: true
-    - ? |
-        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make -C lib libzstd-nomt && make clean; fi
+        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make -C lib libzstd-nomt && make clean; fi
       :
         parallel: true
 

From 30eeb248a8e85dc60030003dee2677af8c6709c6 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 1 Dec 2017 17:22:04 -0800
Subject: [PATCH 100/145] added environment variable through circleci dashboard

check if it works better
---
 circle.yml | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/circle.yml b/circle.yml
index cc494905c..478775b70 100644
--- a/circle.yml
+++ b/circle.yml
@@ -1,7 +1,3 @@
-machine:
-  environment:
-    CFLAGS: -O0   # for faster compilation, will preserve warnings
-
 dependencies:
   override:
     - sudo dpkg --add-architecture i386

From 74991c2764f32482815569a8efe4ee1e61bdfa71 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 1 Dec 2017 17:28:24 -0800
Subject: [PATCH 101/145] circleci: removed gccX/clang tests

does no longer need to install these large packages
---
 circle.yml | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/circle.yml b/circle.yml
index 478775b70..85061faa6 100644
--- a/circle.yml
+++ b/circle.yml
@@ -3,7 +3,6 @@ dependencies:
     - sudo dpkg --add-architecture i386
     - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test; sudo apt-get -y -qq update
     - sudo apt-get -y install gcc-powerpc-linux-gnu gcc-arm-linux-gnueabi libc6-dev-armel-cross gcc-aarch64-linux-gnu libc6-dev-arm64-cross
-    - sudo apt-get -y install libstdc++-7-dev clang gcc g++ gcc-5 gcc-6 gcc-7 zlib1g-dev liblzma-dev
     - sudo apt-get -y install linux-libc-dev:i386 libc6-dev-i386
 
 test:
@@ -25,12 +24,7 @@ test:
         parallel: true
     - ? |
         if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make cxxtest      && make clean; fi &&
-        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make gcc5build    && make clean; fi
-      :
-        parallel: true
-    - ? |
-        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make gcc6build    && make clean; fi &&
-        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make clangbuild   && make clean; fi
+        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make ppc64build   && make clean; fi
       :
         parallel: true
     - ? |
@@ -43,11 +37,6 @@ test:
         if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make ppcbuild     && make clean; fi
       :
         parallel: true
-    - ? |
-        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make ppc64build   && make clean; fi &&
-        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make gcc7build    && make clean; fi
-      :
-        parallel: true
     - ? |
         if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make shortest     && make clean; fi &&
         if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make -C tests test-legacy test-longmatch test-symbols && make clean; fi

From c6f5bf071cd3e246b3a4dae990489d3294e499eb Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 1 Dec 2017 17:35:19 -0800
Subject: [PATCH 102/145] fixed powerpc test

misspelled CFLAGS
---
 Makefile   | 2 +-
 circle.yml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index 9c2657052..c8f0ed4d4 100644
--- a/Makefile
+++ b/Makefile
@@ -161,7 +161,7 @@ aarch64build: clean
 	CC=aarch64-linux-gnu-gcc CFLAGS="-Werror" $(MAKE) allzstd
 
 ppcbuild: clean
-	CC=powerpc-linux-gnu-gcc CLAGS="-m32 -Wno-attributes -Werror" $(MAKE) allzstd
+	CC=powerpc-linux-gnu-gcc CFLAGS="-m32 -Wno-attributes -Werror" $(MAKE) allzstd
 
 ppc64build: clean
 	CC=powerpc-linux-gnu-gcc CFLAGS="-m64 -Werror" $(MAKE) allzstd
diff --git a/circle.yml b/circle.yml
index 85061faa6..3b9facced 100644
--- a/circle.yml
+++ b/circle.yml
@@ -8,7 +8,7 @@ dependencies:
 test:
   override:
     - ? |
-        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then cc -v; make all   && make clean; fi &&
+        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then cc -v; CFLAGS="-O0 -Werror" make all && make clean; fi &&
         if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make gnu90build   && make clean; fi
       :
         parallel: true

From 71f012e5bfbebe91ca89d9fcc5700a26f0dadc87 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 1 Dec 2017 17:42:46 -0800
Subject: [PATCH 103/145] zstdcli: fixed minor warning when bench module not
 enabled

one variable defined but not used
---
 programs/zstdcli.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/programs/zstdcli.c b/programs/zstdcli.c
index 91af49e24..8b4186207 100644
--- a/programs/zstdcli.c
+++ b/programs/zstdcli.c
@@ -773,8 +773,9 @@ int main(int argCount, const char* argv[])
             BMK_setLdmHashEveryLog(g_ldmHashEveryLog);
         }
         BMK_benchFiles(filenameTable, filenameIdx, dictFileName, cLevel, cLevelLast, &compressionParams);
+#else
+        (void)bench_nbSeconds; (void)blockSize; (void)setRealTimePrio; (void)separateFiles;
 #endif
-        (void)bench_nbSeconds; (void)blockSize; (void)setRealTimePrio;
         goto _end;
     }
 

From 6127592391bfda25154a5167954eda6b38e6efde Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 1 Dec 2017 17:56:16 -0800
Subject: [PATCH 104/145] circleci : removed cmaketest

strange error on pthread detection
(seems a bug in cmake detection, since
`make zstd` works perfectly with `-pthread` on same conf)
---
 circle.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/circle.yml b/circle.yml
index 3b9facced..07f2990dd 100644
--- a/circle.yml
+++ b/circle.yml
@@ -19,7 +19,7 @@ test:
         parallel: true
     - ? |
         if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make c11build     && make clean; fi &&
-        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make cmakebuild   && make clean; fi
+        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make -C lib libzstd-nomt && make clean; fi
       :
         parallel: true
     - ? |
@@ -44,7 +44,7 @@ test:
         parallel: true
     - ? |
         if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make -j regressiontest && make clean; fi &&
-        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make -C lib libzstd-nomt && make clean; fi
+        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then true; fi   # can add one more test here
       :
         parallel: true
 

From 272c14233032eb02b79f8d2e69364a9e90ed7ae7 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 1 Dec 2017 18:11:34 -0800
Subject: [PATCH 105/145] circleci : balance some tests

try to group them by "equivalent" duration
since next job will not start as long as previous one is not completed on both VM
---
 circle.yml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/circle.yml b/circle.yml
index 07f2990dd..9b87ea565 100644
--- a/circle.yml
+++ b/circle.yml
@@ -19,11 +19,6 @@ test:
         parallel: true
     - ? |
         if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make c11build     && make clean; fi &&
-        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make -C lib libzstd-nomt && make clean; fi
-      :
-        parallel: true
-    - ? |
-        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make cxxtest      && make clean; fi &&
         if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make ppc64build   && make clean; fi
       :
         parallel: true
@@ -42,6 +37,11 @@ test:
         if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make -C tests test-legacy test-longmatch test-symbols && make clean; fi
       :
         parallel: true
+    - ? |
+        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make cxxtest      && make clean; fi &&
+        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make -C lib libzstd-nomt && make clean; fi
+      :
+        parallel: true
     - ? |
         if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make -j regressiontest && make clean; fi &&
         if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then true; fi   # can add one more test here

From 6f1377301f7a33f39c9bbd9354730141f627733e Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 1 Dec 2017 18:34:22 -0800
Subject: [PATCH 106/145] circleci: removed -m32 tests

installing dependencies costs ~2mn, making it the longest test
(test itself was < 15sec)
---
 circle.yml | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/circle.yml b/circle.yml
index 9b87ea565..ed50d59e5 100644
--- a/circle.yml
+++ b/circle.yml
@@ -3,7 +3,6 @@ dependencies:
     - sudo dpkg --add-architecture i386
     - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test; sudo apt-get -y -qq update
     - sudo apt-get -y install gcc-powerpc-linux-gnu gcc-arm-linux-gnueabi libc6-dev-armel-cross gcc-aarch64-linux-gnu libc6-dev-arm64-cross
-    - sudo apt-get -y install linux-libc-dev:i386 libc6-dev-i386
 
 test:
   override:
@@ -23,13 +22,13 @@ test:
       :
         parallel: true
     - ? |
-        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make m32build     && make clean; fi &&
-        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make armbuild     && make clean; fi
+        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make aarch64build && make clean; fi &&
+        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make ppcbuild     && make clean; fi
       :
         parallel: true
     - ? |
-        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make aarch64build && make clean; fi &&
-        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make ppcbuild     && make clean; fi
+        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make -j regressiontest && make clean; fi &&
+        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make armbuild     && make clean; fi
       :
         parallel: true
     - ? |
@@ -42,11 +41,6 @@ test:
         if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then make -C lib libzstd-nomt && make clean; fi
       :
         parallel: true
-    - ? |
-        if [[ "$CIRCLE_NODE_INDEX" == "0" ]]                                    ; then make -j regressiontest && make clean; fi &&
-        if [[ "$CIRCLE_NODE_TOTAL" < "2" ]] || [[ "$CIRCLE_NODE_INDEX" == "1" ]]; then true; fi   # can add one more test here
-      :
-        parallel: true
 
   post:
     - echo Circle CI tests finished

From 5e1f34b7e4c407f7f733c09c435141d18de2dc18 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 1 Dec 2017 21:17:09 -0800
Subject: [PATCH 107/145] setParameter : no side-effect on setting a
 compression parameter

last such side-effect was modifying cctx->loadedDictEnd on setting forceWindow.
It is no a useless operation, so it's removed.
No side-effect left when setting a compression parameter.
---
 lib/compress/zstd_compress.c   | 37 ++++------------------------------
 lib/compress/zstdmt_compress.c |  2 +-
 2 files changed, 5 insertions(+), 34 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index bc2d8a576..8d493852f 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -270,9 +270,8 @@ size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned v
         return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 
     case ZSTD_p_forceMaxWindow :  /* Force back-references to remain < windowSize,
-                                   * even when referencing into Dictionary content
+                                   * even when referencing into Dictionary content.
                                    * default : 0 when using a CDict, 1 when using a Prefix */
-        cctx->loadedDictEnd = 0;  /* ? */
         return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 
     case ZSTD_p_nbThreads:
@@ -461,13 +460,9 @@ size_t ZSTD_CCtxParam_setParameter(
     }
 }
 
-/**
- * This function should be updated whenever ZSTD_CCtx_params is updated.
- * Parameters are copied manually before the dictionary is loaded.
- * The multithreading parameters jobSize and overlapSizeLog are set only if
- * nbThreads > 1.
- *
- * pledgedSrcSize is considered unknown
+/** ZSTD_CCtx_setParametersUsingCCtxParams() :
+ *  just applies `params` into `cctx`
+ *  no action is performed, parameters are merely stored.
  */
 size_t ZSTD_CCtx_setParametersUsingCCtxParams(
         ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params)
@@ -475,31 +470,8 @@ size_t ZSTD_CCtx_setParametersUsingCCtxParams(
     if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
     if (cctx->cdict) return ERROR(stage_wrong);
 
-#if 1
     cctx->requestedParams = *params;
-#else
-    /* Assume the compression and frame parameters are validated */
-    cctx->requestedParams.cParams = params->cParams;
-    cctx->requestedParams.fParams = params->fParams;
-    cctx->requestedParams.compressionLevel = params->compressionLevel;
 
-    /* Set force window explicitly since it sets cctx->loadedDictEnd */
-    CHECK_F( ZSTD_CCtx_setParameter(
-                   cctx, ZSTD_p_forceMaxWindow, params->forceWindow) );
-
-    /* Set multithreading parameters explicitly */
-    CHECK_F( ZSTD_CCtx_setParameter(cctx, ZSTD_p_nbThreads, params->nbThreads) );
-    if (params->nbThreads > 1) {
-        CHECK_F( ZSTD_CCtx_setParameter(cctx, ZSTD_p_jobSize, params->jobSize) );
-        CHECK_F( ZSTD_CCtx_setParameter(
-                    cctx, ZSTD_p_overlapSizeLog, params->overlapSizeLog) );
-    }
-
-    /* Copy long distance matching parameters */
-    cctx->requestedParams.ldmParams = params->ldmParams;
-#endif
-
-    /* customMem is used only for create/free params and can be ignored */
     return 0;
 }
 
@@ -2097,7 +2069,6 @@ size_t ZSTD_compressBegin_advanced_internal(
                                     unsigned long long pledgedSrcSize)
 {
     DEBUGLOG(4, "ZSTD_compressBegin_advanced_internal");
-    DEBUGLOG(4, "contentSizeFlag : %u", params.fParams.contentSizeFlag);
     /* compression parameters verification and optimization */
     CHECK_F( ZSTD_checkCParams(params.cParams) );
     return ZSTD_compressBegin_internal(cctx, dict, dictSize, dictMode, NULL,
diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c
index ce813dccc..6b6466fe5 100644
--- a/lib/compress/zstdmt_compress.c
+++ b/lib/compress/zstdmt_compress.c
@@ -359,7 +359,7 @@ void ZSTDMT_compressChunk(void* jobDescription)
         assert(job->firstChunk); /* should only happen for first segment */
         if (ZSTD_isError(initError)) { job->cSize = initError; goto _endJob; }
     } else {  /* srcStart points at reloaded section */
-        ZSTD_CCtx_params jobParams = job->params;
+        ZSTD_CCtx_params jobParams = job->params;   /* do not modify job->params ! copy it, modify the copy */
         size_t const forceWindowError = ZSTD_CCtxParam_setParameter(&jobParams, ZSTD_p_forceMaxWindow, !job->firstChunk);
         U64 const pledgedSrcSize = job->firstChunk ? job->fullFrameSize : ZSTD_CONTENTSIZE_UNKNOWN;
         /* load dictionary in "content-only" mode (no header analysis) */

From 55faa5492d5ba593746868991556e593134e6b57 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Mon, 4 Dec 2017 11:26:59 -0800
Subject: [PATCH 108/145] fileio: fixed LZ4F invocation from assert()

---
 programs/fileio.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/programs/fileio.c b/programs/fileio.c
index c9b6b04e1..101c99b1a 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -639,7 +639,6 @@ static unsigned long long FIO_compressLz4Frame(cRess_t* ress,
     memset(&prefs, 0, sizeof(prefs));
 
     assert(blockSize <= ress->srcBufferSize);
-    assert(LZ4F_compressBound(blockSize) <= ress->dstBufferSize);
 
     prefs.autoFlush = 1;
     prefs.compressionLevel = compressionLevel;
@@ -649,6 +648,7 @@ static unsigned long long FIO_compressLz4Frame(cRess_t* ress,
 #if LZ4_VERSION_NUMBER >= 10600
     prefs.frameInfo.contentSize = (srcFileSize==UTIL_FILESIZE_UNKNOWN) ? 0 : srcFileSize;
 #endif
+    assert(LZ4F_compressBound(blockSize, &prefs) <= ress->dstBufferSize);
 
     {
         size_t readSize;

From e46194bbf95aa11b81f3cc1be83f13d3f888421d Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Mon, 4 Dec 2017 15:57:01 -0800
Subject: [PATCH 109/145] fix #911 : changed detection macro for
 clock_gettime()

The new macro might be a bit too restrictive.
Systems which do not support new test will simply default to <time.h>'s `clock_t clock()`,
suffering lesser benchmark accuracy.
Should it matter, the detection macro will have to be upgraded.
---
 programs/util.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/programs/util.h b/programs/util.h
index 37098f2f7..f510bc5e0 100644
--- a/programs/util.h
+++ b/programs/util.h
@@ -168,7 +168,7 @@ static int g_utilDisplayLevel;
         }
         return ((clockEnd - clockStart) * (U64)rate.numer) / ((U64)rate.denom);
     }
-#elif (PLATFORM_POSIX_VERSION >= 200112L)
+#elif defined __UCLIBC__ || ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 17) || __GLIBC__ > 2)
     #include <time.h>
     #define UTIL_TIME_INITIALIZER { 0, 0 }
     typedef struct timespec UTIL_freq_t;

From 00974692380e79ea702e99214c6e7acf672c058e Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Mon, 4 Dec 2017 16:02:42 -0800
Subject: [PATCH 110/145] removed a few redundant #include

---
 programs/util.h | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/programs/util.h b/programs/util.h
index f510bc5e0..38dad2ab4 100644
--- a/programs/util.h
+++ b/programs/util.h
@@ -34,7 +34,7 @@ extern "C" {
 #  include <unistd.h>     /* chown, stat */
 #  include <utime.h>      /* utime */
 #endif
-#include <time.h>         /* time */
+#include <time.h>         /* clock_t, clock, CLOCKS_PER_SEC, nanosleep */
 #include <errno.h>
 #include "mem.h"          /* U32, U64 */
 
@@ -64,7 +64,6 @@ extern "C" {
 #elif PLATFORM_POSIX_VERSION >= 0 /* Unix-like operating system */
 #  include <unistd.h>
 #  include <sys/resource.h> /* setpriority */
-#  include <time.h>         /* clock_t, nanosleep, clock, CLOCKS_PER_SEC */
 #  if defined(PRIO_PROCESS)
 #    define SET_REALTIME_PRIORITY setpriority(PRIO_PROCESS, 0, -20)
 #  else
@@ -169,7 +168,6 @@ static int g_utilDisplayLevel;
         return ((clockEnd - clockStart) * (U64)rate.numer) / ((U64)rate.denom);
     }
 #elif defined __UCLIBC__ || ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 17) || __GLIBC__ > 2)
-    #include <time.h>
     #define UTIL_TIME_INITIALIZER { 0, 0 }
     typedef struct timespec UTIL_freq_t;
     typedef struct timespec UTIL_time_t;

From 31293330d0cd3295646b208f5fa05cfa1ad8914c Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Mon, 4 Dec 2017 16:31:59 -0800
Subject: [PATCH 111/145] It's still necessary to check PLATFORM_POSIX_VERSION
 for clock_gettime()

glibc/uclibc is not enough
---
 programs/util.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/programs/util.h b/programs/util.h
index 38dad2ab4..af1fa7fca 100644
--- a/programs/util.h
+++ b/programs/util.h
@@ -167,7 +167,7 @@ static int g_utilDisplayLevel;
         }
         return ((clockEnd - clockStart) * (U64)rate.numer) / ((U64)rate.denom);
     }
-#elif defined __UCLIBC__ || ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 17) || __GLIBC__ > 2)
+#elif (PLATFORM_POSIX_VERSION >= 200112L) && (defined __UCLIBC__ || ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 17) || __GLIBC__ > 2))
     #define UTIL_TIME_INITIALIZER { 0, 0 }
     typedef struct timespec UTIL_freq_t;
     typedef struct timespec UTIL_time_t;

From c173dbd6e766bf894b1e846c82ab7a00fb0e7481 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Mon, 4 Dec 2017 17:57:42 -0800
Subject: [PATCH 112/145] no longer supported starting C++17

---
 contrib/long_distance_matching/ldm.c  |  3 +-
 lib/common/bitstream.h                |  2 +-
 lib/compress/zstd_compress_internal.h |  2 +-
 lib/dictBuilder/zdict.c               |  2 +-
 lib/legacy/zstd_v01.c                 |  2 +-
 lib/legacy/zstd_v02.c                 | 75 +-------------------------
 lib/legacy/zstd_v03.c                 | 75 +-------------------------
 lib/legacy/zstd_v04.c                 | 73 +------------------------
 lib/legacy/zstd_v05.c                 | 74 +------------------------
 lib/legacy/zstd_v06.c                 | 78 +--------------------------
 lib/legacy/zstd_v07.c                 | 78 +--------------------------
 11 files changed, 11 insertions(+), 453 deletions(-)

diff --git a/contrib/long_distance_matching/ldm.c b/contrib/long_distance_matching/ldm.c
index 4dccd0bfa..37b188b72 100644
--- a/contrib/long_distance_matching/ldm.c
+++ b/contrib/long_distance_matching/ldm.c
@@ -141,7 +141,7 @@ static LDM_hashEntry *getBucket(const LDM_hashTable *table, const hash_t hash) {
   return table->entries + (hash << HASH_BUCKET_SIZE_LOG);
 }
 
-static unsigned ZSTD_NbCommonBytes (register size_t val) {
+static unsigned ZSTD_NbCommonBytes (size_t val) {
   if (MEM_isLittleEndian()) {
     if (MEM_64bits()) {
 #    if defined(_MSC_VER) && defined(_WIN64)
@@ -854,4 +854,3 @@ void LDM_outputConfiguration(void) {
   printf("HASH_CHAR_OFFSET: %d\n", HASH_CHAR_OFFSET);
   printf("=====================\n");
 }
-
diff --git a/lib/common/bitstream.h b/lib/common/bitstream.h
index 2094823fe..fcf384307 100644
--- a/lib/common/bitstream.h
+++ b/lib/common/bitstream.h
@@ -167,7 +167,7 @@ MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
 /*-**************************************************************
 *  Internal functions
 ****************************************************************/
-MEM_STATIC unsigned BIT_highbit32 (register U32 val)
+MEM_STATIC unsigned BIT_highbit32 (U32 val)
 {
     assert(val != 0);
     {
diff --git a/lib/compress/zstd_compress_internal.h b/lib/compress/zstd_compress_internal.h
index 1308541f4..278f2427c 100644
--- a/lib/compress/zstd_compress_internal.h
+++ b/lib/compress/zstd_compress_internal.h
@@ -268,7 +268,7 @@ MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const v
 /*-*************************************
 *  Match length counter
 ***************************************/
-static unsigned ZSTD_NbCommonBytes (register size_t val)
+static unsigned ZSTD_NbCommonBytes (size_t val)
 {
     if (MEM_isLittleEndian()) {
         if (MEM_64bits()) {
diff --git a/lib/dictBuilder/zdict.c b/lib/dictBuilder/zdict.c
index 1bb8b0683..e8f454045 100644
--- a/lib/dictBuilder/zdict.c
+++ b/lib/dictBuilder/zdict.c
@@ -103,7 +103,7 @@ unsigned ZDICT_getDictID(const void* dictBuffer, size_t dictSize)
 /*-********************************************************
 *  Dictionary training functions
 **********************************************************/
-static unsigned ZDICT_NbCommonBytes (register size_t val)
+static unsigned ZDICT_NbCommonBytes (size_t val)
 {
     if (MEM_isLittleEndian()) {
         if (MEM_64bits()) {
diff --git a/lib/legacy/zstd_v01.c b/lib/legacy/zstd_v01.c
index 70003cbed..ae1cb2ce5 100644
--- a/lib/legacy/zstd_v01.c
+++ b/lib/legacy/zstd_v01.c
@@ -339,7 +339,7 @@ typedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];
 /****************************************************************
 *  Internal functions
 ****************************************************************/
-FORCE_INLINE unsigned FSE_highbit32 (register U32 val)
+FORCE_INLINE unsigned FSE_highbit32 (U32 val)
 {
 #   if defined(_MSC_VER)   /* Visual */
     unsigned long r;
diff --git a/lib/legacy/zstd_v02.c b/lib/legacy/zstd_v02.c
index b935a4d18..8bc0eceed 100644
--- a/lib/legacy/zstd_v02.c
+++ b/lib/legacy/zstd_v02.c
@@ -330,18 +330,6 @@ MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
 MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
 
 
-/*
-* Start by invoking BIT_initDStream().
-* A chunk of the bitStream is then stored into a local register.
-* Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
-* You can then retrieve bitFields stored into the local register, **in reverse order**.
-* Local register is manually filled from memory by the BIT_reloadDStream() method.
-* A reload guarantee a minimum of ((8*sizeof(size_t))-7) bits when its result is BIT_DStream_unfinished.
-* Otherwise, it can be less than that, so proceed accordingly.
-* Checking if DStream has reached its end can be performed with BIT_endOfDStream()
-*/
-
-
 /******************************************
 *  unsafe API
 ******************************************/
@@ -353,7 +341,7 @@ MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
 /****************************************************************
 *  Helper functions
 ****************************************************************/
-MEM_STATIC unsigned BIT_highbit32 (register U32 val)
+MEM_STATIC unsigned BIT_highbit32 (U32 val)
 {
 #   if defined(_MSC_VER)   /* Visual */
     unsigned long r=0;
@@ -427,13 +415,6 @@ MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, si
     return srcSize;
 }
 
-/*!BIT_lookBits
- * Provides next n bits from local register
- * local register is not modified (bits are still present for next read/look)
- * On 32-bits, maxNbBits==25
- * On 64-bits, maxNbBits==57
- * @return : value extracted
- */
 MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits)
 {
     const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
@@ -453,11 +434,6 @@ MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
     bitD->bitsConsumed += nbBits;
 }
 
-/*!BIT_readBits
- * Read next n bits from local register.
- * pay attention to not read more than nbBits contained into local register.
- * @return : extracted value.
- */
 MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)
 {
     size_t value = BIT_lookBits(bitD, nbBits);
@@ -695,55 +671,6 @@ static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bi
 
 static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
 
-/*
-Let's now decompose FSE_decompress_usingDTable() into its unitary components.
-You will decode FSE-encoded symbols from the bitStream,
-and also any other bitFields you put in, **in reverse order**.
-
-You will need a few variables to track your bitStream. They are :
-
-BIT_DStream_t DStream;    // Stream context
-FSE_DState_t  DState;     // State context. Multiple ones are possible
-FSE_DTable*   DTablePtr;  // Decoding table, provided by FSE_buildDTable()
-
-The first thing to do is to init the bitStream.
-    errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize);
-
-You should then retrieve your initial state(s)
-(in reverse flushing order if you have several ones) :
-    errorCode = FSE_initDState(&DState, &DStream, DTablePtr);
-
-You can then decode your data, symbol after symbol.
-For information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'.
-Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).
-    unsigned char symbol = FSE_decodeSymbol(&DState, &DStream);
-
-You can retrieve any bitfield you eventually stored into the bitStream (in reverse order)
-Note : maximum allowed nbBits is 25, for 32-bits compatibility
-    size_t bitField = BIT_readBits(&DStream, nbBits);
-
-All above operations only read from local register (which size depends on size_t).
-Refueling the register from memory is manually performed by the reload method.
-    endSignal = FSE_reloadDStream(&DStream);
-
-BIT_reloadDStream() result tells if there is still some more data to read from DStream.
-BIT_DStream_unfinished : there is still some data left into the DStream.
-BIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.
-BIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.
-BIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted.
-
-When reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,
-to properly detect the exact end of stream.
-After each decoded symbol, check if DStream is fully consumed using this simple test :
-    BIT_reloadDStream(&DStream) >= BIT_DStream_completed
-
-When it's done, verify decompression is fully completed, by checking both DStream and the relevant states.
-Checking if DStream has reached its end is performed by :
-    BIT_endOfDStream(&DStream);
-Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.
-    FSE_endOfDState(&DState);
-*/
-
 
 /******************************************
 *  FSE unsafe API
diff --git a/lib/legacy/zstd_v03.c b/lib/legacy/zstd_v03.c
index 35370dd0c..54445af57 100644
--- a/lib/legacy/zstd_v03.c
+++ b/lib/legacy/zstd_v03.c
@@ -332,17 +332,6 @@ MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
 MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
 
 
-/*
-* Start by invoking BIT_initDStream().
-* A chunk of the bitStream is then stored into a local register.
-* Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
-* You can then retrieve bitFields stored into the local register, **in reverse order**.
-* Local register is manually filled from memory by the BIT_reloadDStream() method.
-* A reload guarantee a minimum of ((8*sizeof(size_t))-7) bits when its result is BIT_DStream_unfinished.
-* Otherwise, it can be less than that, so proceed accordingly.
-* Checking if DStream has reached its end can be performed with BIT_endOfDStream()
-*/
-
 
 /******************************************
 *  unsafe API
@@ -355,7 +344,7 @@ MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
 /****************************************************************
 *  Helper functions
 ****************************************************************/
-MEM_STATIC unsigned BIT_highbit32 (register U32 val)
+MEM_STATIC unsigned BIT_highbit32 (U32 val)
 {
 #   if defined(_MSC_VER)   /* Visual */
     unsigned long r=0;
@@ -428,14 +417,6 @@ MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, si
 
     return srcSize;
 }
-
-/*!BIT_lookBits
- * Provides next n bits from local register
- * local register is not modified (bits are still present for next read/look)
- * On 32-bits, maxNbBits==25
- * On 64-bits, maxNbBits==57
- * @return : value extracted
- */
 MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits)
 {
     const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
@@ -455,11 +436,6 @@ MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
     bitD->bitsConsumed += nbBits;
 }
 
-/*!BIT_readBits
- * Read next n bits from local register.
- * pay attention to not read more than nbBits contained into local register.
- * @return : extracted value.
- */
 MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)
 {
     size_t value = BIT_lookBits(bitD, nbBits);
@@ -697,55 +673,6 @@ static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bi
 
 static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
 
-/*
-Let's now decompose FSE_decompress_usingDTable() into its unitary components.
-You will decode FSE-encoded symbols from the bitStream,
-and also any other bitFields you put in, **in reverse order**.
-
-You will need a few variables to track your bitStream. They are :
-
-BIT_DStream_t DStream;    // Stream context
-FSE_DState_t  DState;     // State context. Multiple ones are possible
-FSE_DTable*   DTablePtr;  // Decoding table, provided by FSE_buildDTable()
-
-The first thing to do is to init the bitStream.
-    errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize);
-
-You should then retrieve your initial state(s)
-(in reverse flushing order if you have several ones) :
-    errorCode = FSE_initDState(&DState, &DStream, DTablePtr);
-
-You can then decode your data, symbol after symbol.
-For information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'.
-Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).
-    unsigned char symbol = FSE_decodeSymbol(&DState, &DStream);
-
-You can retrieve any bitfield you eventually stored into the bitStream (in reverse order)
-Note : maximum allowed nbBits is 25, for 32-bits compatibility
-    size_t bitField = BIT_readBits(&DStream, nbBits);
-
-All above operations only read from local register (which size depends on size_t).
-Refueling the register from memory is manually performed by the reload method.
-    endSignal = FSE_reloadDStream(&DStream);
-
-BIT_reloadDStream() result tells if there is still some more data to read from DStream.
-BIT_DStream_unfinished : there is still some data left into the DStream.
-BIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.
-BIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.
-BIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted.
-
-When reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,
-to properly detect the exact end of stream.
-After each decoded symbol, check if DStream is fully consumed using this simple test :
-    BIT_reloadDStream(&DStream) >= BIT_DStream_completed
-
-When it's done, verify decompression is fully completed, by checking both DStream and the relevant states.
-Checking if DStream has reached its end is performed by :
-    BIT_endOfDStream(&DStream);
-Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.
-    FSE_endOfDState(&DState);
-*/
-
 
 /******************************************
 *  FSE unsafe API
diff --git a/lib/legacy/zstd_v04.c b/lib/legacy/zstd_v04.c
index 1b5f6f3b0..1ff7c95e0 100644
--- a/lib/legacy/zstd_v04.c
+++ b/lib/legacy/zstd_v04.c
@@ -738,16 +738,6 @@ MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
 MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
 
 
-/*
-* Start by invoking BIT_initDStream().
-* A chunk of the bitStream is then stored into a local register.
-* Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
-* You can then retrieve bitFields stored into the local register, **in reverse order**.
-* Local register is manually filled from memory by the BIT_reloadDStream() method.
-* A reload guarantee a minimum of ((8*sizeof(size_t))-7) bits when its result is BIT_DStream_unfinished.
-* Otherwise, it can be less than that, so proceed accordingly.
-* Checking if DStream has reached its end can be performed with BIT_endOfDStream()
-*/
 
 
 /******************************************
@@ -761,7 +751,7 @@ MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
 /****************************************************************
 *  Helper functions
 ****************************************************************/
-MEM_STATIC unsigned BIT_highbit32 (register U32 val)
+MEM_STATIC unsigned BIT_highbit32 (U32 val)
 {
 #   if defined(_MSC_VER)   /* Visual */
     unsigned long r=0;
@@ -834,13 +824,6 @@ MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, si
     return srcSize;
 }
 
-/*!BIT_lookBits
- * Provides next n bits from local register
- * local register is not modified (bits are still present for next read/look)
- * On 32-bits, maxNbBits==25
- * On 64-bits, maxNbBits==57
- * @return : value extracted
- */
 MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits)
 {
     const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
@@ -860,11 +843,6 @@ MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
     bitD->bitsConsumed += nbBits;
 }
 
-/*!BIT_readBits
- * Read next n bits from local register.
- * pay attention to not read more than nbBits contained into local register.
- * @return : extracted value.
- */
 MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)
 {
     size_t value = BIT_lookBits(bitD, nbBits);
@@ -1011,55 +989,6 @@ static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bi
 
 static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
 
-/*!
-Let's now decompose FSE_decompress_usingDTable() into its unitary components.
-You will decode FSE-encoded symbols from the bitStream,
-and also any other bitFields you put in, **in reverse order**.
-
-You will need a few variables to track your bitStream. They are :
-
-BIT_DStream_t DStream;    // Stream context
-FSE_DState_t  DState;     // State context. Multiple ones are possible
-FSE_DTable*   DTablePtr;  // Decoding table, provided by FSE_buildDTable()
-
-The first thing to do is to init the bitStream.
-    errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize);
-
-You should then retrieve your initial state(s)
-(in reverse flushing order if you have several ones) :
-    errorCode = FSE_initDState(&DState, &DStream, DTablePtr);
-
-You can then decode your data, symbol after symbol.
-For information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'.
-Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).
-    unsigned char symbol = FSE_decodeSymbol(&DState, &DStream);
-
-You can retrieve any bitfield you eventually stored into the bitStream (in reverse order)
-Note : maximum allowed nbBits is 25, for 32-bits compatibility
-    size_t bitField = BIT_readBits(&DStream, nbBits);
-
-All above operations only read from local register (which size depends on size_t).
-Refueling the register from memory is manually performed by the reload method.
-    endSignal = FSE_reloadDStream(&DStream);
-
-BIT_reloadDStream() result tells if there is still some more data to read from DStream.
-BIT_DStream_unfinished : there is still some data left into the DStream.
-BIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.
-BIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.
-BIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted.
-
-When reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,
-to properly detect the exact end of stream.
-After each decoded symbol, check if DStream is fully consumed using this simple test :
-    BIT_reloadDStream(&DStream) >= BIT_DStream_completed
-
-When it's done, verify decompression is fully completed, by checking both DStream and the relevant states.
-Checking if DStream has reached its end is performed by :
-    BIT_endOfDStream(&DStream);
-Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.
-    FSE_endOfDState(&DState);
-*/
-
 
 /* *****************************************
 *  FSE unsafe API
diff --git a/lib/legacy/zstd_v05.c b/lib/legacy/zstd_v05.c
index 23188f504..a5e1b1ffc 100644
--- a/lib/legacy/zstd_v05.c
+++ b/lib/legacy/zstd_v05.c
@@ -736,18 +736,6 @@ MEM_STATIC BITv05_DStream_status BITv05_reloadDStream(BITv05_DStream_t* bitD);
 MEM_STATIC unsigned BITv05_endOfDStream(const BITv05_DStream_t* bitD);
 
 
-/*!
-* Start by invoking BITv05_initDStream().
-* A chunk of the bitStream is then stored into a local register.
-* Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
-* You can then retrieve bitFields stored into the local register, **in reverse order**.
-* Local register is explicitly reloaded from memory by the BITv05_reloadDStream() method.
-* A reload guarantee a minimum of ((8*sizeof(size_t))-7) bits when its result is BITv05_DStream_unfinished.
-* Otherwise, it can be less than that, so proceed accordingly.
-* Checking if DStream has reached its end can be performed with BITv05_endOfDStream()
-*/
-
-
 /*-****************************************
 *  unsafe API
 ******************************************/
@@ -759,7 +747,7 @@ MEM_STATIC size_t BITv05_readBitsFast(BITv05_DStream_t* bitD, unsigned nbBits);
 /*-**************************************************************
 *  Helper functions
 ****************************************************************/
-MEM_STATIC unsigned BITv05_highbit32 (register U32 val)
+MEM_STATIC unsigned BITv05_highbit32 (U32 val)
 {
 #   if defined(_MSC_VER)   /* Visual */
     unsigned long r=0;
@@ -829,13 +817,6 @@ MEM_STATIC size_t BITv05_initDStream(BITv05_DStream_t* bitD, const void* srcBuff
     return srcSize;
 }
 
-/*!BITv05_lookBits
- * Provides next n bits from local register
- * local register is not modified (bits are still present for next read/look)
- * On 32-bits, maxNbBits==25
- * On 64-bits, maxNbBits==57
- * @return : value extracted
- */
 MEM_STATIC size_t BITv05_lookBits(BITv05_DStream_t* bitD, U32 nbBits)
 {
     const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
@@ -855,11 +836,6 @@ MEM_STATIC void BITv05_skipBits(BITv05_DStream_t* bitD, U32 nbBits)
     bitD->bitsConsumed += nbBits;
 }
 
-/*!BITv05_readBits
- * Read next n bits from local register.
- * pay attention to not read more than nbBits contained into local register.
- * @return : extracted value.
- */
 MEM_STATIC size_t BITv05_readBits(BITv05_DStream_t* bitD, U32 nbBits)
 {
     size_t value = BITv05_lookBits(bitD, nbBits);
@@ -995,54 +971,6 @@ static unsigned char FSEv05_decodeSymbol(FSEv05_DState_t* DStatePtr, BITv05_DStr
 
 static unsigned FSEv05_endOfDState(const FSEv05_DState_t* DStatePtr);
 
-/*!
-Let's now decompose FSEv05_decompress_usingDTable() into its unitary components.
-You will decode FSEv05-encoded symbols from the bitStream,
-and also any other bitFields you put in, **in reverse order**.
-
-You will need a few variables to track your bitStream. They are :
-
-BITv05_DStream_t DStream;    // Stream context
-FSEv05_DState_t  DState;     // State context. Multiple ones are possible
-FSEv05_DTable*   DTablePtr;  // Decoding table, provided by FSEv05_buildDTable()
-
-The first thing to do is to init the bitStream.
-    errorCode = BITv05_initDStream(&DStream, srcBuffer, srcSize);
-
-You should then retrieve your initial state(s)
-(in reverse flushing order if you have several ones) :
-    errorCode = FSEv05_initDState(&DState, &DStream, DTablePtr);
-
-You can then decode your data, symbol after symbol.
-For information the maximum number of bits read by FSEv05_decodeSymbol() is 'tableLog'.
-Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).
-    unsigned char symbol = FSEv05_decodeSymbol(&DState, &DStream);
-
-You can retrieve any bitfield you eventually stored into the bitStream (in reverse order)
-Note : maximum allowed nbBits is 25, for 32-bits compatibility
-    size_t bitField = BITv05_readBits(&DStream, nbBits);
-
-All above operations only read from local register (which size depends on size_t).
-Refueling the register from memory is manually performed by the reload method.
-    endSignal = FSEv05_reloadDStream(&DStream);
-
-BITv05_reloadDStream() result tells if there is still some more data to read from DStream.
-BITv05_DStream_unfinished : there is still some data left into the DStream.
-BITv05_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.
-BITv05_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.
-BITv05_DStream_tooFar : Dstream went too far. Decompression result is corrupted.
-
-When reaching end of buffer (BITv05_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,
-to properly detect the exact end of stream.
-After each decoded symbol, check if DStream is fully consumed using this simple test :
-    BITv05_reloadDStream(&DStream) >= BITv05_DStream_completed
-
-When it's done, verify decompression is fully completed, by checking both DStream and the relevant states.
-Checking if DStream has reached its end is performed by :
-    BITv05_endOfDStream(&DStream);
-Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.
-    FSEv05_endOfDState(&DState);
-*/
 
 
 /* *****************************************
diff --git a/lib/legacy/zstd_v06.c b/lib/legacy/zstd_v06.c
index 62683f994..19116f108 100644
--- a/lib/legacy/zstd_v06.c
+++ b/lib/legacy/zstd_v06.c
@@ -839,16 +839,6 @@ MEM_STATIC BITv06_DStream_status BITv06_reloadDStream(BITv06_DStream_t* bitD);
 MEM_STATIC unsigned BITv06_endOfDStream(const BITv06_DStream_t* bitD);
 
 
-/* Start by invoking BITv06_initDStream().
-*  A chunk of the bitStream is then stored into a local register.
-*  Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
-*  You can then retrieve bitFields stored into the local register, **in reverse order**.
-*  Local register is explicitly reloaded from memory by the BITv06_reloadDStream() method.
-*  A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BITv06_DStream_unfinished.
-*  Otherwise, it can be less than that, so proceed accordingly.
-*  Checking if DStream has reached its end can be performed with BITv06_endOfDStream().
-*/
-
 
 /*-****************************************
 *  unsafe API
@@ -861,7 +851,7 @@ MEM_STATIC size_t BITv06_readBitsFast(BITv06_DStream_t* bitD, unsigned nbBits);
 /*-**************************************************************
 *  Internal functions
 ****************************************************************/
-MEM_STATIC unsigned BITv06_highbit32 (register U32 val)
+MEM_STATIC unsigned BITv06_highbit32 ( U32 val)
 {
 #   if defined(_MSC_VER)   /* Visual */
     unsigned long r=0;
@@ -929,13 +919,6 @@ MEM_STATIC size_t BITv06_initDStream(BITv06_DStream_t* bitD, const void* srcBuff
 }
 
 
-/*! BITv06_lookBits() :
- *  Provides next n bits from local register.
- *  local register is not modified.
- *  On 32-bits, maxNbBits==24.
- *  On 64-bits, maxNbBits==56.
- *  @return : value extracted
- */
  MEM_STATIC size_t BITv06_lookBits(const BITv06_DStream_t* bitD, U32 nbBits)
 {
     U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;
@@ -955,11 +938,6 @@ MEM_STATIC void BITv06_skipBits(BITv06_DStream_t* bitD, U32 nbBits)
     bitD->bitsConsumed += nbBits;
 }
 
-/*! BITv06_readBits() :
- *  Read (consume) next n bits from local register and update.
- *  Pay attention to not read more than nbBits contained into local register.
- *  @return : extracted value.
- */
 MEM_STATIC size_t BITv06_readBits(BITv06_DStream_t* bitD, U32 nbBits)
 {
     size_t const value = BITv06_lookBits(bitD, nbBits);
@@ -976,11 +954,6 @@ MEM_STATIC size_t BITv06_readBitsFast(BITv06_DStream_t* bitD, U32 nbBits)
     return value;
 }
 
-/*! BITv06_reloadDStream() :
-*   Refill `BITv06_DStream_t` from src buffer previously defined (see BITv06_initDStream() ).
-*   This function is safe, it guarantees it will not read beyond src buffer.
-*   @return : status of `BITv06_DStream_t` internal register.
-              if status == unfinished, internal register is filled with >= (sizeof(bitD->bitContainer)*8 - 7) bits */
 MEM_STATIC BITv06_DStream_status BITv06_reloadDStream(BITv06_DStream_t* bitD)
 {
     if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */
@@ -1103,55 +1076,6 @@ static void     FSEv06_initDState(FSEv06_DState_t* DStatePtr, BITv06_DStream_t*
 
 static unsigned char FSEv06_decodeSymbol(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD);
 
-/*!
-Let's now decompose FSEv06_decompress_usingDTable() into its unitary components.
-You will decode FSE-encoded symbols from the bitStream,
-and also any other bitFields you put in, **in reverse order**.
-
-You will need a few variables to track your bitStream. They are :
-
-BITv06_DStream_t DStream;    // Stream context
-FSEv06_DState_t  DState;     // State context. Multiple ones are possible
-FSEv06_DTable*   DTablePtr;  // Decoding table, provided by FSEv06_buildDTable()
-
-The first thing to do is to init the bitStream.
-    errorCode = BITv06_initDStream(&DStream, srcBuffer, srcSize);
-
-You should then retrieve your initial state(s)
-(in reverse flushing order if you have several ones) :
-    errorCode = FSEv06_initDState(&DState, &DStream, DTablePtr);
-
-You can then decode your data, symbol after symbol.
-For information the maximum number of bits read by FSEv06_decodeSymbol() is 'tableLog'.
-Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).
-    unsigned char symbol = FSEv06_decodeSymbol(&DState, &DStream);
-
-You can retrieve any bitfield you eventually stored into the bitStream (in reverse order)
-Note : maximum allowed nbBits is 25, for 32-bits compatibility
-    size_t bitField = BITv06_readBits(&DStream, nbBits);
-
-All above operations only read from local register (which size depends on size_t).
-Refueling the register from memory is manually performed by the reload method.
-    endSignal = FSEv06_reloadDStream(&DStream);
-
-BITv06_reloadDStream() result tells if there is still some more data to read from DStream.
-BITv06_DStream_unfinished : there is still some data left into the DStream.
-BITv06_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.
-BITv06_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.
-BITv06_DStream_tooFar : Dstream went too far. Decompression result is corrupted.
-
-When reaching end of buffer (BITv06_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,
-to properly detect the exact end of stream.
-After each decoded symbol, check if DStream is fully consumed using this simple test :
-    BITv06_reloadDStream(&DStream) >= BITv06_DStream_completed
-
-When it's done, verify decompression is fully completed, by checking both DStream and the relevant states.
-Checking if DStream has reached its end is performed by :
-    BITv06_endOfDStream(&DStream);
-Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.
-    FSEv06_endOfDState(&DState);
-*/
-
 
 /* *****************************************
 *  FSE unsafe API
diff --git a/lib/legacy/zstd_v07.c b/lib/legacy/zstd_v07.c
index aad9b1f65..114ce005b 100644
--- a/lib/legacy/zstd_v07.c
+++ b/lib/legacy/zstd_v07.c
@@ -511,16 +511,6 @@ MEM_STATIC BITv07_DStream_status BITv07_reloadDStream(BITv07_DStream_t* bitD);
 MEM_STATIC unsigned BITv07_endOfDStream(const BITv07_DStream_t* bitD);
 
 
-/* Start by invoking BITv07_initDStream().
-*  A chunk of the bitStream is then stored into a local register.
-*  Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
-*  You can then retrieve bitFields stored into the local register, **in reverse order**.
-*  Local register is explicitly reloaded from memory by the BITv07_reloadDStream() method.
-*  A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BITv07_DStream_unfinished.
-*  Otherwise, it can be less than that, so proceed accordingly.
-*  Checking if DStream has reached its end can be performed with BITv07_endOfDStream().
-*/
-
 
 /*-****************************************
 *  unsafe API
@@ -533,7 +523,7 @@ MEM_STATIC size_t BITv07_readBitsFast(BITv07_DStream_t* bitD, unsigned nbBits);
 /*-**************************************************************
 *  Internal functions
 ****************************************************************/
-MEM_STATIC unsigned BITv07_highbit32 (register U32 val)
+MEM_STATIC unsigned BITv07_highbit32 (U32 val)
 {
 #   if defined(_MSC_VER)   /* Visual */
     unsigned long r=0;
@@ -599,13 +589,6 @@ MEM_STATIC size_t BITv07_initDStream(BITv07_DStream_t* bitD, const void* srcBuff
 }
 
 
-/*! BITv07_lookBits() :
- *  Provides next n bits from local register.
- *  local register is not modified.
- *  On 32-bits, maxNbBits==24.
- *  On 64-bits, maxNbBits==56.
- *  @return : value extracted
- */
  MEM_STATIC size_t BITv07_lookBits(const BITv07_DStream_t* bitD, U32 nbBits)
 {
     U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;
@@ -625,11 +608,6 @@ MEM_STATIC void BITv07_skipBits(BITv07_DStream_t* bitD, U32 nbBits)
     bitD->bitsConsumed += nbBits;
 }
 
-/*! BITv07_readBits() :
- *  Read (consume) next n bits from local register and update.
- *  Pay attention to not read more than nbBits contained into local register.
- *  @return : extracted value.
- */
 MEM_STATIC size_t BITv07_readBits(BITv07_DStream_t* bitD, U32 nbBits)
 {
     size_t const value = BITv07_lookBits(bitD, nbBits);
@@ -646,11 +624,6 @@ MEM_STATIC size_t BITv07_readBitsFast(BITv07_DStream_t* bitD, U32 nbBits)
     return value;
 }
 
-/*! BITv07_reloadDStream() :
-*   Refill `BITv07_DStream_t` from src buffer previously defined (see BITv07_initDStream() ).
-*   This function is safe, it guarantees it will not read beyond src buffer.
-*   @return : status of `BITv07_DStream_t` internal register.
-              if status == unfinished, internal register is filled with >= (sizeof(bitD->bitContainer)*8 - 7) bits */
 MEM_STATIC BITv07_DStream_status BITv07_reloadDStream(BITv07_DStream_t* bitD)
 {
     if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should not happen => corruption detected */
@@ -874,55 +847,6 @@ static void     FSEv07_initDState(FSEv07_DState_t* DStatePtr, BITv07_DStream_t*
 static unsigned char FSEv07_decodeSymbol(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD);
 
 
-/**<
-Let's now decompose FSEv07_decompress_usingDTable() into its unitary components.
-You will decode FSE-encoded symbols from the bitStream,
-and also any other bitFields you put in, **in reverse order**.
-
-You will need a few variables to track your bitStream. They are :
-
-BITv07_DStream_t DStream;    // Stream context
-FSEv07_DState_t  DState;     // State context. Multiple ones are possible
-FSEv07_DTable*   DTablePtr;  // Decoding table, provided by FSEv07_buildDTable()
-
-The first thing to do is to init the bitStream.
-    errorCode = BITv07_initDStream(&DStream, srcBuffer, srcSize);
-
-You should then retrieve your initial state(s)
-(in reverse flushing order if you have several ones) :
-    errorCode = FSEv07_initDState(&DState, &DStream, DTablePtr);
-
-You can then decode your data, symbol after symbol.
-For information the maximum number of bits read by FSEv07_decodeSymbol() is 'tableLog'.
-Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).
-    unsigned char symbol = FSEv07_decodeSymbol(&DState, &DStream);
-
-You can retrieve any bitfield you eventually stored into the bitStream (in reverse order)
-Note : maximum allowed nbBits is 25, for 32-bits compatibility
-    size_t bitField = BITv07_readBits(&DStream, nbBits);
-
-All above operations only read from local register (which size depends on size_t).
-Refueling the register from memory is manually performed by the reload method.
-    endSignal = FSEv07_reloadDStream(&DStream);
-
-BITv07_reloadDStream() result tells if there is still some more data to read from DStream.
-BITv07_DStream_unfinished : there is still some data left into the DStream.
-BITv07_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.
-BITv07_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.
-BITv07_DStream_tooFar : Dstream went too far. Decompression result is corrupted.
-
-When reaching end of buffer (BITv07_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,
-to properly detect the exact end of stream.
-After each decoded symbol, check if DStream is fully consumed using this simple test :
-    BITv07_reloadDStream(&DStream) >= BITv07_DStream_completed
-
-When it's done, verify decompression is fully completed, by checking both DStream and the relevant states.
-Checking if DStream has reached its end is performed by :
-    BITv07_endOfDStream(&DStream);
-Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.
-    FSEv07_endOfDState(&DState);
-*/
-
 
 /* *****************************************
 *  FSE unsafe API

From 3aa2b27a890e9aa4c64b9e52632a6ef4c1418041 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Thu, 7 Dec 2017 02:52:50 -0500
Subject: [PATCH 113/145] fix #942 : streaming interface does not compress
 after ZSTD_initCStream()

While the final result is still, technically, a frame,
the resulting frame expands initial data instead of compressing it.
This is because the streaming API creates a tiny 1-byte buffer for input,
because it believes input is empty (0-bytes),
because in the past, 0 used to mean "unknown" instead.

This patch fixes the issue.
Todo : add a test which traps the issue.
---
 lib/compress/zstd_compress.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 8d493852f..69b0d6402 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -2466,6 +2466,7 @@ size_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx,
 
 ZSTD_CStream* ZSTD_createCStream(void)
 {
+    DEBUGLOG(3, "ZSTD_createCStream");
     return ZSTD_createCStream_advanced(ZSTD_defaultCMem);
 }
 
@@ -2633,7 +2634,8 @@ size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigne
 
 size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel)
 {
-    return ZSTD_initCStream_srcSize(zcs, compressionLevel, 0);
+    DEBUGLOG(4, "ZSTD_initCStream");
+    return ZSTD_initCStream_srcSize(zcs, compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN);
 }
 
 /*======   Compression   ======*/

From 21f7672d43549e1f87b879fb8a14ac1a4fabc266 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Thu, 7 Dec 2017 03:06:01 -0500
Subject: [PATCH 114/145] zstreamtest : add test which detects when
 ZSTD_initCStream() inflate data

as in #942, when ZSTD_initCStream() believes data is empty, instead of unknown.
---
 tests/zstreamtest.c | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index 920e988b0..e08a96d8f 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -245,13 +245,28 @@ static int basicUnitTests(U32 seed, double compressibility)
     }
     dictID = ZDICT_getDictID(dictionary.start, dictionary.filled);
 
+    /* Basic compression test */
+    DISPLAYLEVEL(3, "test%3i : compress %u bytes : ", testNb++, COMPRESSIBLE_NOISE_LENGTH);
+    CHECK_Z( ZSTD_initCStream(zc, 1 /* cLevel */) );
+    outBuff.dst = (char*)(compressedBuffer);
+    outBuff.size = compressedBufferSize;
+    outBuff.pos = 0;
+    inBuff.src = CNBuffer;
+    inBuff.size = CNBufferSize;
+    inBuff.pos = 0;
+    CHECK_Z( ZSTD_compressStream(zc, &outBuff, &inBuff) );
+    if (inBuff.pos != inBuff.size) goto _output_error;   /* entire input should be consumed */
+    { size_t const r = ZSTD_endStream(zc, &outBuff);
+      if (r != 0) goto _output_error; }  /* error, or some data not flushed */
+    DISPLAYLEVEL(3, "OK (%u bytes)\n", (U32)outBuff.pos);
+
     /* generate skippable frame */
     MEM_writeLE32(compressedBuffer, ZSTD_MAGIC_SKIPPABLE_START);
     MEM_writeLE32(((char*)compressedBuffer)+4, (U32)skippableFrameSize);
     cSize = skippableFrameSize + 8;
 
-    /* Basic compression test */
-    DISPLAYLEVEL(3, "test%3i : compress %u bytes : ", testNb++, COMPRESSIBLE_NOISE_LENGTH);
+    /* Basic compression test using dict */
+    DISPLAYLEVEL(3, "test%3i : skipframe + compress %u bytes : ", testNb++, COMPRESSIBLE_NOISE_LENGTH);
     CHECK_Z( ZSTD_initCStream_usingDict(zc, CNBuffer, dictSize, 1 /* cLevel */) );
     outBuff.dst = (char*)(compressedBuffer)+cSize;
     assert(compressedBufferSize > cSize);

From c029ee1f0bc464754c899deb2f5f0a2f16f895e4 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Thu, 7 Dec 2017 17:13:10 -0500
Subject: [PATCH 115/145] ZSTD_initCStream_srcSize() considers "0" to mean
 "unknown"

to not break existing programs relying on this behavior.
Might be changed to mean "empty" in the future.
---
 lib/compress/zstd_compress.c | 7 +++----
 lib/zstd.h                   | 2 +-
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 69b0d6402..20b095998 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -2623,12 +2623,11 @@ size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t di
     return ZSTD_initCStream_internal(zcs, dict, dictSize, NULL, cctxParams, ZSTD_CONTENTSIZE_UNKNOWN);
 }
 
-size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize)
+size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pss)
 {
-    ZSTD_CCtx_params cctxParams;
+    U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;  /* temporary : 0 interpreted as "unknown" during transition period. Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN. `0` will be interpreted as "empty" in the future */
     ZSTD_parameters const params = ZSTD_getParams(compressionLevel, pledgedSrcSize, 0);
-    cctxParams = ZSTD_assignParamsToCCtxParams(zcs->requestedParams, params);
-    cctxParams.fParams.contentSizeFlag = (pledgedSrcSize>0);
+    ZSTD_CCtx_params const cctxParams = ZSTD_assignParamsToCCtxParams(zcs->requestedParams, params);
     return ZSTD_initCStream_internal(zcs, NULL, 0, NULL, cctxParams, pledgedSrcSize);
 }
 
diff --git a/lib/zstd.h b/lib/zstd.h
index fe37cec8b..76d75e2a0 100644
--- a/lib/zstd.h
+++ b/lib/zstd.h
@@ -734,7 +734,7 @@ ZSTDLIB_API unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize);
 /*=====   Advanced Streaming compression functions  =====*/
 ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);
 ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticCCtx() */
-ZSTDLIB_API size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize);   /**< pledgedSrcSize must be correct. If it is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs, a size of 0 is interepreted as "unknown". But it may change in some future version to mean "empty". */
+ZSTDLIB_API size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize);   /**< pledgedSrcSize must be correct. If it is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs, "0" also disables frame content size field. It may be enabled in the future. */
 ZSTDLIB_API size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel); /**< creates of an internal CDict (incompatible with static CCtx), except if dict == NULL or dictSize < 8, in which case no dict is used. Note: dict is loaded with ZSTD_dm_auto (treated as a full zstd dictionary if it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.*/
 ZSTDLIB_API size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, const void* dict, size_t dictSize,
                                              ZSTD_parameters params, unsigned long long pledgedSrcSize);  /**< pledgedSrcSize : if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */

From dfc697e967ad736060dc9ec695a7db0d9a805fe3 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 8 Dec 2017 12:16:49 -0500
Subject: [PATCH 116/145] comment clarification

---
 lib/compress/zstd_compress.c | 8 ++++----
 lib/zstd.h                   | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 20b095998..3f39875f5 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -2599,7 +2599,8 @@ size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)
 }
 
 /* ZSTD_initCStream_advanced() :
- * pledgedSrcSize : if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN.
+ * pledgedSrcSize must be correct.
+ * if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN.
  * dict is loaded with default parameters ZSTD_dm_auto and ZSTD_dlm_byCopy. */
 size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
                                  const void* dict, size_t dictSize,
@@ -2610,9 +2611,8 @@ size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
     DEBUGLOG(4, "ZSTD_initCStream_advanced: pledgedSrcSize=%u, flag=%u",
             (U32)pledgedSrcSize, params.fParams.contentSizeFlag);
     CHECK_F( ZSTD_checkCParams(params.cParams) );
-    if ((pledgedSrcSize==0) && (params.fParams.contentSizeFlag==0))
-        pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;
-    return ZSTD_initCStream_internal(zcs, dict, dictSize, NULL, cctxParams, pledgedSrcSize);
+    if ((pledgedSrcSize==0) && (params.fParams.contentSizeFlag==0)) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;  /* for compatibility with older programs relying on this behavior. Users should now specify ZSTD_CONTENTSIZE_UNKNOWN. This line will be removed in the future. */
+    return ZSTD_initCStream_internal(zcs, dict, dictSize, NULL /*cdict*/, cctxParams, pledgedSrcSize);
 }
 
 size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel)
diff --git a/lib/zstd.h b/lib/zstd.h
index 76d75e2a0..15c467535 100644
--- a/lib/zstd.h
+++ b/lib/zstd.h
@@ -737,9 +737,9 @@ ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspa
 ZSTDLIB_API size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize);   /**< pledgedSrcSize must be correct. If it is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs, "0" also disables frame content size field. It may be enabled in the future. */
 ZSTDLIB_API size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel); /**< creates of an internal CDict (incompatible with static CCtx), except if dict == NULL or dictSize < 8, in which case no dict is used. Note: dict is loaded with ZSTD_dm_auto (treated as a full zstd dictionary if it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.*/
 ZSTDLIB_API size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, const void* dict, size_t dictSize,
-                                             ZSTD_parameters params, unsigned long long pledgedSrcSize);  /**< pledgedSrcSize : if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */
+                                             ZSTD_parameters params, unsigned long long pledgedSrcSize);  /**< pledgedSrcSize must be correct. If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */
 ZSTDLIB_API size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);  /**< note : cdict will just be referenced, and must outlive compression session */
-ZSTDLIB_API size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize);  /**< same as ZSTD_initCStream_usingCDict(), with control over frame parameters */
+ZSTDLIB_API size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize);  /**< same as ZSTD_initCStream_usingCDict(), with control over frame parameters. pledgedSrcSize must be correct. If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. */
 
 /*! ZSTD_resetCStream() :
  *  start a new compression job, using same parameters from previous job.

From 5098d1fbe2a0b3d0ddb66c0880e3004feac65f3e Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 12 Dec 2017 12:48:31 -0800
Subject: [PATCH 117/145] Created a test case which reliably reproduces bug
 #944

in zstreamtest.
---
 lib/compress/zstd_compress.c     | 11 ++---
 lib/compress/zstdmt_compress.c   | 30 ++++++------
 lib/decompress/zstd_decompress.c | 19 +++++---
 lib/zstd.h                       | 19 +++++---
 tests/zstreamtest.c              | 81 +++++++++++++++++++++++++++-----
 5 files changed, 114 insertions(+), 46 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 3f39875f5..107291888 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -477,7 +477,7 @@ size_t ZSTD_CCtx_setParametersUsingCCtxParams(
 
 ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize)
 {
-    DEBUGLOG(4, " setting pledgedSrcSize to %u", (U32)pledgedSrcSize);
+    DEBUGLOG(4, "ZSTD_CCtx_setPledgedSrcSize to %u bytes", (U32)pledgedSrcSize);
     if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
     cctx->pledgedSrcSizePlusOne = pledgedSrcSize+1;
     return 0;
@@ -489,7 +489,7 @@ size_t ZSTD_CCtx_loadDictionary_advanced(
 {
     if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
     if (cctx->staticSize) return ERROR(memory_allocation);  /* no malloc for static CCtx */
-    DEBUGLOG(4, "load dictionary of size %u", (U32)dictSize);
+    DEBUGLOG(4, "ZSTD_CCtx_loadDictionary_advanced (size: %u)", (U32)dictSize);
     ZSTD_freeCDict(cctx->cdictLocal);  /* in case one already exists */
     if (dict==NULL || dictSize==0) {   /* no dictionary mode */
         cctx->cdictLocal = NULL;
@@ -2273,7 +2273,7 @@ static size_t ZSTD_initCDict_internal(
                     ZSTD_dictMode_e dictMode,
                     ZSTD_compressionParameters cParams)
 {
-    DEBUGLOG(4, "ZSTD_initCDict_internal, mode %u", (U32)dictMode);
+    DEBUGLOG(3, "ZSTD_initCDict_internal, mode %u", (U32)dictMode);
     if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dictBuffer) || (!dictSize)) {
         cdict->dictBuffer = NULL;
         cdict->dictContent = dictBuffer;
@@ -2303,7 +2303,7 @@ ZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize,
                                       ZSTD_dictMode_e dictMode,
                                       ZSTD_compressionParameters cParams, ZSTD_customMem customMem)
 {
-    DEBUGLOG(4, "ZSTD_createCDict_advanced, mode %u", (U32)dictMode);
+    DEBUGLOG(3, "ZSTD_createCDict_advanced, mode %u", (U32)dictMode);
     if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
 
     {   ZSTD_CDict* const cdict = (ZSTD_CDict*)ZSTD_malloc(sizeof(ZSTD_CDict), customMem);
@@ -2809,7 +2809,7 @@ size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
                               ZSTD_inBuffer* input,
                               ZSTD_EndDirective endOp)
 {
-    DEBUGLOG(5, "ZSTD_compress_generic");
+    DEBUGLOG(5, "ZSTD_compress_generic, endOp=%u ", (U32)endOp);
     /* check conditions */
     if (output->pos > output->size) return ERROR(GENERIC);
     if (input->pos  > input->size)  return ERROR(GENERIC);
@@ -2856,7 +2856,6 @@ size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
 #ifdef ZSTD_MULTITHREAD
     if (cctx->appliedParams.nbThreads > 1) {
         size_t const flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);
-        DEBUGLOG(5, "ZSTDMT_compressStream_generic result : %u", (U32)flushMin);
         if ( ZSTD_isError(flushMin)
           || (endOp == ZSTD_e_end && flushMin == 0) ) { /* compression completed */
             ZSTD_startNewCompression(cctx);
diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c
index 6b6466fe5..8347cf29d 100644
--- a/lib/compress/zstdmt_compress.c
+++ b/lib/compress/zstdmt_compress.c
@@ -310,7 +310,7 @@ static void ZSTDMT_releaseCCtx(ZSTDMT_CCtxPool* pool, ZSTD_CCtx* cctx)
 typedef struct {
     buffer_t src;
     const void* srcStart;
-    size_t   dictSize;
+    size_t   prefixSize;
     size_t   srcSize;
     buffer_t dstBuff;
     size_t   cSize;
@@ -333,10 +333,10 @@ void ZSTDMT_compressChunk(void* jobDescription)
 {
     ZSTDMT_jobDescription* const job = (ZSTDMT_jobDescription*)jobDescription;
     ZSTD_CCtx* const cctx = ZSTDMT_getCCtx(job->cctxPool);
-    const void* const src = (const char*)job->srcStart + job->dictSize;
+    const void* const src = (const char*)job->srcStart + job->prefixSize;
     buffer_t dstBuff = job->dstBuff;
-    DEBUGLOG(5, "ZSTDMT_compressChunk: job (first:%u) (last:%u) : dictSize %u, srcSize %u",
-                 job->firstChunk, job->lastChunk, (U32)job->dictSize, (U32)job->srcSize);
+    DEBUGLOG(5, "ZSTDMT_compressChunk: job (first:%u) (last:%u) : prefixSize %u, srcSize %u ",
+                 job->firstChunk, job->lastChunk, (U32)job->prefixSize, (U32)job->srcSize);
 
     if (cctx==NULL) {
         job->cSize = ERROR(memory_allocation);
@@ -356,20 +356,21 @@ void ZSTDMT_compressChunk(void* jobDescription)
     if (job->cdict) {
         size_t const initError = ZSTD_compressBegin_usingCDict_advanced(cctx, job->cdict, job->params.fParams, job->fullFrameSize);
         DEBUGLOG(4, "ZSTDMT_compressChunk: init using CDict");
-        assert(job->firstChunk); /* should only happen for first segment */
+        assert(job->firstChunk);  /* only allowed for first job */
         if (ZSTD_isError(initError)) { job->cSize = initError; goto _endJob; }
     } else {  /* srcStart points at reloaded section */
         ZSTD_CCtx_params jobParams = job->params;   /* do not modify job->params ! copy it, modify the copy */
         size_t const forceWindowError = ZSTD_CCtxParam_setParameter(&jobParams, ZSTD_p_forceMaxWindow, !job->firstChunk);
         U64 const pledgedSrcSize = job->firstChunk ? job->fullFrameSize : ZSTD_CONTENTSIZE_UNKNOWN;
         /* load dictionary in "content-only" mode (no header analysis) */
-        size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, job->srcStart, job->dictSize, ZSTD_dm_rawContent, jobParams, pledgedSrcSize);
+        size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, job->srcStart, job->prefixSize, ZSTD_dm_rawContent, jobParams, pledgedSrcSize);
+        DEBUGLOG(5, "ZSTD_compressBegin_advanced_internal called with windowLog = %u ", jobParams.cParams.windowLog);
         if (ZSTD_isError(initError) || ZSTD_isError(forceWindowError)) {
             job->cSize = initError;
             goto _endJob;
         }
     }
-    if (!job->firstChunk) {  /* flush and overwrite frame header when it's not first segment */
+    if (!job->firstChunk) {  /* flush and overwrite frame header when it's not first job */
         size_t const hSize = ZSTD_compressContinue(cctx, dstBuff.start, dstBuff.size, src, 0);
         if (ZSTD_isError(hSize)) { job->cSize = hSize; goto _endJob; }
         ZSTD_invalidateRepCodes(cctx);
@@ -380,9 +381,9 @@ void ZSTDMT_compressChunk(void* jobDescription)
     job->cSize = (job->lastChunk) ?
                  ZSTD_compressEnd     (cctx, dstBuff.start, dstBuff.size, src, job->srcSize) :
                  ZSTD_compressContinue(cctx, dstBuff.start, dstBuff.size, src, job->srcSize);
-    DEBUGLOG(5, "compressed %u bytes into %u bytes   (first:%u) (last:%u)",
+    DEBUGLOG(5, "compressed %u bytes into %u bytes   (first:%u) (last:%u) ",
                 (unsigned)job->srcSize, (unsigned)job->cSize, job->firstChunk, job->lastChunk);
-    DEBUGLOG(5, "dstBuff.size : %u ; => %s", (U32)dstBuff.size, ZSTD_getErrorName(job->cSize));
+    DEBUGLOG(5, "dstBuff.size : %u ; => %s ", (U32)dstBuff.size, ZSTD_getErrorName(job->cSize));
 
 _endJob:
     ZSTDMT_releaseCCtx(job->cctxPool, cctx);
@@ -618,7 +619,7 @@ static size_t ZSTDMT_compress_advanced_internal(
     size_t const overlapSize = (overlapRLog>=9) ? 0 : (size_t)1 << (params.cParams.windowLog - overlapRLog);
     unsigned nbChunks = computeNbChunks(srcSize, params.cParams.windowLog, params.nbThreads);
     size_t const proposedChunkSize = (srcSize + (nbChunks-1)) / nbChunks;
-    size_t const avgChunkSize = ((proposedChunkSize & 0x1FFFF) < 0x7FFF) ? proposedChunkSize + 0xFFFF : proposedChunkSize;   /* avoid too small last block */
+    size_t const avgChunkSize = (((proposedChunkSize-1) & 0x1FFFF) < 0x7FFF) ? proposedChunkSize + 0xFFFF : proposedChunkSize;   /* avoid too small last block */
     const char* const srcStart = (const char*)src;
     size_t remainingSrcSize = srcSize;
     unsigned const compressWithinDst = (dstCapacity >= ZSTD_compressBound(srcSize)) ? nbChunks : (unsigned)(dstCapacity / ZSTD_compressBound(avgChunkSize));  /* presumes avgChunkSize >= 256 KB, which should be the case */
@@ -628,7 +629,8 @@ static size_t ZSTDMT_compress_advanced_internal(
     assert(mtctx->cctxPool->totalCCtx == params.nbThreads);
 
     DEBUGLOG(4, "ZSTDMT_compress_advanced_internal");
-    DEBUGLOG(4, "nbChunks  : %2u   (chunkSize : %u bytes)   ", nbChunks, (U32)avgChunkSize);
+    DEBUGLOG(4, "nbChunks  : %2u (raw chunkSize : %u bytes; fixed chunkSize: %u)   ",
+                nbChunks, (U32)proposedChunkSize, (U32)avgChunkSize);
     if (nbChunks==1) {   /* fallback to single-thread mode */
         ZSTD_CCtx* const cctx = mtctx->cctxPool->cctx[0];
         if (cdict) return ZSTD_compress_usingCDict_advanced(cctx, dst, dstCapacity, src, srcSize, cdict, jobParams.fParams);
@@ -657,7 +659,7 @@ static size_t ZSTDMT_compress_advanced_internal(
 
             mtctx->jobs[u].src = g_nullBuffer;
             mtctx->jobs[u].srcStart = srcStart + frameStartPos - dictSize;
-            mtctx->jobs[u].dictSize = dictSize;
+            mtctx->jobs[u].prefixSize = dictSize;
             mtctx->jobs[u].srcSize = chunkSize;
             mtctx->jobs[u].cdict = (u==0) ? cdict : NULL;
             mtctx->jobs[u].fullFrameSize = srcSize;
@@ -888,7 +890,7 @@ static size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* zcs, size_t srcSize, unsi
     zcs->jobs[jobID].src = zcs->inBuff.buffer;
     zcs->jobs[jobID].srcStart = zcs->inBuff.buffer.start;
     zcs->jobs[jobID].srcSize = srcSize;
-    zcs->jobs[jobID].dictSize = zcs->dictSize;
+    zcs->jobs[jobID].prefixSize = zcs->dictSize;
     assert(zcs->inBuff.filled >= srcSize + zcs->dictSize);
     zcs->jobs[jobID].params = zcs->params;
     /* do not calculate checksum within sections, but write it in header for first section */
@@ -1014,7 +1016,7 @@ size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
 {
     size_t const newJobThreshold = mtctx->dictSize + mtctx->targetSectionSize;
     unsigned forwardInputProgress = 0;
-    DEBUGLOG(5, "ZSTDMT_compressStream_generic");
+    DEBUGLOG(5, "ZSTDMT_compressStream_generic ");
     assert(output->pos <= output->size);
     assert(input->pos  <= input->size);
 
diff --git a/lib/decompress/zstd_decompress.c b/lib/decompress/zstd_decompress.c
index f0cf967cb..a59d94411 100644
--- a/lib/decompress/zstd_decompress.c
+++ b/lib/decompress/zstd_decompress.c
@@ -2451,14 +2451,16 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
                         return ZSTD_decompressLegacyStream(zds->legacyContext, legacyVersion, output, input);
                     }
 #endif
-                    return hSize; /* error */
+                    return hSize;   /* error */
                 }
                 if (hSize != 0) {   /* need more input */
                     size_t const toLoad = hSize - zds->lhSize;   /* if hSize!=0, hSize > zds->lhSize */
-                    if (toLoad > (size_t)(iend-ip)) {   /* not enough input to load full header */
-                        if (iend-ip > 0) {
-                            memcpy(zds->headerBuffer + zds->lhSize, ip, iend-ip);
-                            zds->lhSize += iend-ip;
+                    size_t const remainingInput = (size_t)(iend-ip);
+                    assert(iend >= ip);
+                    if (toLoad > remainingInput) {   /* not enough input to load full header */
+                        if (remainingInput > 0) {
+                            memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput);
+                            zds->lhSize += remainingInput;
                         }
                         input->pos = input->size;
                         return (MAX(ZSTD_frameHeaderSize_min, hSize) - zds->lhSize) + ZSTD_blockHeaderSize;   /* remaining header bytes + next block header */
@@ -2473,8 +2475,10 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
                 && (U64)(size_t)(oend-op) >= zds->fParams.frameContentSize) {
                 size_t const cSize = ZSTD_findFrameCompressedSize(istart, iend-istart);
                 if (cSize <= (size_t)(iend-istart)) {
+                    /* shortcut : using single-pass mode */
                     size_t const decompressedSize = ZSTD_decompress_usingDDict(zds, op, oend-op, istart, cSize, zds->ddict);
                     if (ZSTD_isError(decompressedSize)) return decompressedSize;
+                    DEBUGLOG(4, "shortcut to single-pass ZSTD_decompress_usingDDict()")
                     ip = istart + cSize;
                     op += decompressedSize;
                     zds->expected = 0;
@@ -2497,8 +2501,9 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
             }
 
             /* control buffer memory usage */
-            DEBUGLOG(4, "Control max buffer memory usage (max %u KB)",
-                        (U32)(zds->maxWindowSize >> 10));
+            DEBUGLOG(4, "Control max memory usage (%u KB <= max %u KB)",
+                        (U32)(zds->fParams.windowSize >>10),
+                        (U32)(zds->maxWindowSize >> 10) );
             zds->fParams.windowSize = MAX(zds->fParams.windowSize, 1U << ZSTD_WINDOWLOG_ABSOLUTEMIN);
             if (zds->fParams.windowSize > zds->maxWindowSize) return ERROR(frameParameter_windowTooLarge);
 
diff --git a/lib/zstd.h b/lib/zstd.h
index 15c467535..e4541c3f4 100644
--- a/lib/zstd.h
+++ b/lib/zstd.h
@@ -1016,7 +1016,8 @@ typedef enum {
                               * More threads improve speed, but also increase memory usage.
                               * Can only receive a value > 1 if ZSTD_MULTITHREAD is enabled.
                               * Special: value 0 means "do not change nbThreads" */
-    ZSTD_p_jobSize,          /* Size of a compression job. Each compression job is completed in parallel.
+    ZSTD_p_jobSize,          /* Size of a compression job. This value is only enforced in streaming (non-blocking) mode.
+                              * Each compression job is completed in parallel, so indirectly controls the nb of active threads.
                               * 0 means default, which is dynamically determined based on compression parameters.
                               * Job size must be a minimum of overlapSize, or 1 KB, whichever is largest
                               * The minimum size is automatically and transparently enforced */
@@ -1144,13 +1145,19 @@ typedef enum {
  *  - Compression parameters cannot be changed once compression is started.
  *  - outpot->pos must be <= dstCapacity, input->pos must be <= srcSize
  *  - outpot->pos and input->pos will be updated. They are guaranteed to remain below their respective limit.
- *  - @return provides the minimum amount of data still to flush from internal buffers
+ *  - In single-thread mode (default), function is blocking : it completed its job before returning to caller.
+ *  - In multi-thread mode, function is non-blocking : it just acquires a copy of input, and distribute job to internal worker threads,
+ *                                                     and then immediately returns, just indicating that there is some data remaining to be flushed.
+ *                                                     The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte.
+ *  - Exception : in multi-threading mode, if the first call requests a ZSTD_e_end directive, it is blocking : it will complete compression before giving back control to caller.
+ *  - @return provides the minimum amount of data remaining to be flushed from internal buffers
  *            or an error code, which can be tested using ZSTD_isError().
- *            if @return != 0, flush is not fully completed, there is some data left within internal buffers.
- *  - after a ZSTD_e_end directive, if internal buffer is not fully flushed,
+ *            if @return != 0, flush is not fully completed, there is still some data left within internal buffers.
+ *            This is useful to determine if a ZSTD_e_flush or ZSTD_e_end directive is completed.
+ *  - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0),
  *            only ZSTD_e_end or ZSTD_e_flush operations are allowed.
- *            It is necessary to fully flush internal buffers
- *            before starting a new compression job, or changing compression parameters.
+ *            Before starting a new compression job, or changing compression parameters,
+ *            it is required to fully flush internal buffers.
  */
 ZSTDLIB_API size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
                                           ZSTD_outBuffer* output,
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index e08a96d8f..6910457ff 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -524,12 +524,12 @@ static int basicUnitTests(U32 seed, double compressibility)
     {   ZSTD_DDict* const ddict = ZSTD_createDDict(dictionary.start, dictionary.filled);
         size_t const initError = ZSTD_initDStream_usingDDict(zd, ddict);
         if (ZSTD_isError(initError)) goto _output_error;
-        inBuff.src = compressedBuffer;
-        inBuff.size = cSize;
-        inBuff.pos = 0;
         outBuff.dst = decodedBuffer;
         outBuff.size = CNBufferSize;
         outBuff.pos = 0;
+        inBuff.src = compressedBuffer;
+        inBuff.size = cSize;
+        inBuff.pos = 0;
         { size_t const r = ZSTD_decompressStream(zd, &outBuff, &inBuff);
           if (r != 0) goto _output_error; }  /* should reach end of frame == 0; otherwise, some data left, or an error */
         if (outBuff.pos != CNBufferSize) goto _output_error;   /* should regenerate the same amount */
@@ -548,12 +548,12 @@ static int basicUnitTests(U32 seed, double compressibility)
     DISPLAYLEVEL(3, "test%3i : maxWindowSize < frame requirement : ", testNb++);
     ZSTD_initDStream_usingDict(zd, CNBuffer, dictSize);
     CHECK_Z( ZSTD_setDStreamParameter(zd, DStream_p_maxWindowSize, 1000) );  /* too small limit */
-    inBuff.src = compressedBuffer;
-    inBuff.size = cSize;
-    inBuff.pos = 0;
     outBuff.dst = decodedBuffer;
     outBuff.size = CNBufferSize;
     outBuff.pos = 0;
+    inBuff.src = compressedBuffer;
+    inBuff.size = cSize;
+    inBuff.pos = 0;
     { size_t const r = ZSTD_decompressStream(zd, &outBuff, &inBuff);
       if (!ZSTD_isError(r)) goto _output_error;  /* must fail : frame requires > 100 bytes */
       DISPLAYLEVEL(3, "OK (%s)\n", ZSTD_getErrorName(r)); }
@@ -642,12 +642,12 @@ static int basicUnitTests(U32 seed, double compressibility)
         params.fParams.contentSizeFlag = 1;
         CHECK_Z( ZSTD_initCStream_advanced(zc, dictionary.start, dictionary.filled, params, 0 /* pledgedSrcSize==0 means "empty" when params.fParams.contentSizeFlag is set */) );
     } /* cstream advanced shall write content size = 0 */
-    inBuff.src = CNBuffer;
-    inBuff.size = 0;
-    inBuff.pos = 0;
     outBuff.dst = compressedBuffer;
     outBuff.size = compressedBufferSize;
     outBuff.pos = 0;
+    inBuff.src = CNBuffer;
+    inBuff.size = 0;
+    inBuff.pos = 0;
     CHECK_Z( ZSTD_compressStream(zc, &outBuff, &inBuff) );
     if (ZSTD_endStream(zc, &outBuff) != 0) goto _output_error;
     cSize = outBuff.pos;
@@ -671,12 +671,12 @@ static int basicUnitTests(U32 seed, double compressibility)
     if (ZSTD_findDecompressedSize(compressedBuffer, cSize) != 0) goto _output_error;
 
     ZSTD_resetCStream(zc, 0); /* resetCStream should treat 0 as unknown */
-    inBuff.src = CNBuffer;
-    inBuff.size = 0;
-    inBuff.pos = 0;
     outBuff.dst = compressedBuffer;
     outBuff.size = compressedBufferSize;
     outBuff.pos = 0;
+    inBuff.src = CNBuffer;
+    inBuff.size = 0;
+    inBuff.pos = 0;
     CHECK_Z( ZSTD_compressStream(zc, &outBuff, &inBuff) );
     if (ZSTD_endStream(zc, &outBuff) != 0) goto _output_error;
     cSize = outBuff.pos;
@@ -688,7 +688,7 @@ static int basicUnitTests(U32 seed, double compressibility)
     {   ZSTD_parameters const params = ZSTD_getParams(1, 0, 0);
         CHECK_Z( ZSTDMT_initCStream_advanced(mtctx, CNBuffer, dictSize, params, CNBufferSize) );
     }
-    outBuff.dst = (char*)(compressedBuffer);
+    outBuff.dst = compressedBuffer;
     outBuff.size = compressedBufferSize;
     outBuff.pos = 0;
     inBuff.src = CNBuffer;
@@ -700,6 +700,61 @@ static int basicUnitTests(U32 seed, double compressibility)
       if (r != 0) goto _output_error; }  /* error, or some data not flushed */
     DISPLAYLEVEL(3, "OK \n");
 
+    /* Complex multithreading + dictionary test */
+    {   U32 const nbThreads = 2;
+        size_t const jobSize = 4 * 1 MB;
+        size_t const srcSize = jobSize * nbThreads;  /* we want each job to have predictable size */
+        size_t const segLength = 2 KB;
+        size_t const offset = 600 KB;   /* must be larger than window defined in cdict */
+        size_t const start = jobSize + (offset-1);
+        const BYTE* const srcToCopy = (const BYTE*)CNBuffer + start;
+        BYTE* const dst = (BYTE*)CNBuffer + start - offset;
+        DISPLAYLEVEL(3, "test%3i : compress %u bytes with multiple threads + dictionary : ", testNb++, (U32)srcSize);
+        ZSTD_CCtx_setParameter(zc, ZSTD_p_compressionLevel, 3);
+        ZSTD_CCtx_setParameter(zc, ZSTD_p_nbThreads, 2);
+        ZSTD_CCtx_setParameter(zc, ZSTD_p_jobSize, jobSize);
+        assert(start > offset);
+        assert(start + segLength < COMPRESSIBLE_NOISE_LENGTH);
+        memcpy(dst, srcToCopy, segLength);   /* create a long repetition at long distance for job 2 */
+        outBuff.dst = compressedBuffer;
+        outBuff.size = compressedBufferSize;
+        outBuff.pos = 0;
+        inBuff.src = CNBuffer;
+        inBuff.size = srcSize; assert(srcSize < COMPRESSIBLE_NOISE_LENGTH);
+        inBuff.pos = 0;
+    }
+    {   ZSTD_compressionParameters const cParams = ZSTD_getCParams(1, 4 KB, dictionary.filled);   /* intentionnally lies on estimatedSrcSize, to push cdict into targeting a small window size */
+        ZSTD_CDict* const cdict = ZSTD_createCDict_advanced(dictionary.start, dictionary.filled, ZSTD_dlm_byRef, ZSTD_dm_fullDict, cParams, ZSTD_defaultCMem);
+        DISPLAYLEVEL(5, "cParams.windowLog = %u : ", cParams.windowLog);
+        ZSTD_CCtx_refCDict(zc, cdict);
+        CHECK_Z( ZSTD_compress_generic(zc, &outBuff, &inBuff, ZSTD_e_end) );
+        ZSTD_CCtx_refCDict(zc, NULL);  /* do not keep a reference to cdict, as its lifetime ends */
+        ZSTD_freeCDict(cdict);
+    }
+    if (inBuff.pos != inBuff.size) goto _output_error;   /* entire input should be consumed */
+    cSize = outBuff.pos;
+    DISPLAYLEVEL(3, "OK \n");
+
+    DISPLAYLEVEL(3, "test%3i : decompress large frame created from multiple threads + dictionary : ", testNb++);
+    {   ZSTD_DStream* const dstream = ZSTD_createDCtx();
+        ZSTD_frameHeader zfh;
+        ZSTD_getFrameHeader(&zfh, compressedBuffer, cSize);
+        DISPLAYLEVEL(5, "frame windowsize = %u : ", (U32)zfh.windowSize);
+        outBuff.dst = decodedBuffer;
+        outBuff.size = CNBufferSize;
+        outBuff.pos = 0;
+        inBuff.src = compressedBuffer;
+        inBuff.pos = 0;
+        CHECK_Z( ZSTD_initDStream_usingDict(dstream, dictionary.start, dictionary.filled) );
+        inBuff.size = 1;  /* avoid shortcut to single-pass mode */
+        CHECK_Z( ZSTD_decompressStream(dstream, &outBuff, &inBuff) );
+        inBuff.size = cSize;
+        CHECK_Z( ZSTD_decompressStream(dstream, &outBuff, &inBuff) );
+        if (inBuff.pos != inBuff.size) goto _output_error;   /* entire input should be consumed */
+        ZSTD_freeDStream(dstream);
+    }
+    DISPLAYLEVEL(3, "OK \n");
+
     DISPLAYLEVEL(3, "test%3i : check dictionary FSE tables can represent every code : ", testNb++);
     {   unsigned const kMaxWindowLog = 24;
         unsigned value;

From 8a104fda05e357d89dc8b263a48aa00ebe5d2603 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 12 Dec 2017 12:51:49 -0800
Subject: [PATCH 118/145] Revert "Created a test case which reliably reproduces
 bug #944"

This reverts commit 5098d1fbe2a0b3d0ddb66c0880e3004feac65f3e.
---
 lib/compress/zstd_compress.c     | 11 +++--
 lib/compress/zstdmt_compress.c   | 30 ++++++------
 lib/decompress/zstd_decompress.c | 19 +++-----
 lib/zstd.h                       | 19 +++-----
 tests/zstreamtest.c              | 81 +++++---------------------------
 5 files changed, 46 insertions(+), 114 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 107291888..3f39875f5 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -477,7 +477,7 @@ size_t ZSTD_CCtx_setParametersUsingCCtxParams(
 
 ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize)
 {
-    DEBUGLOG(4, "ZSTD_CCtx_setPledgedSrcSize to %u bytes", (U32)pledgedSrcSize);
+    DEBUGLOG(4, " setting pledgedSrcSize to %u", (U32)pledgedSrcSize);
     if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
     cctx->pledgedSrcSizePlusOne = pledgedSrcSize+1;
     return 0;
@@ -489,7 +489,7 @@ size_t ZSTD_CCtx_loadDictionary_advanced(
 {
     if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
     if (cctx->staticSize) return ERROR(memory_allocation);  /* no malloc for static CCtx */
-    DEBUGLOG(4, "ZSTD_CCtx_loadDictionary_advanced (size: %u)", (U32)dictSize);
+    DEBUGLOG(4, "load dictionary of size %u", (U32)dictSize);
     ZSTD_freeCDict(cctx->cdictLocal);  /* in case one already exists */
     if (dict==NULL || dictSize==0) {   /* no dictionary mode */
         cctx->cdictLocal = NULL;
@@ -2273,7 +2273,7 @@ static size_t ZSTD_initCDict_internal(
                     ZSTD_dictMode_e dictMode,
                     ZSTD_compressionParameters cParams)
 {
-    DEBUGLOG(3, "ZSTD_initCDict_internal, mode %u", (U32)dictMode);
+    DEBUGLOG(4, "ZSTD_initCDict_internal, mode %u", (U32)dictMode);
     if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dictBuffer) || (!dictSize)) {
         cdict->dictBuffer = NULL;
         cdict->dictContent = dictBuffer;
@@ -2303,7 +2303,7 @@ ZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize,
                                       ZSTD_dictMode_e dictMode,
                                       ZSTD_compressionParameters cParams, ZSTD_customMem customMem)
 {
-    DEBUGLOG(3, "ZSTD_createCDict_advanced, mode %u", (U32)dictMode);
+    DEBUGLOG(4, "ZSTD_createCDict_advanced, mode %u", (U32)dictMode);
     if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
 
     {   ZSTD_CDict* const cdict = (ZSTD_CDict*)ZSTD_malloc(sizeof(ZSTD_CDict), customMem);
@@ -2809,7 +2809,7 @@ size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
                               ZSTD_inBuffer* input,
                               ZSTD_EndDirective endOp)
 {
-    DEBUGLOG(5, "ZSTD_compress_generic, endOp=%u ", (U32)endOp);
+    DEBUGLOG(5, "ZSTD_compress_generic");
     /* check conditions */
     if (output->pos > output->size) return ERROR(GENERIC);
     if (input->pos  > input->size)  return ERROR(GENERIC);
@@ -2856,6 +2856,7 @@ size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
 #ifdef ZSTD_MULTITHREAD
     if (cctx->appliedParams.nbThreads > 1) {
         size_t const flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);
+        DEBUGLOG(5, "ZSTDMT_compressStream_generic result : %u", (U32)flushMin);
         if ( ZSTD_isError(flushMin)
           || (endOp == ZSTD_e_end && flushMin == 0) ) { /* compression completed */
             ZSTD_startNewCompression(cctx);
diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c
index 8347cf29d..6b6466fe5 100644
--- a/lib/compress/zstdmt_compress.c
+++ b/lib/compress/zstdmt_compress.c
@@ -310,7 +310,7 @@ static void ZSTDMT_releaseCCtx(ZSTDMT_CCtxPool* pool, ZSTD_CCtx* cctx)
 typedef struct {
     buffer_t src;
     const void* srcStart;
-    size_t   prefixSize;
+    size_t   dictSize;
     size_t   srcSize;
     buffer_t dstBuff;
     size_t   cSize;
@@ -333,10 +333,10 @@ void ZSTDMT_compressChunk(void* jobDescription)
 {
     ZSTDMT_jobDescription* const job = (ZSTDMT_jobDescription*)jobDescription;
     ZSTD_CCtx* const cctx = ZSTDMT_getCCtx(job->cctxPool);
-    const void* const src = (const char*)job->srcStart + job->prefixSize;
+    const void* const src = (const char*)job->srcStart + job->dictSize;
     buffer_t dstBuff = job->dstBuff;
-    DEBUGLOG(5, "ZSTDMT_compressChunk: job (first:%u) (last:%u) : prefixSize %u, srcSize %u ",
-                 job->firstChunk, job->lastChunk, (U32)job->prefixSize, (U32)job->srcSize);
+    DEBUGLOG(5, "ZSTDMT_compressChunk: job (first:%u) (last:%u) : dictSize %u, srcSize %u",
+                 job->firstChunk, job->lastChunk, (U32)job->dictSize, (U32)job->srcSize);
 
     if (cctx==NULL) {
         job->cSize = ERROR(memory_allocation);
@@ -356,21 +356,20 @@ void ZSTDMT_compressChunk(void* jobDescription)
     if (job->cdict) {
         size_t const initError = ZSTD_compressBegin_usingCDict_advanced(cctx, job->cdict, job->params.fParams, job->fullFrameSize);
         DEBUGLOG(4, "ZSTDMT_compressChunk: init using CDict");
-        assert(job->firstChunk);  /* only allowed for first job */
+        assert(job->firstChunk); /* should only happen for first segment */
         if (ZSTD_isError(initError)) { job->cSize = initError; goto _endJob; }
     } else {  /* srcStart points at reloaded section */
         ZSTD_CCtx_params jobParams = job->params;   /* do not modify job->params ! copy it, modify the copy */
         size_t const forceWindowError = ZSTD_CCtxParam_setParameter(&jobParams, ZSTD_p_forceMaxWindow, !job->firstChunk);
         U64 const pledgedSrcSize = job->firstChunk ? job->fullFrameSize : ZSTD_CONTENTSIZE_UNKNOWN;
         /* load dictionary in "content-only" mode (no header analysis) */
-        size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, job->srcStart, job->prefixSize, ZSTD_dm_rawContent, jobParams, pledgedSrcSize);
-        DEBUGLOG(5, "ZSTD_compressBegin_advanced_internal called with windowLog = %u ", jobParams.cParams.windowLog);
+        size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, job->srcStart, job->dictSize, ZSTD_dm_rawContent, jobParams, pledgedSrcSize);
         if (ZSTD_isError(initError) || ZSTD_isError(forceWindowError)) {
             job->cSize = initError;
             goto _endJob;
         }
     }
-    if (!job->firstChunk) {  /* flush and overwrite frame header when it's not first job */
+    if (!job->firstChunk) {  /* flush and overwrite frame header when it's not first segment */
         size_t const hSize = ZSTD_compressContinue(cctx, dstBuff.start, dstBuff.size, src, 0);
         if (ZSTD_isError(hSize)) { job->cSize = hSize; goto _endJob; }
         ZSTD_invalidateRepCodes(cctx);
@@ -381,9 +380,9 @@ void ZSTDMT_compressChunk(void* jobDescription)
     job->cSize = (job->lastChunk) ?
                  ZSTD_compressEnd     (cctx, dstBuff.start, dstBuff.size, src, job->srcSize) :
                  ZSTD_compressContinue(cctx, dstBuff.start, dstBuff.size, src, job->srcSize);
-    DEBUGLOG(5, "compressed %u bytes into %u bytes   (first:%u) (last:%u) ",
+    DEBUGLOG(5, "compressed %u bytes into %u bytes   (first:%u) (last:%u)",
                 (unsigned)job->srcSize, (unsigned)job->cSize, job->firstChunk, job->lastChunk);
-    DEBUGLOG(5, "dstBuff.size : %u ; => %s ", (U32)dstBuff.size, ZSTD_getErrorName(job->cSize));
+    DEBUGLOG(5, "dstBuff.size : %u ; => %s", (U32)dstBuff.size, ZSTD_getErrorName(job->cSize));
 
 _endJob:
     ZSTDMT_releaseCCtx(job->cctxPool, cctx);
@@ -619,7 +618,7 @@ static size_t ZSTDMT_compress_advanced_internal(
     size_t const overlapSize = (overlapRLog>=9) ? 0 : (size_t)1 << (params.cParams.windowLog - overlapRLog);
     unsigned nbChunks = computeNbChunks(srcSize, params.cParams.windowLog, params.nbThreads);
     size_t const proposedChunkSize = (srcSize + (nbChunks-1)) / nbChunks;
-    size_t const avgChunkSize = (((proposedChunkSize-1) & 0x1FFFF) < 0x7FFF) ? proposedChunkSize + 0xFFFF : proposedChunkSize;   /* avoid too small last block */
+    size_t const avgChunkSize = ((proposedChunkSize & 0x1FFFF) < 0x7FFF) ? proposedChunkSize + 0xFFFF : proposedChunkSize;   /* avoid too small last block */
     const char* const srcStart = (const char*)src;
     size_t remainingSrcSize = srcSize;
     unsigned const compressWithinDst = (dstCapacity >= ZSTD_compressBound(srcSize)) ? nbChunks : (unsigned)(dstCapacity / ZSTD_compressBound(avgChunkSize));  /* presumes avgChunkSize >= 256 KB, which should be the case */
@@ -629,8 +628,7 @@ static size_t ZSTDMT_compress_advanced_internal(
     assert(mtctx->cctxPool->totalCCtx == params.nbThreads);
 
     DEBUGLOG(4, "ZSTDMT_compress_advanced_internal");
-    DEBUGLOG(4, "nbChunks  : %2u (raw chunkSize : %u bytes; fixed chunkSize: %u)   ",
-                nbChunks, (U32)proposedChunkSize, (U32)avgChunkSize);
+    DEBUGLOG(4, "nbChunks  : %2u   (chunkSize : %u bytes)   ", nbChunks, (U32)avgChunkSize);
     if (nbChunks==1) {   /* fallback to single-thread mode */
         ZSTD_CCtx* const cctx = mtctx->cctxPool->cctx[0];
         if (cdict) return ZSTD_compress_usingCDict_advanced(cctx, dst, dstCapacity, src, srcSize, cdict, jobParams.fParams);
@@ -659,7 +657,7 @@ static size_t ZSTDMT_compress_advanced_internal(
 
             mtctx->jobs[u].src = g_nullBuffer;
             mtctx->jobs[u].srcStart = srcStart + frameStartPos - dictSize;
-            mtctx->jobs[u].prefixSize = dictSize;
+            mtctx->jobs[u].dictSize = dictSize;
             mtctx->jobs[u].srcSize = chunkSize;
             mtctx->jobs[u].cdict = (u==0) ? cdict : NULL;
             mtctx->jobs[u].fullFrameSize = srcSize;
@@ -890,7 +888,7 @@ static size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* zcs, size_t srcSize, unsi
     zcs->jobs[jobID].src = zcs->inBuff.buffer;
     zcs->jobs[jobID].srcStart = zcs->inBuff.buffer.start;
     zcs->jobs[jobID].srcSize = srcSize;
-    zcs->jobs[jobID].prefixSize = zcs->dictSize;
+    zcs->jobs[jobID].dictSize = zcs->dictSize;
     assert(zcs->inBuff.filled >= srcSize + zcs->dictSize);
     zcs->jobs[jobID].params = zcs->params;
     /* do not calculate checksum within sections, but write it in header for first section */
@@ -1016,7 +1014,7 @@ size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
 {
     size_t const newJobThreshold = mtctx->dictSize + mtctx->targetSectionSize;
     unsigned forwardInputProgress = 0;
-    DEBUGLOG(5, "ZSTDMT_compressStream_generic ");
+    DEBUGLOG(5, "ZSTDMT_compressStream_generic");
     assert(output->pos <= output->size);
     assert(input->pos  <= input->size);
 
diff --git a/lib/decompress/zstd_decompress.c b/lib/decompress/zstd_decompress.c
index a59d94411..f0cf967cb 100644
--- a/lib/decompress/zstd_decompress.c
+++ b/lib/decompress/zstd_decompress.c
@@ -2451,16 +2451,14 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
                         return ZSTD_decompressLegacyStream(zds->legacyContext, legacyVersion, output, input);
                     }
 #endif
-                    return hSize;   /* error */
+                    return hSize; /* error */
                 }
                 if (hSize != 0) {   /* need more input */
                     size_t const toLoad = hSize - zds->lhSize;   /* if hSize!=0, hSize > zds->lhSize */
-                    size_t const remainingInput = (size_t)(iend-ip);
-                    assert(iend >= ip);
-                    if (toLoad > remainingInput) {   /* not enough input to load full header */
-                        if (remainingInput > 0) {
-                            memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput);
-                            zds->lhSize += remainingInput;
+                    if (toLoad > (size_t)(iend-ip)) {   /* not enough input to load full header */
+                        if (iend-ip > 0) {
+                            memcpy(zds->headerBuffer + zds->lhSize, ip, iend-ip);
+                            zds->lhSize += iend-ip;
                         }
                         input->pos = input->size;
                         return (MAX(ZSTD_frameHeaderSize_min, hSize) - zds->lhSize) + ZSTD_blockHeaderSize;   /* remaining header bytes + next block header */
@@ -2475,10 +2473,8 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
                 && (U64)(size_t)(oend-op) >= zds->fParams.frameContentSize) {
                 size_t const cSize = ZSTD_findFrameCompressedSize(istart, iend-istart);
                 if (cSize <= (size_t)(iend-istart)) {
-                    /* shortcut : using single-pass mode */
                     size_t const decompressedSize = ZSTD_decompress_usingDDict(zds, op, oend-op, istart, cSize, zds->ddict);
                     if (ZSTD_isError(decompressedSize)) return decompressedSize;
-                    DEBUGLOG(4, "shortcut to single-pass ZSTD_decompress_usingDDict()")
                     ip = istart + cSize;
                     op += decompressedSize;
                     zds->expected = 0;
@@ -2501,9 +2497,8 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
             }
 
             /* control buffer memory usage */
-            DEBUGLOG(4, "Control max memory usage (%u KB <= max %u KB)",
-                        (U32)(zds->fParams.windowSize >>10),
-                        (U32)(zds->maxWindowSize >> 10) );
+            DEBUGLOG(4, "Control max buffer memory usage (max %u KB)",
+                        (U32)(zds->maxWindowSize >> 10));
             zds->fParams.windowSize = MAX(zds->fParams.windowSize, 1U << ZSTD_WINDOWLOG_ABSOLUTEMIN);
             if (zds->fParams.windowSize > zds->maxWindowSize) return ERROR(frameParameter_windowTooLarge);
 
diff --git a/lib/zstd.h b/lib/zstd.h
index e4541c3f4..15c467535 100644
--- a/lib/zstd.h
+++ b/lib/zstd.h
@@ -1016,8 +1016,7 @@ typedef enum {
                               * More threads improve speed, but also increase memory usage.
                               * Can only receive a value > 1 if ZSTD_MULTITHREAD is enabled.
                               * Special: value 0 means "do not change nbThreads" */
-    ZSTD_p_jobSize,          /* Size of a compression job. This value is only enforced in streaming (non-blocking) mode.
-                              * Each compression job is completed in parallel, so indirectly controls the nb of active threads.
+    ZSTD_p_jobSize,          /* Size of a compression job. Each compression job is completed in parallel.
                               * 0 means default, which is dynamically determined based on compression parameters.
                               * Job size must be a minimum of overlapSize, or 1 KB, whichever is largest
                               * The minimum size is automatically and transparently enforced */
@@ -1145,19 +1144,13 @@ typedef enum {
  *  - Compression parameters cannot be changed once compression is started.
  *  - outpot->pos must be <= dstCapacity, input->pos must be <= srcSize
  *  - outpot->pos and input->pos will be updated. They are guaranteed to remain below their respective limit.
- *  - In single-thread mode (default), function is blocking : it completed its job before returning to caller.
- *  - In multi-thread mode, function is non-blocking : it just acquires a copy of input, and distribute job to internal worker threads,
- *                                                     and then immediately returns, just indicating that there is some data remaining to be flushed.
- *                                                     The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte.
- *  - Exception : in multi-threading mode, if the first call requests a ZSTD_e_end directive, it is blocking : it will complete compression before giving back control to caller.
- *  - @return provides the minimum amount of data remaining to be flushed from internal buffers
+ *  - @return provides the minimum amount of data still to flush from internal buffers
  *            or an error code, which can be tested using ZSTD_isError().
- *            if @return != 0, flush is not fully completed, there is still some data left within internal buffers.
- *            This is useful to determine if a ZSTD_e_flush or ZSTD_e_end directive is completed.
- *  - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0),
+ *            if @return != 0, flush is not fully completed, there is some data left within internal buffers.
+ *  - after a ZSTD_e_end directive, if internal buffer is not fully flushed,
  *            only ZSTD_e_end or ZSTD_e_flush operations are allowed.
- *            Before starting a new compression job, or changing compression parameters,
- *            it is required to fully flush internal buffers.
+ *            It is necessary to fully flush internal buffers
+ *            before starting a new compression job, or changing compression parameters.
  */
 ZSTDLIB_API size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
                                           ZSTD_outBuffer* output,
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index 6910457ff..e08a96d8f 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -524,12 +524,12 @@ static int basicUnitTests(U32 seed, double compressibility)
     {   ZSTD_DDict* const ddict = ZSTD_createDDict(dictionary.start, dictionary.filled);
         size_t const initError = ZSTD_initDStream_usingDDict(zd, ddict);
         if (ZSTD_isError(initError)) goto _output_error;
-        outBuff.dst = decodedBuffer;
-        outBuff.size = CNBufferSize;
-        outBuff.pos = 0;
         inBuff.src = compressedBuffer;
         inBuff.size = cSize;
         inBuff.pos = 0;
+        outBuff.dst = decodedBuffer;
+        outBuff.size = CNBufferSize;
+        outBuff.pos = 0;
         { size_t const r = ZSTD_decompressStream(zd, &outBuff, &inBuff);
           if (r != 0) goto _output_error; }  /* should reach end of frame == 0; otherwise, some data left, or an error */
         if (outBuff.pos != CNBufferSize) goto _output_error;   /* should regenerate the same amount */
@@ -548,12 +548,12 @@ static int basicUnitTests(U32 seed, double compressibility)
     DISPLAYLEVEL(3, "test%3i : maxWindowSize < frame requirement : ", testNb++);
     ZSTD_initDStream_usingDict(zd, CNBuffer, dictSize);
     CHECK_Z( ZSTD_setDStreamParameter(zd, DStream_p_maxWindowSize, 1000) );  /* too small limit */
-    outBuff.dst = decodedBuffer;
-    outBuff.size = CNBufferSize;
-    outBuff.pos = 0;
     inBuff.src = compressedBuffer;
     inBuff.size = cSize;
     inBuff.pos = 0;
+    outBuff.dst = decodedBuffer;
+    outBuff.size = CNBufferSize;
+    outBuff.pos = 0;
     { size_t const r = ZSTD_decompressStream(zd, &outBuff, &inBuff);
       if (!ZSTD_isError(r)) goto _output_error;  /* must fail : frame requires > 100 bytes */
       DISPLAYLEVEL(3, "OK (%s)\n", ZSTD_getErrorName(r)); }
@@ -642,12 +642,12 @@ static int basicUnitTests(U32 seed, double compressibility)
         params.fParams.contentSizeFlag = 1;
         CHECK_Z( ZSTD_initCStream_advanced(zc, dictionary.start, dictionary.filled, params, 0 /* pledgedSrcSize==0 means "empty" when params.fParams.contentSizeFlag is set */) );
     } /* cstream advanced shall write content size = 0 */
-    outBuff.dst = compressedBuffer;
-    outBuff.size = compressedBufferSize;
-    outBuff.pos = 0;
     inBuff.src = CNBuffer;
     inBuff.size = 0;
     inBuff.pos = 0;
+    outBuff.dst = compressedBuffer;
+    outBuff.size = compressedBufferSize;
+    outBuff.pos = 0;
     CHECK_Z( ZSTD_compressStream(zc, &outBuff, &inBuff) );
     if (ZSTD_endStream(zc, &outBuff) != 0) goto _output_error;
     cSize = outBuff.pos;
@@ -671,12 +671,12 @@ static int basicUnitTests(U32 seed, double compressibility)
     if (ZSTD_findDecompressedSize(compressedBuffer, cSize) != 0) goto _output_error;
 
     ZSTD_resetCStream(zc, 0); /* resetCStream should treat 0 as unknown */
-    outBuff.dst = compressedBuffer;
-    outBuff.size = compressedBufferSize;
-    outBuff.pos = 0;
     inBuff.src = CNBuffer;
     inBuff.size = 0;
     inBuff.pos = 0;
+    outBuff.dst = compressedBuffer;
+    outBuff.size = compressedBufferSize;
+    outBuff.pos = 0;
     CHECK_Z( ZSTD_compressStream(zc, &outBuff, &inBuff) );
     if (ZSTD_endStream(zc, &outBuff) != 0) goto _output_error;
     cSize = outBuff.pos;
@@ -688,7 +688,7 @@ static int basicUnitTests(U32 seed, double compressibility)
     {   ZSTD_parameters const params = ZSTD_getParams(1, 0, 0);
         CHECK_Z( ZSTDMT_initCStream_advanced(mtctx, CNBuffer, dictSize, params, CNBufferSize) );
     }
-    outBuff.dst = compressedBuffer;
+    outBuff.dst = (char*)(compressedBuffer);
     outBuff.size = compressedBufferSize;
     outBuff.pos = 0;
     inBuff.src = CNBuffer;
@@ -700,61 +700,6 @@ static int basicUnitTests(U32 seed, double compressibility)
       if (r != 0) goto _output_error; }  /* error, or some data not flushed */
     DISPLAYLEVEL(3, "OK \n");
 
-    /* Complex multithreading + dictionary test */
-    {   U32 const nbThreads = 2;
-        size_t const jobSize = 4 * 1 MB;
-        size_t const srcSize = jobSize * nbThreads;  /* we want each job to have predictable size */
-        size_t const segLength = 2 KB;
-        size_t const offset = 600 KB;   /* must be larger than window defined in cdict */
-        size_t const start = jobSize + (offset-1);
-        const BYTE* const srcToCopy = (const BYTE*)CNBuffer + start;
-        BYTE* const dst = (BYTE*)CNBuffer + start - offset;
-        DISPLAYLEVEL(3, "test%3i : compress %u bytes with multiple threads + dictionary : ", testNb++, (U32)srcSize);
-        ZSTD_CCtx_setParameter(zc, ZSTD_p_compressionLevel, 3);
-        ZSTD_CCtx_setParameter(zc, ZSTD_p_nbThreads, 2);
-        ZSTD_CCtx_setParameter(zc, ZSTD_p_jobSize, jobSize);
-        assert(start > offset);
-        assert(start + segLength < COMPRESSIBLE_NOISE_LENGTH);
-        memcpy(dst, srcToCopy, segLength);   /* create a long repetition at long distance for job 2 */
-        outBuff.dst = compressedBuffer;
-        outBuff.size = compressedBufferSize;
-        outBuff.pos = 0;
-        inBuff.src = CNBuffer;
-        inBuff.size = srcSize; assert(srcSize < COMPRESSIBLE_NOISE_LENGTH);
-        inBuff.pos = 0;
-    }
-    {   ZSTD_compressionParameters const cParams = ZSTD_getCParams(1, 4 KB, dictionary.filled);   /* intentionnally lies on estimatedSrcSize, to push cdict into targeting a small window size */
-        ZSTD_CDict* const cdict = ZSTD_createCDict_advanced(dictionary.start, dictionary.filled, ZSTD_dlm_byRef, ZSTD_dm_fullDict, cParams, ZSTD_defaultCMem);
-        DISPLAYLEVEL(5, "cParams.windowLog = %u : ", cParams.windowLog);
-        ZSTD_CCtx_refCDict(zc, cdict);
-        CHECK_Z( ZSTD_compress_generic(zc, &outBuff, &inBuff, ZSTD_e_end) );
-        ZSTD_CCtx_refCDict(zc, NULL);  /* do not keep a reference to cdict, as its lifetime ends */
-        ZSTD_freeCDict(cdict);
-    }
-    if (inBuff.pos != inBuff.size) goto _output_error;   /* entire input should be consumed */
-    cSize = outBuff.pos;
-    DISPLAYLEVEL(3, "OK \n");
-
-    DISPLAYLEVEL(3, "test%3i : decompress large frame created from multiple threads + dictionary : ", testNb++);
-    {   ZSTD_DStream* const dstream = ZSTD_createDCtx();
-        ZSTD_frameHeader zfh;
-        ZSTD_getFrameHeader(&zfh, compressedBuffer, cSize);
-        DISPLAYLEVEL(5, "frame windowsize = %u : ", (U32)zfh.windowSize);
-        outBuff.dst = decodedBuffer;
-        outBuff.size = CNBufferSize;
-        outBuff.pos = 0;
-        inBuff.src = compressedBuffer;
-        inBuff.pos = 0;
-        CHECK_Z( ZSTD_initDStream_usingDict(dstream, dictionary.start, dictionary.filled) );
-        inBuff.size = 1;  /* avoid shortcut to single-pass mode */
-        CHECK_Z( ZSTD_decompressStream(dstream, &outBuff, &inBuff) );
-        inBuff.size = cSize;
-        CHECK_Z( ZSTD_decompressStream(dstream, &outBuff, &inBuff) );
-        if (inBuff.pos != inBuff.size) goto _output_error;   /* entire input should be consumed */
-        ZSTD_freeDStream(dstream);
-    }
-    DISPLAYLEVEL(3, "OK \n");
-
     DISPLAYLEVEL(3, "test%3i : check dictionary FSE tables can represent every code : ", testNb++);
     {   unsigned const kMaxWindowLog = 24;
         unsigned value;

From 03832b7aa590ed708354b086842406bc7c4f9b3a Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 12 Dec 2017 14:01:54 -0800
Subject: [PATCH 119/145] re-added test case

messing with revert ... :(
---
 lib/compress/zstd_compress.c     | 11 ++---
 lib/compress/zstdmt_compress.c   | 30 ++++++------
 lib/decompress/zstd_decompress.c | 19 +++++---
 lib/zstd.h                       | 19 +++++---
 tests/zstreamtest.c              | 81 +++++++++++++++++++++++++++-----
 5 files changed, 114 insertions(+), 46 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 3f39875f5..107291888 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -477,7 +477,7 @@ size_t ZSTD_CCtx_setParametersUsingCCtxParams(
 
 ZSTDLIB_API size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize)
 {
-    DEBUGLOG(4, " setting pledgedSrcSize to %u", (U32)pledgedSrcSize);
+    DEBUGLOG(4, "ZSTD_CCtx_setPledgedSrcSize to %u bytes", (U32)pledgedSrcSize);
     if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
     cctx->pledgedSrcSizePlusOne = pledgedSrcSize+1;
     return 0;
@@ -489,7 +489,7 @@ size_t ZSTD_CCtx_loadDictionary_advanced(
 {
     if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
     if (cctx->staticSize) return ERROR(memory_allocation);  /* no malloc for static CCtx */
-    DEBUGLOG(4, "load dictionary of size %u", (U32)dictSize);
+    DEBUGLOG(4, "ZSTD_CCtx_loadDictionary_advanced (size: %u)", (U32)dictSize);
     ZSTD_freeCDict(cctx->cdictLocal);  /* in case one already exists */
     if (dict==NULL || dictSize==0) {   /* no dictionary mode */
         cctx->cdictLocal = NULL;
@@ -2273,7 +2273,7 @@ static size_t ZSTD_initCDict_internal(
                     ZSTD_dictMode_e dictMode,
                     ZSTD_compressionParameters cParams)
 {
-    DEBUGLOG(4, "ZSTD_initCDict_internal, mode %u", (U32)dictMode);
+    DEBUGLOG(3, "ZSTD_initCDict_internal, mode %u", (U32)dictMode);
     if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dictBuffer) || (!dictSize)) {
         cdict->dictBuffer = NULL;
         cdict->dictContent = dictBuffer;
@@ -2303,7 +2303,7 @@ ZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize,
                                       ZSTD_dictMode_e dictMode,
                                       ZSTD_compressionParameters cParams, ZSTD_customMem customMem)
 {
-    DEBUGLOG(4, "ZSTD_createCDict_advanced, mode %u", (U32)dictMode);
+    DEBUGLOG(3, "ZSTD_createCDict_advanced, mode %u", (U32)dictMode);
     if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
 
     {   ZSTD_CDict* const cdict = (ZSTD_CDict*)ZSTD_malloc(sizeof(ZSTD_CDict), customMem);
@@ -2809,7 +2809,7 @@ size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
                               ZSTD_inBuffer* input,
                               ZSTD_EndDirective endOp)
 {
-    DEBUGLOG(5, "ZSTD_compress_generic");
+    DEBUGLOG(5, "ZSTD_compress_generic, endOp=%u ", (U32)endOp);
     /* check conditions */
     if (output->pos > output->size) return ERROR(GENERIC);
     if (input->pos  > input->size)  return ERROR(GENERIC);
@@ -2856,7 +2856,6 @@ size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
 #ifdef ZSTD_MULTITHREAD
     if (cctx->appliedParams.nbThreads > 1) {
         size_t const flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);
-        DEBUGLOG(5, "ZSTDMT_compressStream_generic result : %u", (U32)flushMin);
         if ( ZSTD_isError(flushMin)
           || (endOp == ZSTD_e_end && flushMin == 0) ) { /* compression completed */
             ZSTD_startNewCompression(cctx);
diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c
index 6b6466fe5..8347cf29d 100644
--- a/lib/compress/zstdmt_compress.c
+++ b/lib/compress/zstdmt_compress.c
@@ -310,7 +310,7 @@ static void ZSTDMT_releaseCCtx(ZSTDMT_CCtxPool* pool, ZSTD_CCtx* cctx)
 typedef struct {
     buffer_t src;
     const void* srcStart;
-    size_t   dictSize;
+    size_t   prefixSize;
     size_t   srcSize;
     buffer_t dstBuff;
     size_t   cSize;
@@ -333,10 +333,10 @@ void ZSTDMT_compressChunk(void* jobDescription)
 {
     ZSTDMT_jobDescription* const job = (ZSTDMT_jobDescription*)jobDescription;
     ZSTD_CCtx* const cctx = ZSTDMT_getCCtx(job->cctxPool);
-    const void* const src = (const char*)job->srcStart + job->dictSize;
+    const void* const src = (const char*)job->srcStart + job->prefixSize;
     buffer_t dstBuff = job->dstBuff;
-    DEBUGLOG(5, "ZSTDMT_compressChunk: job (first:%u) (last:%u) : dictSize %u, srcSize %u",
-                 job->firstChunk, job->lastChunk, (U32)job->dictSize, (U32)job->srcSize);
+    DEBUGLOG(5, "ZSTDMT_compressChunk: job (first:%u) (last:%u) : prefixSize %u, srcSize %u ",
+                 job->firstChunk, job->lastChunk, (U32)job->prefixSize, (U32)job->srcSize);
 
     if (cctx==NULL) {
         job->cSize = ERROR(memory_allocation);
@@ -356,20 +356,21 @@ void ZSTDMT_compressChunk(void* jobDescription)
     if (job->cdict) {
         size_t const initError = ZSTD_compressBegin_usingCDict_advanced(cctx, job->cdict, job->params.fParams, job->fullFrameSize);
         DEBUGLOG(4, "ZSTDMT_compressChunk: init using CDict");
-        assert(job->firstChunk); /* should only happen for first segment */
+        assert(job->firstChunk);  /* only allowed for first job */
         if (ZSTD_isError(initError)) { job->cSize = initError; goto _endJob; }
     } else {  /* srcStart points at reloaded section */
         ZSTD_CCtx_params jobParams = job->params;   /* do not modify job->params ! copy it, modify the copy */
         size_t const forceWindowError = ZSTD_CCtxParam_setParameter(&jobParams, ZSTD_p_forceMaxWindow, !job->firstChunk);
         U64 const pledgedSrcSize = job->firstChunk ? job->fullFrameSize : ZSTD_CONTENTSIZE_UNKNOWN;
         /* load dictionary in "content-only" mode (no header analysis) */
-        size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, job->srcStart, job->dictSize, ZSTD_dm_rawContent, jobParams, pledgedSrcSize);
+        size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, job->srcStart, job->prefixSize, ZSTD_dm_rawContent, jobParams, pledgedSrcSize);
+        DEBUGLOG(5, "ZSTD_compressBegin_advanced_internal called with windowLog = %u ", jobParams.cParams.windowLog);
         if (ZSTD_isError(initError) || ZSTD_isError(forceWindowError)) {
             job->cSize = initError;
             goto _endJob;
         }
     }
-    if (!job->firstChunk) {  /* flush and overwrite frame header when it's not first segment */
+    if (!job->firstChunk) {  /* flush and overwrite frame header when it's not first job */
         size_t const hSize = ZSTD_compressContinue(cctx, dstBuff.start, dstBuff.size, src, 0);
         if (ZSTD_isError(hSize)) { job->cSize = hSize; goto _endJob; }
         ZSTD_invalidateRepCodes(cctx);
@@ -380,9 +381,9 @@ void ZSTDMT_compressChunk(void* jobDescription)
     job->cSize = (job->lastChunk) ?
                  ZSTD_compressEnd     (cctx, dstBuff.start, dstBuff.size, src, job->srcSize) :
                  ZSTD_compressContinue(cctx, dstBuff.start, dstBuff.size, src, job->srcSize);
-    DEBUGLOG(5, "compressed %u bytes into %u bytes   (first:%u) (last:%u)",
+    DEBUGLOG(5, "compressed %u bytes into %u bytes   (first:%u) (last:%u) ",
                 (unsigned)job->srcSize, (unsigned)job->cSize, job->firstChunk, job->lastChunk);
-    DEBUGLOG(5, "dstBuff.size : %u ; => %s", (U32)dstBuff.size, ZSTD_getErrorName(job->cSize));
+    DEBUGLOG(5, "dstBuff.size : %u ; => %s ", (U32)dstBuff.size, ZSTD_getErrorName(job->cSize));
 
 _endJob:
     ZSTDMT_releaseCCtx(job->cctxPool, cctx);
@@ -618,7 +619,7 @@ static size_t ZSTDMT_compress_advanced_internal(
     size_t const overlapSize = (overlapRLog>=9) ? 0 : (size_t)1 << (params.cParams.windowLog - overlapRLog);
     unsigned nbChunks = computeNbChunks(srcSize, params.cParams.windowLog, params.nbThreads);
     size_t const proposedChunkSize = (srcSize + (nbChunks-1)) / nbChunks;
-    size_t const avgChunkSize = ((proposedChunkSize & 0x1FFFF) < 0x7FFF) ? proposedChunkSize + 0xFFFF : proposedChunkSize;   /* avoid too small last block */
+    size_t const avgChunkSize = (((proposedChunkSize-1) & 0x1FFFF) < 0x7FFF) ? proposedChunkSize + 0xFFFF : proposedChunkSize;   /* avoid too small last block */
     const char* const srcStart = (const char*)src;
     size_t remainingSrcSize = srcSize;
     unsigned const compressWithinDst = (dstCapacity >= ZSTD_compressBound(srcSize)) ? nbChunks : (unsigned)(dstCapacity / ZSTD_compressBound(avgChunkSize));  /* presumes avgChunkSize >= 256 KB, which should be the case */
@@ -628,7 +629,8 @@ static size_t ZSTDMT_compress_advanced_internal(
     assert(mtctx->cctxPool->totalCCtx == params.nbThreads);
 
     DEBUGLOG(4, "ZSTDMT_compress_advanced_internal");
-    DEBUGLOG(4, "nbChunks  : %2u   (chunkSize : %u bytes)   ", nbChunks, (U32)avgChunkSize);
+    DEBUGLOG(4, "nbChunks  : %2u (raw chunkSize : %u bytes; fixed chunkSize: %u)   ",
+                nbChunks, (U32)proposedChunkSize, (U32)avgChunkSize);
     if (nbChunks==1) {   /* fallback to single-thread mode */
         ZSTD_CCtx* const cctx = mtctx->cctxPool->cctx[0];
         if (cdict) return ZSTD_compress_usingCDict_advanced(cctx, dst, dstCapacity, src, srcSize, cdict, jobParams.fParams);
@@ -657,7 +659,7 @@ static size_t ZSTDMT_compress_advanced_internal(
 
             mtctx->jobs[u].src = g_nullBuffer;
             mtctx->jobs[u].srcStart = srcStart + frameStartPos - dictSize;
-            mtctx->jobs[u].dictSize = dictSize;
+            mtctx->jobs[u].prefixSize = dictSize;
             mtctx->jobs[u].srcSize = chunkSize;
             mtctx->jobs[u].cdict = (u==0) ? cdict : NULL;
             mtctx->jobs[u].fullFrameSize = srcSize;
@@ -888,7 +890,7 @@ static size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* zcs, size_t srcSize, unsi
     zcs->jobs[jobID].src = zcs->inBuff.buffer;
     zcs->jobs[jobID].srcStart = zcs->inBuff.buffer.start;
     zcs->jobs[jobID].srcSize = srcSize;
-    zcs->jobs[jobID].dictSize = zcs->dictSize;
+    zcs->jobs[jobID].prefixSize = zcs->dictSize;
     assert(zcs->inBuff.filled >= srcSize + zcs->dictSize);
     zcs->jobs[jobID].params = zcs->params;
     /* do not calculate checksum within sections, but write it in header for first section */
@@ -1014,7 +1016,7 @@ size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
 {
     size_t const newJobThreshold = mtctx->dictSize + mtctx->targetSectionSize;
     unsigned forwardInputProgress = 0;
-    DEBUGLOG(5, "ZSTDMT_compressStream_generic");
+    DEBUGLOG(5, "ZSTDMT_compressStream_generic ");
     assert(output->pos <= output->size);
     assert(input->pos  <= input->size);
 
diff --git a/lib/decompress/zstd_decompress.c b/lib/decompress/zstd_decompress.c
index f0cf967cb..a59d94411 100644
--- a/lib/decompress/zstd_decompress.c
+++ b/lib/decompress/zstd_decompress.c
@@ -2451,14 +2451,16 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
                         return ZSTD_decompressLegacyStream(zds->legacyContext, legacyVersion, output, input);
                     }
 #endif
-                    return hSize; /* error */
+                    return hSize;   /* error */
                 }
                 if (hSize != 0) {   /* need more input */
                     size_t const toLoad = hSize - zds->lhSize;   /* if hSize!=0, hSize > zds->lhSize */
-                    if (toLoad > (size_t)(iend-ip)) {   /* not enough input to load full header */
-                        if (iend-ip > 0) {
-                            memcpy(zds->headerBuffer + zds->lhSize, ip, iend-ip);
-                            zds->lhSize += iend-ip;
+                    size_t const remainingInput = (size_t)(iend-ip);
+                    assert(iend >= ip);
+                    if (toLoad > remainingInput) {   /* not enough input to load full header */
+                        if (remainingInput > 0) {
+                            memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput);
+                            zds->lhSize += remainingInput;
                         }
                         input->pos = input->size;
                         return (MAX(ZSTD_frameHeaderSize_min, hSize) - zds->lhSize) + ZSTD_blockHeaderSize;   /* remaining header bytes + next block header */
@@ -2473,8 +2475,10 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
                 && (U64)(size_t)(oend-op) >= zds->fParams.frameContentSize) {
                 size_t const cSize = ZSTD_findFrameCompressedSize(istart, iend-istart);
                 if (cSize <= (size_t)(iend-istart)) {
+                    /* shortcut : using single-pass mode */
                     size_t const decompressedSize = ZSTD_decompress_usingDDict(zds, op, oend-op, istart, cSize, zds->ddict);
                     if (ZSTD_isError(decompressedSize)) return decompressedSize;
+                    DEBUGLOG(4, "shortcut to single-pass ZSTD_decompress_usingDDict()")
                     ip = istart + cSize;
                     op += decompressedSize;
                     zds->expected = 0;
@@ -2497,8 +2501,9 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
             }
 
             /* control buffer memory usage */
-            DEBUGLOG(4, "Control max buffer memory usage (max %u KB)",
-                        (U32)(zds->maxWindowSize >> 10));
+            DEBUGLOG(4, "Control max memory usage (%u KB <= max %u KB)",
+                        (U32)(zds->fParams.windowSize >>10),
+                        (U32)(zds->maxWindowSize >> 10) );
             zds->fParams.windowSize = MAX(zds->fParams.windowSize, 1U << ZSTD_WINDOWLOG_ABSOLUTEMIN);
             if (zds->fParams.windowSize > zds->maxWindowSize) return ERROR(frameParameter_windowTooLarge);
 
diff --git a/lib/zstd.h b/lib/zstd.h
index 15c467535..e4541c3f4 100644
--- a/lib/zstd.h
+++ b/lib/zstd.h
@@ -1016,7 +1016,8 @@ typedef enum {
                               * More threads improve speed, but also increase memory usage.
                               * Can only receive a value > 1 if ZSTD_MULTITHREAD is enabled.
                               * Special: value 0 means "do not change nbThreads" */
-    ZSTD_p_jobSize,          /* Size of a compression job. Each compression job is completed in parallel.
+    ZSTD_p_jobSize,          /* Size of a compression job. This value is only enforced in streaming (non-blocking) mode.
+                              * Each compression job is completed in parallel, so indirectly controls the nb of active threads.
                               * 0 means default, which is dynamically determined based on compression parameters.
                               * Job size must be a minimum of overlapSize, or 1 KB, whichever is largest
                               * The minimum size is automatically and transparently enforced */
@@ -1144,13 +1145,19 @@ typedef enum {
  *  - Compression parameters cannot be changed once compression is started.
  *  - outpot->pos must be <= dstCapacity, input->pos must be <= srcSize
  *  - outpot->pos and input->pos will be updated. They are guaranteed to remain below their respective limit.
- *  - @return provides the minimum amount of data still to flush from internal buffers
+ *  - In single-thread mode (default), function is blocking : it completed its job before returning to caller.
+ *  - In multi-thread mode, function is non-blocking : it just acquires a copy of input, and distribute job to internal worker threads,
+ *                                                     and then immediately returns, just indicating that there is some data remaining to be flushed.
+ *                                                     The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte.
+ *  - Exception : in multi-threading mode, if the first call requests a ZSTD_e_end directive, it is blocking : it will complete compression before giving back control to caller.
+ *  - @return provides the minimum amount of data remaining to be flushed from internal buffers
  *            or an error code, which can be tested using ZSTD_isError().
- *            if @return != 0, flush is not fully completed, there is some data left within internal buffers.
- *  - after a ZSTD_e_end directive, if internal buffer is not fully flushed,
+ *            if @return != 0, flush is not fully completed, there is still some data left within internal buffers.
+ *            This is useful to determine if a ZSTD_e_flush or ZSTD_e_end directive is completed.
+ *  - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0),
  *            only ZSTD_e_end or ZSTD_e_flush operations are allowed.
- *            It is necessary to fully flush internal buffers
- *            before starting a new compression job, or changing compression parameters.
+ *            Before starting a new compression job, or changing compression parameters,
+ *            it is required to fully flush internal buffers.
  */
 ZSTDLIB_API size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
                                           ZSTD_outBuffer* output,
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index e08a96d8f..6910457ff 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -524,12 +524,12 @@ static int basicUnitTests(U32 seed, double compressibility)
     {   ZSTD_DDict* const ddict = ZSTD_createDDict(dictionary.start, dictionary.filled);
         size_t const initError = ZSTD_initDStream_usingDDict(zd, ddict);
         if (ZSTD_isError(initError)) goto _output_error;
-        inBuff.src = compressedBuffer;
-        inBuff.size = cSize;
-        inBuff.pos = 0;
         outBuff.dst = decodedBuffer;
         outBuff.size = CNBufferSize;
         outBuff.pos = 0;
+        inBuff.src = compressedBuffer;
+        inBuff.size = cSize;
+        inBuff.pos = 0;
         { size_t const r = ZSTD_decompressStream(zd, &outBuff, &inBuff);
           if (r != 0) goto _output_error; }  /* should reach end of frame == 0; otherwise, some data left, or an error */
         if (outBuff.pos != CNBufferSize) goto _output_error;   /* should regenerate the same amount */
@@ -548,12 +548,12 @@ static int basicUnitTests(U32 seed, double compressibility)
     DISPLAYLEVEL(3, "test%3i : maxWindowSize < frame requirement : ", testNb++);
     ZSTD_initDStream_usingDict(zd, CNBuffer, dictSize);
     CHECK_Z( ZSTD_setDStreamParameter(zd, DStream_p_maxWindowSize, 1000) );  /* too small limit */
-    inBuff.src = compressedBuffer;
-    inBuff.size = cSize;
-    inBuff.pos = 0;
     outBuff.dst = decodedBuffer;
     outBuff.size = CNBufferSize;
     outBuff.pos = 0;
+    inBuff.src = compressedBuffer;
+    inBuff.size = cSize;
+    inBuff.pos = 0;
     { size_t const r = ZSTD_decompressStream(zd, &outBuff, &inBuff);
       if (!ZSTD_isError(r)) goto _output_error;  /* must fail : frame requires > 100 bytes */
       DISPLAYLEVEL(3, "OK (%s)\n", ZSTD_getErrorName(r)); }
@@ -642,12 +642,12 @@ static int basicUnitTests(U32 seed, double compressibility)
         params.fParams.contentSizeFlag = 1;
         CHECK_Z( ZSTD_initCStream_advanced(zc, dictionary.start, dictionary.filled, params, 0 /* pledgedSrcSize==0 means "empty" when params.fParams.contentSizeFlag is set */) );
     } /* cstream advanced shall write content size = 0 */
-    inBuff.src = CNBuffer;
-    inBuff.size = 0;
-    inBuff.pos = 0;
     outBuff.dst = compressedBuffer;
     outBuff.size = compressedBufferSize;
     outBuff.pos = 0;
+    inBuff.src = CNBuffer;
+    inBuff.size = 0;
+    inBuff.pos = 0;
     CHECK_Z( ZSTD_compressStream(zc, &outBuff, &inBuff) );
     if (ZSTD_endStream(zc, &outBuff) != 0) goto _output_error;
     cSize = outBuff.pos;
@@ -671,12 +671,12 @@ static int basicUnitTests(U32 seed, double compressibility)
     if (ZSTD_findDecompressedSize(compressedBuffer, cSize) != 0) goto _output_error;
 
     ZSTD_resetCStream(zc, 0); /* resetCStream should treat 0 as unknown */
-    inBuff.src = CNBuffer;
-    inBuff.size = 0;
-    inBuff.pos = 0;
     outBuff.dst = compressedBuffer;
     outBuff.size = compressedBufferSize;
     outBuff.pos = 0;
+    inBuff.src = CNBuffer;
+    inBuff.size = 0;
+    inBuff.pos = 0;
     CHECK_Z( ZSTD_compressStream(zc, &outBuff, &inBuff) );
     if (ZSTD_endStream(zc, &outBuff) != 0) goto _output_error;
     cSize = outBuff.pos;
@@ -688,7 +688,7 @@ static int basicUnitTests(U32 seed, double compressibility)
     {   ZSTD_parameters const params = ZSTD_getParams(1, 0, 0);
         CHECK_Z( ZSTDMT_initCStream_advanced(mtctx, CNBuffer, dictSize, params, CNBufferSize) );
     }
-    outBuff.dst = (char*)(compressedBuffer);
+    outBuff.dst = compressedBuffer;
     outBuff.size = compressedBufferSize;
     outBuff.pos = 0;
     inBuff.src = CNBuffer;
@@ -700,6 +700,61 @@ static int basicUnitTests(U32 seed, double compressibility)
       if (r != 0) goto _output_error; }  /* error, or some data not flushed */
     DISPLAYLEVEL(3, "OK \n");
 
+    /* Complex multithreading + dictionary test */
+    {   U32 const nbThreads = 2;
+        size_t const jobSize = 4 * 1 MB;
+        size_t const srcSize = jobSize * nbThreads;  /* we want each job to have predictable size */
+        size_t const segLength = 2 KB;
+        size_t const offset = 600 KB;   /* must be larger than window defined in cdict */
+        size_t const start = jobSize + (offset-1);
+        const BYTE* const srcToCopy = (const BYTE*)CNBuffer + start;
+        BYTE* const dst = (BYTE*)CNBuffer + start - offset;
+        DISPLAYLEVEL(3, "test%3i : compress %u bytes with multiple threads + dictionary : ", testNb++, (U32)srcSize);
+        ZSTD_CCtx_setParameter(zc, ZSTD_p_compressionLevel, 3);
+        ZSTD_CCtx_setParameter(zc, ZSTD_p_nbThreads, 2);
+        ZSTD_CCtx_setParameter(zc, ZSTD_p_jobSize, jobSize);
+        assert(start > offset);
+        assert(start + segLength < COMPRESSIBLE_NOISE_LENGTH);
+        memcpy(dst, srcToCopy, segLength);   /* create a long repetition at long distance for job 2 */
+        outBuff.dst = compressedBuffer;
+        outBuff.size = compressedBufferSize;
+        outBuff.pos = 0;
+        inBuff.src = CNBuffer;
+        inBuff.size = srcSize; assert(srcSize < COMPRESSIBLE_NOISE_LENGTH);
+        inBuff.pos = 0;
+    }
+    {   ZSTD_compressionParameters const cParams = ZSTD_getCParams(1, 4 KB, dictionary.filled);   /* intentionnally lies on estimatedSrcSize, to push cdict into targeting a small window size */
+        ZSTD_CDict* const cdict = ZSTD_createCDict_advanced(dictionary.start, dictionary.filled, ZSTD_dlm_byRef, ZSTD_dm_fullDict, cParams, ZSTD_defaultCMem);
+        DISPLAYLEVEL(5, "cParams.windowLog = %u : ", cParams.windowLog);
+        ZSTD_CCtx_refCDict(zc, cdict);
+        CHECK_Z( ZSTD_compress_generic(zc, &outBuff, &inBuff, ZSTD_e_end) );
+        ZSTD_CCtx_refCDict(zc, NULL);  /* do not keep a reference to cdict, as its lifetime ends */
+        ZSTD_freeCDict(cdict);
+    }
+    if (inBuff.pos != inBuff.size) goto _output_error;   /* entire input should be consumed */
+    cSize = outBuff.pos;
+    DISPLAYLEVEL(3, "OK \n");
+
+    DISPLAYLEVEL(3, "test%3i : decompress large frame created from multiple threads + dictionary : ", testNb++);
+    {   ZSTD_DStream* const dstream = ZSTD_createDCtx();
+        ZSTD_frameHeader zfh;
+        ZSTD_getFrameHeader(&zfh, compressedBuffer, cSize);
+        DISPLAYLEVEL(5, "frame windowsize = %u : ", (U32)zfh.windowSize);
+        outBuff.dst = decodedBuffer;
+        outBuff.size = CNBufferSize;
+        outBuff.pos = 0;
+        inBuff.src = compressedBuffer;
+        inBuff.pos = 0;
+        CHECK_Z( ZSTD_initDStream_usingDict(dstream, dictionary.start, dictionary.filled) );
+        inBuff.size = 1;  /* avoid shortcut to single-pass mode */
+        CHECK_Z( ZSTD_decompressStream(dstream, &outBuff, &inBuff) );
+        inBuff.size = cSize;
+        CHECK_Z( ZSTD_decompressStream(dstream, &outBuff, &inBuff) );
+        if (inBuff.pos != inBuff.size) goto _output_error;   /* entire input should be consumed */
+        ZSTD_freeDStream(dstream);
+    }
+    DISPLAYLEVEL(3, "OK \n");
+
     DISPLAYLEVEL(3, "test%3i : check dictionary FSE tables can represent every code : ", testNb++);
     {   unsigned const kMaxWindowLog = 24;
         unsigned value;

From e28305fcca441564a57758d84da8ef73afe7d85d Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 12 Dec 2017 16:20:51 -0800
Subject: [PATCH 120/145] fix #944 : ZSTDMT with large files and dictionary now
 works correctly

windowLog is now enforced from provided compression parameters,
instead of being copied blindly from `cdict`
where it could be smaller.

also :
- fix a minor bug in zstreamtest --mt : advanced parameters must be set before init
- changed advanced parameter name to ZSTDMT_jobSize
---
 lib/compress/zstd_compress.c          | 62 +++++++++++++++------------
 lib/compress/zstd_compress_internal.h |  1 +
 lib/compress/zstdmt_compress.c        | 43 ++++++++++++-------
 lib/compress/zstdmt_compress.h        |  8 ++--
 tests/zstreamtest.c                   | 16 +++----
 5 files changed, 75 insertions(+), 55 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 107291888..7586c3a0c 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -410,7 +410,7 @@ size_t ZSTD_CCtxParam_setParameter(
         return ERROR(parameter_unsupported);
 #else
         if (CCtxParams->nbThreads <= 1) return ERROR(parameter_unsupported);
-        return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_sectionSize, value);
+        return ZSTDMT_CCtxParam_setMTCtxParameter(CCtxParams, ZSTDMT_p_jobSize, value);
 #endif
 
     case ZSTD_p_overlapSizeLog :
@@ -987,15 +987,16 @@ void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx) {
 
 /*! ZSTD_copyCCtx_internal() :
  *  Duplicate an existing context `srcCCtx` into another one `dstCCtx`.
- *  The "context", in this case, refers to the hash and chain tables,
- *  entropy tables, and dictionary offsets.
  *  Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()).
- *  pledgedSrcSize=0 means "empty".
- *  @return : 0, or an error code */
+ *  The "context", in this case, refers to the hash and chain tables,
+ *  entropy tables, and dictionary references.
+ * `windowLog` value is enforced if != 0, otherwise value is copied from srcCCtx.
+ * @return : 0, or an error code */
 static size_t ZSTD_copyCCtx_internal(ZSTD_CCtx* dstCCtx,
                             const ZSTD_CCtx* srcCCtx,
+                            unsigned windowLog,
                             ZSTD_frameParameters fParams,
-                            unsigned long long pledgedSrcSize,
+                            U64 pledgedSrcSize,
                             ZSTD_buffered_policy_e zbuff)
 {
     DEBUGLOG(5, "ZSTD_copyCCtx_internal");
@@ -1005,6 +1006,7 @@ static size_t ZSTD_copyCCtx_internal(ZSTD_CCtx* dstCCtx,
     {   ZSTD_CCtx_params params = dstCCtx->requestedParams;
         /* Copy only compression parameters related to tables. */
         params.cParams = srcCCtx->appliedParams.cParams;
+        if (windowLog) params.cParams.windowLog = windowLog;
         params.fParams = fParams;
         ZSTD_resetCCtx_internal(dstCCtx, params, pledgedSrcSize,
                                 ZSTDcrp_noMemset, zbuff);
@@ -1050,7 +1052,9 @@ size_t ZSTD_copyCCtx(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx, unsigned long
     if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;
     fParams.contentSizeFlag = (pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN);
 
-    return ZSTD_copyCCtx_internal(dstCCtx, srcCCtx, fParams, pledgedSrcSize, zbuff);
+    return ZSTD_copyCCtx_internal(dstCCtx, srcCCtx,
+                                0 /*windowLog from srcCCtx*/, fParams, pledgedSrcSize,
+                                zbuff);
 }
 
 
@@ -2037,12 +2041,12 @@ static size_t ZSTD_compress_insertDictionary(ZSTD_CCtx* cctx,
 
 /*! ZSTD_compressBegin_internal() :
  * @return : 0, or an error code */
-static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
+size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
                              const void* dict, size_t dictSize,
                              ZSTD_dictMode_e dictMode,
                              const ZSTD_CDict* cdict,
-                                   ZSTD_CCtx_params params, U64 pledgedSrcSize,
-                                   ZSTD_buffered_policy_e zbuff)
+                             ZSTD_CCtx_params params, U64 pledgedSrcSize,
+                             ZSTD_buffered_policy_e zbuff)
 {
     DEBUGLOG(4, "ZSTD_compressBegin_internal");
     /* params are supposed to be fully validated at this point */
@@ -2052,7 +2056,7 @@ static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
     if (cdict && cdict->dictContentSize>0) {
         cctx->requestedParams = params;
         return ZSTD_copyCCtx_internal(cctx, cdict->refContext,
-                                      params.fParams, pledgedSrcSize,
+                                      params.cParams.windowLog, params.fParams, pledgedSrcSize,
                                       zbuff);
     }
 
@@ -2061,17 +2065,19 @@ static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
     return ZSTD_compress_insertDictionary(cctx, dict, dictSize, dictMode);
 }
 
-size_t ZSTD_compressBegin_advanced_internal(
-                                    ZSTD_CCtx* cctx,
+size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
                                     const void* dict, size_t dictSize,
                                     ZSTD_dictMode_e dictMode,
+                                    const ZSTD_CDict* cdict,
                                     ZSTD_CCtx_params params,
                                     unsigned long long pledgedSrcSize)
 {
     DEBUGLOG(4, "ZSTD_compressBegin_advanced_internal");
     /* compression parameters verification and optimization */
     CHECK_F( ZSTD_checkCParams(params.cParams) );
-    return ZSTD_compressBegin_internal(cctx, dict, dictSize, dictMode, NULL,
+    return ZSTD_compressBegin_internal(cctx,
+                                       dict, dictSize, dictMode,
+                                       cdict,
                                        params, pledgedSrcSize,
                                        ZSTDb_not_buffered);
 }
@@ -2084,9 +2090,10 @@ size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx,
 {
     ZSTD_CCtx_params const cctxParams =
             ZSTD_assignParamsToCCtxParams(cctx->requestedParams, params);
-    return ZSTD_compressBegin_advanced_internal(cctx, dict, dictSize, ZSTD_dm_auto,
-                                                cctxParams,
-                                                pledgedSrcSize);
+    return ZSTD_compressBegin_advanced_internal(cctx,
+                                            dict, dictSize, ZSTD_dm_auto,
+                                            NULL /*cdict*/,
+                                            cctxParams, pledgedSrcSize);
 }
 
 size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel)
@@ -2507,10 +2514,10 @@ static size_t ZSTD_resetCStream_internal(ZSTD_CStream* zcs,
     assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
 
     CHECK_F( ZSTD_compressBegin_internal(zcs,
-                                        dict, dictSize, dictMode,
-                                        cdict,
-                                        params, pledgedSrcSize,
-                                        ZSTDb_buffered) );
+                                         dict, dictSize, dictMode,
+                                         cdict,
+                                         params, pledgedSrcSize,
+                                         ZSTDb_buffered) );
 
     zcs->inToCompress = 0;
     zcs->inBuffPos = 0;
@@ -2534,7 +2541,7 @@ size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize)
 }
 
 /*! ZSTD_initCStream_internal() :
- *  Note : not static, but hidden (not exposed). Used by zstdmt_compress.c
+ *  Note : for lib/compress only. Used by zstdmt_compress.c.
  *  Assumption 1 : params are valid
  *  Assumption 2 : either dict, or cdict, is defined, not both */
 size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
@@ -2546,7 +2553,7 @@ size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
     assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
 
     if (dict && dictSize >= 8) {
-        DEBUGLOG(5, "loading dictionary of size %u", (U32)dictSize);
+        DEBUGLOG(4, "loading dictionary of size %u", (U32)dictSize);
         if (zcs->staticSize) {   /* static CCtx : never uses malloc */
             /* incompatible with internal cdict creation */
             return ERROR(memory_allocation);
@@ -2559,14 +2566,14 @@ size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
         if (zcs->cdictLocal == NULL) return ERROR(memory_allocation);
     } else {
         if (cdict) {
-            params.cParams = ZSTD_getCParamsFromCDict(cdict);  /* cParams are enforced from cdict */
+            params.cParams = ZSTD_getCParamsFromCDict(cdict);  /* cParams are enforced from cdict; this includes windowLog (should it be enforced from `params` instead ?) */
         }
         ZSTD_freeCDict(zcs->cdictLocal);
         zcs->cdictLocal = NULL;
         zcs->cdict = cdict;
     }
 
-    params.compressionLevel = ZSTD_CLEVEL_CUSTOM;
+    params.compressionLevel = ZSTD_CLEVEL_CUSTOM; /* enforce usage of cParams, instead of a dynamic derivation from cLevel (but does that happen ?) */
     zcs->requestedParams = params;
 
     return ZSTD_resetCStream_internal(zcs, NULL, 0, ZSTD_dm_auto, zcs->cdict, params, pledgedSrcSize);
@@ -2606,10 +2613,9 @@ size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
                                  const void* dict, size_t dictSize,
                                  ZSTD_parameters params, unsigned long long pledgedSrcSize)
 {
-    ZSTD_CCtx_params const cctxParams =
-            ZSTD_assignParamsToCCtxParams(zcs->requestedParams, params);
+    ZSTD_CCtx_params const cctxParams = ZSTD_assignParamsToCCtxParams(zcs->requestedParams, params);
     DEBUGLOG(4, "ZSTD_initCStream_advanced: pledgedSrcSize=%u, flag=%u",
-            (U32)pledgedSrcSize, params.fParams.contentSizeFlag);
+                (U32)pledgedSrcSize, params.fParams.contentSizeFlag);
     CHECK_F( ZSTD_checkCParams(params.cParams) );
     if ((pledgedSrcSize==0) && (params.fParams.contentSizeFlag==0)) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;  /* for compatibility with older programs relying on this behavior. Users should now specify ZSTD_CONTENTSIZE_UNKNOWN. This line will be removed in the future. */
     return ZSTD_initCStream_internal(zcs, dict, dictSize, NULL /*cdict*/, cctxParams, pledgedSrcSize);
diff --git a/lib/compress/zstd_compress_internal.h b/lib/compress/zstd_compress_internal.h
index 278f2427c..f104fe981 100644
--- a/lib/compress/zstd_compress_internal.h
+++ b/lib/compress/zstd_compress_internal.h
@@ -447,6 +447,7 @@ ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict);
 size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
                                     const void* dict, size_t dictSize,
                                     ZSTD_dictMode_e dictMode,
+                                    const ZSTD_CDict* cdict,
                                     ZSTD_CCtx_params params,
                                     unsigned long long pledgedSrcSize);
 
diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c
index 8347cf29d..a5e996d3e 100644
--- a/lib/compress/zstdmt_compress.c
+++ b/lib/compress/zstdmt_compress.c
@@ -350,29 +350,35 @@ void ZSTDMT_compressChunk(void* jobDescription)
             goto _endJob;
         }
         job->dstBuff = dstBuff;
-        DEBUGLOG(5, "ZSTDMT_compressChunk: allocated dstBuff of size %u", (U32)dstBuff.size);
+        DEBUGLOG(5, "ZSTDMT_compressChunk: received dstBuff of size %u", (U32)dstBuff.size);
     }
 
     if (job->cdict) {
-        size_t const initError = ZSTD_compressBegin_usingCDict_advanced(cctx, job->cdict, job->params.fParams, job->fullFrameSize);
+        size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, NULL, 0, ZSTD_dm_auto, job->cdict, job->params, job->fullFrameSize);
         DEBUGLOG(4, "ZSTDMT_compressChunk: init using CDict");
         assert(job->firstChunk);  /* only allowed for first job */
         if (ZSTD_isError(initError)) { job->cSize = initError; goto _endJob; }
     } else {  /* srcStart points at reloaded section */
+        U64 const pledgedSrcSize = job->firstChunk ? job->fullFrameSize : ZSTD_CONTENTSIZE_UNKNOWN;
         ZSTD_CCtx_params jobParams = job->params;   /* do not modify job->params ! copy it, modify the copy */
         size_t const forceWindowError = ZSTD_CCtxParam_setParameter(&jobParams, ZSTD_p_forceMaxWindow, !job->firstChunk);
-        U64 const pledgedSrcSize = job->firstChunk ? job->fullFrameSize : ZSTD_CONTENTSIZE_UNKNOWN;
-        /* load dictionary in "content-only" mode (no header analysis) */
-        size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, job->srcStart, job->prefixSize, ZSTD_dm_rawContent, jobParams, pledgedSrcSize);
-        DEBUGLOG(5, "ZSTD_compressBegin_advanced_internal called with windowLog = %u ", jobParams.cParams.windowLog);
-        if (ZSTD_isError(initError) || ZSTD_isError(forceWindowError)) {
-            job->cSize = initError;
+        if (ZSTD_isError(forceWindowError)) {
+            DEBUGLOG(5, "ZSTD_CCtxParam_setParameter error : %s ", ZSTD_getErrorName(forceWindowError));
+            job->cSize = forceWindowError;
             goto _endJob;
         }
+        /* load dictionary in "content-only" mode (no header analysis) */
+        {   size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, job->srcStart, job->prefixSize, ZSTD_dm_rawContent, NULL, jobParams, pledgedSrcSize);
+            DEBUGLOG(5, "ZSTD_compressBegin_advanced_internal called with windowLog = %u ", jobParams.cParams.windowLog);
+            if (ZSTD_isError(initError)) {
+                DEBUGLOG(5, "ZSTD_compressBegin_advanced_internal error : %s ", ZSTD_getErrorName(initError));
+                job->cSize = initError;
+                goto _endJob;
+        }   }
     }
     if (!job->firstChunk) {  /* flush and overwrite frame header when it's not first job */
         size_t const hSize = ZSTD_compressContinue(cctx, dstBuff.start, dstBuff.size, src, 0);
-        if (ZSTD_isError(hSize)) { job->cSize = hSize; goto _endJob; }
+        if (ZSTD_isError(hSize)) { job->cSize = hSize; /* save error code */ goto _endJob; }
         ZSTD_invalidateRepCodes(cctx);
     }
 
@@ -559,11 +565,13 @@ size_t ZSTDMT_sizeof_CCtx(ZSTDMT_CCtx* mtctx)
 }
 
 /* Internal only */
-size_t ZSTDMT_CCtxParam_setMTCtxParameter(
-    ZSTD_CCtx_params* params, ZSTDMT_parameter parameter, unsigned value) {
+size_t ZSTDMT_CCtxParam_setMTCtxParameter(ZSTD_CCtx_params* params,
+                                ZSTDMT_parameter parameter, unsigned value) {
+    DEBUGLOG(4, "ZSTDMT_CCtxParam_setMTCtxParameter");
     switch(parameter)
     {
-    case ZSTDMT_p_sectionSize :
+    case ZSTDMT_p_jobSize :
+        DEBUGLOG(4, "ZSTDMT_CCtxParam_setMTCtxParameter : set jobSize to %u", value);
         if ( (value > 0)  /* value==0 => automatic job size */
            & (value < ZSTDMT_JOBSIZE_MIN) )
             value = ZSTDMT_JOBSIZE_MIN;
@@ -581,9 +589,10 @@ size_t ZSTDMT_CCtxParam_setMTCtxParameter(
 
 size_t ZSTDMT_setMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, unsigned value)
 {
+    DEBUGLOG(4, "ZSTDMT_setMTCtxParameter");
     switch(parameter)
     {
-    case ZSTDMT_p_sectionSize :
+    case ZSTDMT_p_jobSize :
         return ZSTDMT_CCtxParam_setMTCtxParameter(&mtctx->params, parameter, value);
     case ZSTDMT_p_overlapSectionLog :
         return ZSTDMT_CCtxParam_setMTCtxParameter(&mtctx->params, parameter, value);
@@ -817,7 +826,7 @@ size_t ZSTDMT_initCStream_internal(
     zcs->targetSectionSize = params.jobSize ? params.jobSize : (size_t)1 << (params.cParams.windowLog + 2);
     if (zcs->targetSectionSize < ZSTDMT_JOBSIZE_MIN) zcs->targetSectionSize = ZSTDMT_JOBSIZE_MIN;
     if (zcs->targetSectionSize < zcs->targetDictSize) zcs->targetSectionSize = zcs->targetDictSize;  /* job size must be >= overlap size */
-    DEBUGLOG(4, "Job Size : %u KB", (U32)(zcs->targetSectionSize>>10));
+    DEBUGLOG(4, "Job Size : %u KB (note : set to %u)", (U32)(zcs->targetSectionSize>>10), params.jobSize);
     zcs->inBuffSize = zcs->targetDictSize + zcs->targetSectionSize;
     DEBUGLOG(4, "inBuff Size : %u KB", (U32)(zcs->inBuffSize>>10));
     ZSTDMT_setBufferSize(zcs->bufPool, MAX(zcs->inBuffSize, ZSTD_compressBound(zcs->targetSectionSize)) );
@@ -955,6 +964,7 @@ static size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* zcs, size_t srcSize, unsi
 static size_t ZSTDMT_flushNextJob(ZSTDMT_CCtx* zcs, ZSTD_outBuffer* output, unsigned blockToFlush)
 {
     unsigned const wJobID = zcs->doneJobID & zcs->jobIDMask;
+    DEBUGLOG(5, "ZSTDMT_flushNextJob");
     if (zcs->doneJobID == zcs->nextJobID) return 0;   /* all flushed ! */
     ZSTD_PTHREAD_MUTEX_LOCK(&zcs->jobCompleted_mutex);
     while (zcs->jobs[wJobID].jobCompleted==0) {
@@ -967,7 +977,8 @@ static size_t ZSTDMT_flushNextJob(ZSTDMT_CCtx* zcs, ZSTD_outBuffer* output, unsi
     {   ZSTDMT_jobDescription job = zcs->jobs[wJobID];
         if (!job.jobScanned) {
             if (ZSTD_isError(job.cSize)) {
-                DEBUGLOG(5, "compression error detected ");
+                DEBUGLOG(5, "job %u : compression error detected : %s",
+                            zcs->doneJobID, ZSTD_getErrorName(job.cSize));
                 ZSTDMT_waitForAllJobsCompleted(zcs);
                 ZSTDMT_releaseAllJobResources(zcs);
                 return job.cSize;
@@ -1099,9 +1110,11 @@ size_t ZSTDMT_compressStream(ZSTDMT_CCtx* zcs, ZSTD_outBuffer* output, ZSTD_inBu
 static size_t ZSTDMT_flushStream_internal(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, unsigned endFrame)
 {
     size_t const srcSize = mtctx->inBuff.filled - mtctx->dictSize;
+    DEBUGLOG(5, "ZSTDMT_flushStream_internal");
 
     if ( ((srcSize > 0) || (endFrame && !mtctx->frameEnded))
        && (mtctx->nextJobID <= mtctx->doneJobID + mtctx->jobIDMask) ) {
+           DEBUGLOG(5, "ZSTDMT_flushStream_internal : create a new job");
         CHECK_F( ZSTDMT_createCompressionJob(mtctx, srcSize, endFrame) );
     }
 
diff --git a/lib/compress/zstdmt_compress.h b/lib/compress/zstdmt_compress.h
index 269c54b1a..4209cf3c5 100644
--- a/lib/compress/zstdmt_compress.h
+++ b/lib/compress/zstdmt_compress.h
@@ -84,13 +84,13 @@ ZSTDLIB_API size_t ZSTDMT_initCStream_usingCDict(ZSTDMT_CCtx* mtctx,
 /* ZSTDMT_parameter :
  * List of parameters that can be set using ZSTDMT_setMTCtxParameter() */
 typedef enum {
-    ZSTDMT_p_sectionSize,        /* size of input "section". Each section is compressed in parallel. 0 means default, which is dynamically determined within compression functions */
-    ZSTDMT_p_overlapSectionLog   /* Log of overlapped section; 0 == no overlap, 6(default) == use 1/8th of window, >=9 == use full window */
+    ZSTDMT_p_jobSize,           /* Each job is compressed in parallel. By default, this value is dynamically determined depending on compression parameters. Can be set explicitly here. */
+    ZSTDMT_p_overlapSectionLog  /* Each job may reload a part of previous job to enhance compressionr ratio; 0 == no overlap, 6(default) == use 1/8th of window, >=9 == use full window */
 } ZSTDMT_parameter;
 
 /* ZSTDMT_setMTCtxParameter() :
  * allow setting individual parameters, one at a time, among a list of enums defined in ZSTDMT_parameter.
- * The function must be called typically after ZSTD_createCCtx().
+ * The function must be called typically after ZSTD_createCCtx() but __before ZSTDMT_init*() !__
  * Parameters not explicitly reset by ZSTDMT_init*() remain the same in consecutive compression sessions.
  * @return : 0, or an error code (which can be tested using ZSTD_isError()) */
 ZSTDLIB_API size_t ZSTDMT_setMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSTDMT_parameter parameter, unsigned value);
@@ -114,7 +114,7 @@ size_t ZSTDMT_CCtxParam_setMTCtxParameter(ZSTD_CCtx_params* params, ZSTDMT_param
 
 /* ZSTDMT_CCtxParam_setNbThreads()
  * Set nbThreads, and clamp it correctly,
- * but also reset jobSize and overlapLog */ 
+ * but also reset jobSize and overlapLog */
 size_t ZSTDMT_CCtxParam_setNbThreads(ZSTD_CCtx_params* params, unsigned nbThreads);
 
 /*! ZSTDMT_initCStream_internal() :
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index 6910457ff..67ef6ce80 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -1263,15 +1263,15 @@ static int fuzzerTests_MT(U32 seed, U32 nbTests, unsigned startTest, double comp
             }
             {   U64 const pledgedSrcSize = (FUZ_rand(&lseed) & 3) ? ZSTD_CONTENTSIZE_UNKNOWN : maxTestSize;
                 ZSTD_parameters params = ZSTD_getParams(cLevel, pledgedSrcSize, dictSize);
-                DISPLAYLEVEL(5, "Init with windowLog = %u and pledgedSrcSize = %u \n",
-                    params.cParams.windowLog, (U32)pledgedSrcSize);
+                DISPLAYLEVEL(5, "Init with windowLog = %u, pledgedSrcSize = %u, dictSize = %u \n",
+                    params.cParams.windowLog, (U32)pledgedSrcSize, (U32)dictSize);
                 params.fParams.checksumFlag = FUZ_rand(&lseed) & 1;
                 params.fParams.noDictIDFlag = FUZ_rand(&lseed) & 1;
                 params.fParams.contentSizeFlag = FUZ_rand(&lseed) & 1;
                 DISPLAYLEVEL(5, "checksumFlag : %u \n", params.fParams.checksumFlag);
-                CHECK_Z( ZSTDMT_initCStream_advanced(zc, dict, dictSize, params, pledgedSrcSize) );
                 CHECK_Z( ZSTDMT_setMTCtxParameter(zc, ZSTDMT_p_overlapSectionLog, FUZ_rand(&lseed) % 12) );
-                CHECK_Z( ZSTDMT_setMTCtxParameter(zc, ZSTDMT_p_sectionSize, FUZ_rand(&lseed) % (2*maxTestSize+1)) );
+                CHECK_Z( ZSTDMT_setMTCtxParameter(zc, ZSTDMT_p_jobSize, FUZ_rand(&lseed) % (2*maxTestSize+1)) );   /* custome job size */
+                CHECK_Z( ZSTDMT_initCStream_advanced(zc, dict, dictSize, params, pledgedSrcSize) );
         }   }
 
         /* multi-segments compression test */
@@ -1288,9 +1288,9 @@ static int fuzzerTests_MT(U32 seed, U32 nbTests, unsigned startTest, double comp
                     ZSTD_inBuffer inBuff = { srcBuffer+srcStart, srcSize, 0 };
                     outBuff.size = outBuff.pos + dstBuffSize;
 
-                    DISPLAYLEVEL(5, "Sending %u bytes to compress \n", (U32)srcSize);
+                    DISPLAYLEVEL(6, "Sending %u bytes to compress \n", (U32)srcSize);
                     CHECK_Z( ZSTDMT_compressStream(zc, &outBuff, &inBuff) );
-                    DISPLAYLEVEL(5, "%u bytes read by ZSTDMT_compressStream \n", (U32)inBuff.pos);
+                    DISPLAYLEVEL(6, "%u bytes read by ZSTDMT_compressStream \n", (U32)inBuff.pos);
 
                     XXH64_update(&xxhState, srcBuffer+srcStart, inBuff.pos);
                     memcpy(copyBuffer+totalTestSize, srcBuffer+srcStart, inBuff.pos);
@@ -1337,10 +1337,10 @@ static int fuzzerTests_MT(U32 seed, U32 nbTests, unsigned startTest, double comp
                 size_t const dstBuffSize = MIN(dstBufferSize - totalGenSize, randomDstSize);
                 inBuff.size = inBuff.pos + readCSrcSize;
                 outBuff.size = outBuff.pos + dstBuffSize;
-                DISPLAYLEVEL(5, "ZSTD_decompressStream input %u bytes \n", (U32)readCSrcSize);
+                DISPLAYLEVEL(6, "ZSTD_decompressStream input %u bytes \n", (U32)readCSrcSize);
                 decompressionResult = ZSTD_decompressStream(zd, &outBuff, &inBuff);
                 CHECK (ZSTD_isError(decompressionResult), "decompression error : %s", ZSTD_getErrorName(decompressionResult));
-                DISPLAYLEVEL(5, "inBuff.pos = %u \n", (U32)readCSrcSize);
+                DISPLAYLEVEL(6, "inBuff.pos = %u \n", (U32)readCSrcSize);
             }
             CHECK (outBuff.pos != totalTestSize, "decompressed data : wrong size (%u != %u)", (U32)outBuff.pos, (U32)totalTestSize);
             CHECK (inBuff.pos != cSize, "compressed data should be fully read (%u != %u)", (U32)inBuff.pos, (U32)cSize);

From e9dc0ab8843437ff590a5acbc479ff9769b2f449 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 12 Dec 2017 18:20:04 -0800
Subject: [PATCH 121/145] zstd binary, when compiled from /tests, enables debug
 mode

adds ZSTD_DEBUG=1 and -g
---
 tests/Makefile | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/Makefile b/tests/Makefile
index f944fd5a8..342a648c0 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -76,16 +76,16 @@ allnothread: fullbench fuzzer paramgrill datagen decodecorpus
 dll: fuzzer-dll zstreamtest-dll
 
 zstd:
-	$(MAKE) -C $(PRGDIR) $@
+	$(MAKE) -C $(PRGDIR) $@ MOREFLAGS="$(DEBUGFLAGS)"
 
 zstd32:
-	$(MAKE) -C $(PRGDIR) $@
+	$(MAKE) -C $(PRGDIR) $@ MOREFLAGS="$(DEBUGFLAGS)"
 
 zstd-nolegacy:
-	$(MAKE) -C $(PRGDIR) $@
+	$(MAKE) -C $(PRGDIR) $@ MOREFLAGS="$(DEBUGFLAGS)"
 
 gzstd:
-	$(MAKE) -C $(PRGDIR) zstd HAVE_ZLIB=1
+	$(MAKE) -C $(PRGDIR) zstd HAVE_ZLIB=1 MOREFLAGS="$(DEBUGFLAGS)"
 
 fullbench32: CPPFLAGS += -m32
 fullbench fullbench32 : CPPFLAGS += $(MULTITHREAD_CPP)

From 98ccc115edffd286d44ac6501479c7462b770825 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 12 Dec 2017 19:47:38 -0800
Subject: [PATCH 122/145] added cli test veryfying bug #944

this test fails on v1.3.2
---
 tests/playTests.sh | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/playTests.sh b/tests/playTests.sh
index 299c2d883..6b78b305a 100755
--- a/tests/playTests.sh
+++ b/tests/playTests.sh
@@ -297,6 +297,8 @@ cp $TESTFILE tmp
 $ZSTD -f tmp -D tmpDict
 $ZSTD -d tmp.zst -D tmpDict -fo result
 $DIFF $TESTFILE result
+$ECHO "- Test dictionary compression with multithreading "
+./datagen -g5M | $ZSTD -T2 -D tmpDict | $ZSTD -t -D tmpDict   # fails with v1.3.2 
 $ECHO "- Create second (different) dictionary "
 $ZSTD --train *.c ../programs/*.c ../programs/*.h -o tmpDictC
 $ZSTD -d tmp.zst -D tmpDictC -fo result && die "wrong dictionary not detected!"

From 04a1557e2808be33bf199757482c59fa4bd287da Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 13 Dec 2017 10:08:52 -0800
Subject: [PATCH 123/145] fuzzer tests : added -v command

so that unit tests get listed in CI console
and we can see which one failed.
---
 tests/Makefile | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/Makefile b/tests/Makefile
index f944fd5a8..79df7dd95 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -300,10 +300,10 @@ test-fullbench32: fullbench32 datagen
 	$(QEMU_SYS) ./fullbench32 -i1 -P0
 
 test-fuzzer: fuzzer
-	$(QEMU_SYS) ./fuzzer $(FUZZERTEST) $(FUZZER_FLAGS)
+	$(QEMU_SYS) ./fuzzer -v $(FUZZERTEST) $(FUZZER_FLAGS)
 
 test-fuzzer32: fuzzer32
-	$(QEMU_SYS) ./fuzzer32 $(FUZZERTEST) $(FUZZER_FLAGS)
+	$(QEMU_SYS) ./fuzzer32 -v $(FUZZERTEST) $(FUZZER_FLAGS)
 
 test-zbuff: zbufftest
 	$(QEMU_SYS) ./zbufftest $(ZSTREAM_TESTTIME)
@@ -312,7 +312,7 @@ test-zbuff32: zbufftest32
 	$(QEMU_SYS) ./zbufftest32 $(ZSTREAM_TESTTIME)
 
 test-zstream: zstreamtest
-	$(QEMU_SYS) ./zstreamtest $(ZSTREAM_TESTTIME) $(FUZZER_FLAGS)
+	$(QEMU_SYS) ./zstreamtest -v $(ZSTREAM_TESTTIME) $(FUZZER_FLAGS)
 	$(QEMU_SYS) ./zstreamtest --mt -t1 $(ZSTREAM_TESTTIME) $(FUZZER_FLAGS)
 	$(QEMU_SYS) ./zstreamtest --newapi -t1 $(ZSTREAM_TESTTIME) $(FUZZER_FLAGS)
 	$(QEMU_SYS) ./zstreamtest --opaqueapi -t1 $(ZSTREAM_TESTTIME) $(FUZZER_FLAGS)

From b5e7f6c0f3e023d9a6622d2b227bf6d15c73c574 Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Wed, 13 Dec 2017 10:55:24 -0800
Subject: [PATCH 124/145] [fileio] Fix window size MB calculation

Test command:
```
head -c 10000 /dev/zero | ./zstd -c --zstd=wlog=12 | ./zstd -M2048 -t
```
---
 programs/fileio.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/programs/fileio.c b/programs/fileio.c
index 101c99b1a..4758fa0ed 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -1149,7 +1149,7 @@ static void FIO_zstdErrorHelp(dRess_t* ress, size_t ret, char const* srcFileName
     if (ret == 0) {
         U32 const windowSize = (U32)header.windowSize;
         U32 const windowLog = BIT_highbit32(windowSize) + ((windowSize & (windowSize - 1)) != 0);
-        U32 const windowMB = (windowSize >> 20) + (windowSize & ((1 MB) - 1));
+        U32 const windowMB = (windowSize >> 20) + ((windowSize & ((1 MB) - 1)) != 0);
         assert(header.windowSize <= (U64)((U32)-1));
         assert(g_memLimit > 0);
         DISPLAYLEVEL(1, "%s : Window size larger than maximum : %llu > %u\n",

From 22727a7467ff55892c6b9775a0c190cecc8b9b5c Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Tue, 12 Dec 2017 17:37:06 -0800
Subject: [PATCH 125/145] Fix cdict compressor repcodes

---
 lib/compress/zstd_compress.c |  6 +++++
 tests/fuzzer.c               | 44 ++++++++++++++++++++++++++++++++++++
 2 files changed, 50 insertions(+)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 3f39875f5..8cd288d2a 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -1033,6 +1033,12 @@ static size_t ZSTD_copyCCtx_internal(ZSTD_CCtx* dstCCtx,
 
     /* copy entropy tables */
     memcpy(dstCCtx->entropy, srcCCtx->entropy, sizeof(ZSTD_entropyCTables_t));
+    /* copy repcodes */
+    {
+        int i;
+        for (i = 0; i < ZSTD_REP_NUM; ++i)
+            dstCCtx->seqStore.rep[i] = srcCCtx->seqStore.rep[i];
+    }
 
     return 0;
 }
diff --git a/tests/fuzzer.c b/tests/fuzzer.c
index 46671a15c..f799b5f9e 100644
--- a/tests/fuzzer.c
+++ b/tests/fuzzer.c
@@ -835,6 +835,50 @@ static int basicUnitTests(U32 seed, double compressibility)
         }
         DISPLAYLEVEL(4, "OK \n");
 
+        DISPLAYLEVEL(4, "test%3i : Dictionary with non-default repcodes : ", testNb++);
+        { U32 u; for (u=0; u<nbSamples; u++) samplesSizes[u] = sampleUnitSize; }
+        dictSize = ZDICT_trainFromBuffer(dictBuffer, dictSize,
+                                         CNBuffer, samplesSizes, nbSamples);
+        if (ZDICT_isError(dictSize)) goto _output_error;
+        /* Set all the repcodes to non-default */
+        {
+            BYTE* dictPtr = (BYTE*)dictBuffer;
+            BYTE* dictLimit = dictPtr + dictSize - 12;
+            /* Find the repcodes */
+            while (dictPtr < dictLimit &&
+                   (MEM_readLE32(dictPtr) != 1 || MEM_readLE32(dictPtr + 4) != 4 ||
+                    MEM_readLE32(dictPtr + 8) != 8)) {
+                ++dictPtr;
+            }
+            if (dictPtr >= dictLimit) goto _output_error;
+            MEM_writeLE32(dictPtr + 0, 10);
+            MEM_writeLE32(dictPtr + 4, 10);
+            MEM_writeLE32(dictPtr + 8, 10);
+            /* Set the last 8 bytes to 'x' */
+            memset((BYTE*)dictBuffer + dictSize - 8, 'x', 8);
+        }
+        /* The optimal parser checks all the repcodes.
+         * Make sure at least one is a match >= targetLength so that it is
+         * immediately chosen. This will make sure that the compressor and
+         * decompressor agree on at least one of the repcodes.
+         */
+        {   size_t dSize;
+            BYTE data[1024];
+            ZSTD_compressionParameters const cParams = ZSTD_getCParams(19, CNBuffSize, dictSize);
+            ZSTD_CDict* const cdict = ZSTD_createCDict_advanced(dictBuffer, dictSize,
+                                            ZSTD_dlm_byRef, ZSTD_dm_auto,
+                                            cParams, ZSTD_defaultCMem);
+            memset(data, 'x', sizeof(data));
+            cSize = ZSTD_compress_usingCDict(cctx, compressedBuffer, compressedBufferSize,
+                                             data, sizeof(data), cdict);
+            ZSTD_freeCDict(cdict);
+            if (ZSTD_isError(cSize)) { DISPLAYLEVEL(5, "Compression error %s : ", ZSTD_getErrorName(cSize)); goto _output_error; }
+            dSize = ZSTD_decompress_usingDict(dctx, decodedBuffer, sizeof(data), compressedBuffer, cSize, dictBuffer, dictSize);
+            if (ZSTD_isError(dSize)) { DISPLAYLEVEL(5, "Decompression error %s : ", ZSTD_getErrorName(dSize)); goto _output_error; }
+            if (memcmp(data, decodedBuffer, sizeof(data))) { DISPLAYLEVEL(5, "Data corruption : "); goto _output_error; }
+        }
+        DISPLAYLEVEL(4, "OK \n");
+
         ZSTD_freeCCtx(cctx);
         free(dictBuffer);
         free(samplesSizes);

From 311878dec3ae7a9d9cf54883c0dac8c1ccedc81a Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 13 Dec 2017 11:48:30 -0800
Subject: [PATCH 126/145] Improved tests

- building cli from /tests preserves potential flags in MOREFLAGS (such as asan/usan)
- MT dictionary tests check for MT capability (MT is not enabled by default for zstd32)
---
 tests/Makefile     | 6 +++---
 tests/playTests.sh | 7 +++++--
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/tests/Makefile b/tests/Makefile
index faa7d019c..853f4ee89 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -76,13 +76,13 @@ allnothread: fullbench fuzzer paramgrill datagen decodecorpus
 dll: fuzzer-dll zstreamtest-dll
 
 zstd:
-	$(MAKE) -C $(PRGDIR) $@ MOREFLAGS="$(DEBUGFLAGS)"
+	$(MAKE) -C $(PRGDIR) $@ MOREFLAGS+="$(DEBUGFLAGS)"
 
 zstd32:
-	$(MAKE) -C $(PRGDIR) $@ MOREFLAGS="$(DEBUGFLAGS)"
+	$(MAKE) -C $(PRGDIR) $@ MOREFLAGS+="$(DEBUGFLAGS)"
 
 zstd-nolegacy:
-	$(MAKE) -C $(PRGDIR) $@ MOREFLAGS="$(DEBUGFLAGS)"
+	$(MAKE) -C $(PRGDIR) $@ MOREFLAGS+="$(DEBUGFLAGS)"
 
 gzstd:
 	$(MAKE) -C $(PRGDIR) zstd HAVE_ZLIB=1 MOREFLAGS="$(DEBUGFLAGS)"
diff --git a/tests/playTests.sh b/tests/playTests.sh
index 6b78b305a..67732d3a1 100755
--- a/tests/playTests.sh
+++ b/tests/playTests.sh
@@ -297,8 +297,11 @@ cp $TESTFILE tmp
 $ZSTD -f tmp -D tmpDict
 $ZSTD -d tmp.zst -D tmpDict -fo result
 $DIFF $TESTFILE result
-$ECHO "- Test dictionary compression with multithreading "
-./datagen -g5M | $ZSTD -T2 -D tmpDict | $ZSTD -t -D tmpDict   # fails with v1.3.2 
+if [ -n "$hasMT" ]
+then
+    $ECHO "- Test dictionary compression with multithreading "
+    ./datagen -g5M | $ZSTD -T2 -D tmpDict | $ZSTD -t -D tmpDict   # fails with v1.3.2 
+fi
 $ECHO "- Create second (different) dictionary "
 $ZSTD --train *.c ../programs/*.c ../programs/*.h -o tmpDictC
 $ZSTD -d tmp.zst -D tmpDictC -fo result && die "wrong dictionary not detected!"

From 82bc8fe0cc3746d9b02b86c1bddaed842d07f755 Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Wed, 13 Dec 2017 12:04:46 -0800
Subject: [PATCH 127/145] [fileio] Refuse to remove non-regular file

---
 programs/fileio.c  | 12 ++++++++++--
 tests/playTests.sh |  8 ++++++++
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/programs/fileio.c b/programs/fileio.c
index 101c99b1a..a0e370bac 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -261,6 +261,10 @@ void FIO_setLdmHashEveryLog(unsigned ldmHashEveryLog) {
  * @result : Unlink `fileName`, even if it's read-only */
 static int FIO_remove(const char* path)
 {
+    if (!UTIL_isRegularFile(path)) {
+        DISPLAYLEVEL(2, "zstd: Refusing to remove non-regular file %s\n", path);
+        return 0;
+    }
 #if defined(_WIN32) || defined(WIN32)
     /* windows doesn't allow remove read-only files,
      * so try to make it writable first */
@@ -314,9 +318,13 @@ static FILE* FIO_openDstFile(const char* dstFileName)
         g_sparseFileSupport = ZSTD_SPARSE_DEFAULT;
     }
 
-    if (strcmp (dstFileName, nulmark)) {  /* not /dev/null */
+    if (UTIL_isRegularFile(dstFileName)) {
+        FILE* fCheck;
+        if (!strcmp(dstFileName, nulmark)) {
+            EXM_THROW(40, "%s is unexpectedly a regular file", dstFileName);
+        }
         /* Check if destination file already exists */
-        FILE* const fCheck = fopen( dstFileName, "rb" );
+        fCheck = fopen( dstFileName, "rb" );
         if (fCheck != NULL) {  /* dst file exists, authorization prompt */
             fclose(fCheck);
             if (!g_overwrite) {
diff --git a/tests/playTests.sh b/tests/playTests.sh
index 299c2d883..402808c0d 100755
--- a/tests/playTests.sh
+++ b/tests/playTests.sh
@@ -56,10 +56,12 @@ fi
 
 isWindows=false
 INTOVOID="/dev/null"
+DEVDEVICE="/dev/zero"
 case "$OS" in
   Windows*)
     isWindows=true
     INTOVOID="NUL"
+    DEVDEVICE="NUL"
     ;;
 esac
 
@@ -159,6 +161,12 @@ $ZSTD -f --rm tmp
 test ! -f tmp  # tmp should no longer be present
 $ZSTD -f -d --rm tmp.zst
 test ! -f tmp.zst   # tmp.zst should no longer be present
+$ECHO "test : should quietly not remove non-regular file"
+$ECHO hello > tmp
+$ZSTD tmp -f -o "$DEVDEVICE" 2>tmplog > "$INTOVOID"
+grep -v "Refusing to remove non-regular file" tmplog
+rm -f tmplog
+$ZSTD tmp -f -o "$INTONULL" 2>&1 | grep -v "Refusing to remove non-regular file"
 $ECHO "test : --rm on stdin"
 $ECHO a | $ZSTD --rm > $INTOVOID   # --rm should remain silent
 rm tmp

From d23eb9a098ce99ae0fe039496385687c0e574c60 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 13 Dec 2017 15:35:49 -0800
Subject: [PATCH 128/145] zstreamtest : added missing CHECK_Z()

---
 lib/compress/zstd_compress.c |  2 +-
 tests/zstreamtest.c          | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 7586c3a0c..34bfb737c 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -2566,7 +2566,7 @@ size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
         if (zcs->cdictLocal == NULL) return ERROR(memory_allocation);
     } else {
         if (cdict) {
-            params.cParams = ZSTD_getCParamsFromCDict(cdict);  /* cParams are enforced from cdict; this includes windowLog (should it be enforced from `params` instead ?) */
+            params.cParams = ZSTD_getCParamsFromCDict(cdict);  /* cParams are enforced from cdict; it includes windowLog */
         }
         ZSTD_freeCDict(zcs->cdictLocal);
         zcs->cdictLocal = NULL;
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index 67ef6ce80..70922e2e0 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -710,9 +710,9 @@ static int basicUnitTests(U32 seed, double compressibility)
         const BYTE* const srcToCopy = (const BYTE*)CNBuffer + start;
         BYTE* const dst = (BYTE*)CNBuffer + start - offset;
         DISPLAYLEVEL(3, "test%3i : compress %u bytes with multiple threads + dictionary : ", testNb++, (U32)srcSize);
-        ZSTD_CCtx_setParameter(zc, ZSTD_p_compressionLevel, 3);
-        ZSTD_CCtx_setParameter(zc, ZSTD_p_nbThreads, 2);
-        ZSTD_CCtx_setParameter(zc, ZSTD_p_jobSize, jobSize);
+        CHECK_Z( ZSTD_CCtx_setParameter(zc, ZSTD_p_compressionLevel, 3) );
+        CHECK_Z( ZSTD_CCtx_setParameter(zc, ZSTD_p_nbThreads, 2) );
+        CHECK_Z( ZSTD_CCtx_setParameter(zc, ZSTD_p_jobSize, jobSize) );
         assert(start > offset);
         assert(start + segLength < COMPRESSIBLE_NOISE_LENGTH);
         memcpy(dst, srcToCopy, segLength);   /* create a long repetition at long distance for job 2 */
@@ -726,9 +726,9 @@ static int basicUnitTests(U32 seed, double compressibility)
     {   ZSTD_compressionParameters const cParams = ZSTD_getCParams(1, 4 KB, dictionary.filled);   /* intentionnally lies on estimatedSrcSize, to push cdict into targeting a small window size */
         ZSTD_CDict* const cdict = ZSTD_createCDict_advanced(dictionary.start, dictionary.filled, ZSTD_dlm_byRef, ZSTD_dm_fullDict, cParams, ZSTD_defaultCMem);
         DISPLAYLEVEL(5, "cParams.windowLog = %u : ", cParams.windowLog);
-        ZSTD_CCtx_refCDict(zc, cdict);
+        CHECK_Z( ZSTD_CCtx_refCDict(zc, cdict) );
         CHECK_Z( ZSTD_compress_generic(zc, &outBuff, &inBuff, ZSTD_e_end) );
-        ZSTD_CCtx_refCDict(zc, NULL);  /* do not keep a reference to cdict, as its lifetime ends */
+        CHECK_Z( ZSTD_CCtx_refCDict(zc, NULL) );  /* do not keep a reference to cdict, as its lifetime ends */
         ZSTD_freeCDict(cdict);
     }
     if (inBuff.pos != inBuff.size) goto _output_error;   /* entire input should be consumed */

From 4680e85bdf6d6862564a7465b77f9243592cc66a Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Tue, 12 Dec 2017 18:32:50 -0800
Subject: [PATCH 129/145] Allow -o with multiple files

---
 programs/fileio.c  | 26 +++++++++++---------------
 programs/fileio.h  |  4 ++--
 programs/zstdcli.c | 10 ++--------
 tests/playTests.sh | 16 ++++++++++++++++
 4 files changed, 31 insertions(+), 25 deletions(-)

diff --git a/programs/fileio.c b/programs/fileio.c
index 5a8840b5b..16c2cb8fe 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -939,7 +939,7 @@ int FIO_compressFilename(const char* dstFileName, const char* srcFileName,
 
 
 int FIO_compressMultipleFilenames(const char** inFileNamesTable, unsigned nbFiles,
-                                  const char* suffix,
+                                  const char* outFileName, const char* suffix,
                                   const char* dictFileName, int compressionLevel,
                                   ZSTD_compressionParameters* comprParams)
 {
@@ -955,16 +955,15 @@ int FIO_compressMultipleFilenames(const char** inFileNamesTable, unsigned nbFile
     /* init */
     if (dstFileName==NULL)
         EXM_THROW(27, "FIO_compressMultipleFilenames : allocation error for dstFileName");
-    if (suffix == NULL)
+    if (outFileName == NULL && suffix == NULL)
         EXM_THROW(28, "FIO_compressMultipleFilenames : dst unknown");  /* should never happen */
 
     /* loop on each file */
-    if (!strcmp(suffix, stdoutmark)) {
+    if (outFileName != NULL) {
         unsigned u;
-        ress.dstFile = stdout;
-        SET_BINARY_MODE(stdout);
+        ress.dstFile = FIO_openDstFile(outFileName);
         for (u=0; u<nbFiles; u++)
-            missed_files += FIO_compressFilename_srcFile(ress, stdoutmark, inFileNamesTable[u], compressionLevel);
+            missed_files += FIO_compressFilename_srcFile(ress, outFileName, inFileNamesTable[u], compressionLevel);
         if (fclose(ress.dstFile))
             EXM_THROW(29, "Write error : cannot properly close stdout");
     } else {
@@ -1654,24 +1653,21 @@ int FIO_decompressFilename(const char* dstFileName, const char* srcFileName,
 
 #define MAXSUFFIXSIZE 8
 int FIO_decompressMultipleFilenames(const char** srcNamesTable, unsigned nbFiles,
-                                    const char* suffix,
+                                    const char* outFileName,
                                     const char* dictFileName)
 {
     int skippedFiles = 0;
     int missingFiles = 0;
     dRess_t ress = FIO_createDResources(dictFileName);
 
-    if (suffix==NULL)
-        EXM_THROW(70, "zstd: decompression: unknown dst");   /* should never happen */
-
-    if (!strcmp(suffix, stdoutmark) || !strcmp(suffix, nulmark)) {  /* special cases : -c or -t */
+    if (outFileName) {
         unsigned u;
-        ress.dstFile = FIO_openDstFile(suffix);
-        if (ress.dstFile == 0) EXM_THROW(71, "cannot open %s", suffix);
+        ress.dstFile = FIO_openDstFile(outFileName);
+        if (ress.dstFile == 0) EXM_THROW(71, "cannot open %s", outFileName);
         for (u=0; u<nbFiles; u++)
-            missingFiles += FIO_decompressSrcFile(ress, suffix, srcNamesTable[u]);
+            missingFiles += FIO_decompressSrcFile(ress, outFileName, srcNamesTable[u]);
         if (fclose(ress.dstFile))
-            EXM_THROW(72, "Write error : cannot properly close stdout");
+            EXM_THROW(72, "Write error : cannot properly close output file");
     } else {
         size_t suffixSize;
         size_t dfnSize = FNSPACE;
diff --git a/programs/fileio.h b/programs/fileio.h
index aa4484fdc..9b9c7ea2f 100644
--- a/programs/fileio.h
+++ b/programs/fileio.h
@@ -84,14 +84,14 @@ int FIO_listMultipleFiles(unsigned numFiles, const char** filenameTable, int dis
 /** FIO_compressMultipleFilenames() :
     @return : nb of missing files */
 int FIO_compressMultipleFilenames(const char** srcNamesTable, unsigned nbFiles,
-                                  const char* suffix,
+                                  const char* outFileName, const char* suffix,
                                   const char* dictFileName, int compressionLevel,
                                   ZSTD_compressionParameters* comprParams);
 
 /** FIO_decompressMultipleFilenames() :
     @return : nb of missing or skipped files */
 int FIO_decompressMultipleFilenames(const char** srcNamesTable, unsigned nbFiles,
-                                    const char* suffix,
+                                    const char* outFileName,
                                     const char* dictFileName);
 
 
diff --git a/programs/zstdcli.c b/programs/zstdcli.c
index 8b4186207..7e29998b0 100644
--- a/programs/zstdcli.c
+++ b/programs/zstdcli.c
@@ -815,12 +815,6 @@ int main(int argCount, const char* argv[])
     if (outFileName && !strcmp(outFileName, stdoutmark) && IS_CONSOLE(stdout) && !strcmp(filenameTable[0], stdinmark) && !forceStdout && operation!=zom_decompress)
         CLEAN_RETURN(badusage(programName));
 
-    /* user-selected output filename, only possible with a single file */
-    if (outFileName && strcmp(outFileName,stdoutmark) && strcmp(outFileName,nulmark) && (filenameIdx>1)) {
-        DISPLAY("Too many files (%u) on the command line. \n", filenameIdx);
-        CLEAN_RETURN(filenameIdx);
-    }
-
 #ifndef ZSTD_NOCOMPRESS
     /* check compression level limits */
     {   int const maxCLevel = ultra ? ZSTD_maxCLevel() : ZSTDCLI_CLEVEL_MAX;
@@ -854,7 +848,7 @@ int main(int argCount, const char* argv[])
         if ((filenameIdx==1) && outFileName)
           operationResult = FIO_compressFilename(outFileName, filenameTable[0], dictFileName, cLevel, &compressionParams);
         else
-          operationResult = FIO_compressMultipleFilenames(filenameTable, filenameIdx, outFileName ? outFileName : suffix, dictFileName, cLevel, &compressionParams);
+          operationResult = FIO_compressMultipleFilenames(filenameTable, filenameIdx, outFileName, suffix, dictFileName, cLevel, &compressionParams);
 #else
         (void)suffix;
         DISPLAY("Compression not supported\n");
@@ -872,7 +866,7 @@ int main(int argCount, const char* argv[])
         if (filenameIdx==1 && outFileName)
             operationResult = FIO_decompressFilename(outFileName, filenameTable[0], dictFileName);
         else
-            operationResult = FIO_decompressMultipleFilenames(filenameTable, filenameIdx, outFileName ? outFileName : ZSTD_EXTENSION, dictFileName);
+            operationResult = FIO_decompressMultipleFilenames(filenameTable, filenameIdx, outFileName, dictFileName);
 #else
         DISPLAY("Decompression not supported\n");
 #endif
diff --git a/tests/playTests.sh b/tests/playTests.sh
index 402808c0d..773da845b 100755
--- a/tests/playTests.sh
+++ b/tests/playTests.sh
@@ -173,6 +173,22 @@ rm tmp
 $ZSTD -f tmp && die "tmp not present : should have failed"
 test ! -f tmp.zst  # tmp.zst should not be created
 
+$ECHO "test : compress multiple files"
+$ECHO hello > tmp1
+$ECHO world > tmp2
+$ZSTD tmp1 tmp2 -o "$INTOVOID"
+$ZSTD tmp1 tmp2 -c | $ZSTD -t
+$ZSTD tmp1 tmp2 -o tmp.zst
+test ! -f tmp1.zst
+test ! -f tmp2.zst
+$ZSTD tmp1 tmp2
+$ZSTD -t tmp1.zst tmp2.zst
+$ZSTD -dc tmp1.zst tmp2.zst
+$ZSTD tmp1.zst tmp2.zst -o "$INTOVOID"
+$ZSTD -d tmp1.zst tmp2.zst -o tmp
+rm tmp*
+
+
 
 $ECHO "\n===>  Advanced compression parameters "
 $ECHO "Hello world!" | $ZSTD --zstd=windowLog=21,      - -o tmp.zst && die "wrong parameters not detected!"

From 5432ef6921b840c6cfe25f5d8ffcc87f4f91deff Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 13 Dec 2017 17:45:26 -0800
Subject: [PATCH 130/145] fixes adaptation on srcSize

This patch restores capability for each file to receive adapted compression parameters depending on its size.

The bug breaking this feature was relatively silly :
setting a parameter with a value "0" is supposed to be a no-op.
Unfortunately, it would pin down compression parameters as if they were manually set,
preventing later automatic adaptation.

Unfortunately, I'm currently short of a test case that could check this situation and trigger an error.
Compression parameters selection between tableID 0,1,2,3 is largely internal,
leaving no trace to outside world, not even in frame header.
---
 lib/compress/zstd_compress.c | 12 ++++++++++--
 programs/fileio.c            |  2 +-
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 8cd288d2a..d52261aae 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -144,6 +144,8 @@ const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx) { return &(ctx->seqStor
 static ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(
         ZSTD_CCtx_params CCtxParams, U64 srcSizeHint, size_t dictSize)
 {
+    DEBUGLOG(4, "ZSTD_getCParamsFromCCtxParams: srcSize = %u, dictSize = %u",
+                (U32)srcSizeHint, (U32)dictSize);
     return (CCtxParams.compressionLevel == ZSTD_CLEVEL_CUSTOM) ?
                 CCtxParams.cParams :
                 ZSTD_getCParams(CCtxParams.compressionLevel, srcSizeHint, dictSize);
@@ -151,18 +153,22 @@ static ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(
 
 static void ZSTD_cLevelToCCtxParams_srcSize(ZSTD_CCtx_params* CCtxParams, U64 srcSize)
 {
+    DEBUGLOG(4, "ZSTD_cLevelToCCtxParams_srcSize: srcSize = %u",
+                (U32)srcSize);
     CCtxParams->cParams = ZSTD_getCParamsFromCCtxParams(*CCtxParams, srcSize, 0);
     CCtxParams->compressionLevel = ZSTD_CLEVEL_CUSTOM;
 }
 
 static void ZSTD_cLevelToCParams(ZSTD_CCtx* cctx)
 {
+    DEBUGLOG(4, "ZSTD_cLevelToCParams");
     ZSTD_cLevelToCCtxParams_srcSize(
             &cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1);
 }
 
 static void ZSTD_cLevelToCCtxParams(ZSTD_CCtx_params* CCtxParams)
 {
+    DEBUGLOG(4, "ZSTD_cLevelToCCtxParams");
     ZSTD_cLevelToCCtxParams_srcSize(CCtxParams, 0);
 }
 
@@ -261,7 +267,7 @@ size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned v
     case ZSTD_p_targetLength:
     case ZSTD_p_compressionStrategy:
         if (cctx->cdict) return ERROR(stage_wrong);
-        ZSTD_cLevelToCParams(cctx);  /* Can optimize if srcSize is known */
+        if (value>0) ZSTD_cLevelToCParams(cctx);  /* Can optimize if srcSize is known */
         return ZSTD_CCtxParam_setParameter(&cctx->requestedParams, param, value);
 
     case ZSTD_p_contentSizeFlag:
@@ -422,7 +428,7 @@ size_t ZSTD_CCtxParam_setParameter(
 #endif
 
     case ZSTD_p_enableLongDistanceMatching :
-        if (value != 0) {
+        if (value) {
             ZSTD_cLevelToCCtxParams(CCtxParams);
             CCtxParams->cParams.windowLog = ZSTD_LDM_DEFAULT_WINDOW_LOG;
         }
@@ -3056,6 +3062,8 @@ ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long l
     size_t const addedSize = srcSizeHint ? 0 : 500;
     U64 const rSize = srcSizeHint+dictSize ? srcSizeHint+dictSize+addedSize : (U64)-1;
     U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);   /* intentional underflow for srcSizeHint == 0 */
+    DEBUGLOG(4, "ZSTD_getCParams: cLevel=%i, srcSize=%u, dictSize=%u => table %u",
+                compressionLevel, (U32)srcSizeHint, (U32)dictSize, tableID);
 
 #if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=1)
     static int g_monotonicTest = 1;
diff --git a/programs/fileio.c b/programs/fileio.c
index 4758fa0ed..879954078 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -446,7 +446,7 @@ static cRess_t FIO_createCResources(const char* dictFileName, int cLevel,
         DISPLAYLEVEL(5,"set nb threads = %u \n", g_nbThreads);
         CHECK( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_p_nbThreads, g_nbThreads) );
         /* dictionary */
-        CHECK( ZSTD_CCtx_setPledgedSrcSize(ress.cctx, srcSize) );  /* just for dictionary loading, using good compression parameters */
+        CHECK( ZSTD_CCtx_setPledgedSrcSize(ress.cctx, srcSize) );  /* just for dictionary loading, for compression parameters adaptation */
         CHECK( ZSTD_CCtx_loadDictionary(ress.cctx, dictBuffer, dictBuffSize) );
         CHECK( ZSTD_CCtx_setPledgedSrcSize(ress.cctx, ZSTD_CONTENTSIZE_UNKNOWN) );  /* reset */
 

From 2e97a6d464d85e82584ba77f971526f1f1fd106b Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Wed, 13 Dec 2017 18:50:05 -0800
Subject: [PATCH 131/145] fixed minor declaration-after-statement warning

---
 lib/compress/zstd_compress.c | 6 ++++--
 programs/fileio.c            | 4 ++++
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index d52261aae..02235c11a 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -1738,6 +1738,8 @@ static size_t ZSTD_compress_frameChunk (ZSTD_CCtx* cctx,
             op += cSize;
             assert(dstCapacity >= cSize);
             dstCapacity -= cSize;
+            DEBUGLOG(5, "ZSTD_compress_frameChunk: adding a block of size %u",
+                        (U32)cSize);
     }   }
 
     if (lastFrameChunk && (op>ostart)) cctx->stage = ZSTDcs_ending;
@@ -3062,8 +3064,6 @@ ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long l
     size_t const addedSize = srcSizeHint ? 0 : 500;
     U64 const rSize = srcSizeHint+dictSize ? srcSizeHint+dictSize+addedSize : (U64)-1;
     U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);   /* intentional underflow for srcSizeHint == 0 */
-    DEBUGLOG(4, "ZSTD_getCParams: cLevel=%i, srcSize=%u, dictSize=%u => table %u",
-                compressionLevel, (U32)srcSizeHint, (U32)dictSize, tableID);
 
 #if defined(ZSTD_DEBUG) && (ZSTD_DEBUG>=1)
     static int g_monotonicTest = 1;
@@ -3073,6 +3073,8 @@ ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long l
     }
 #endif
 
+    DEBUGLOG(4, "ZSTD_getCParams: cLevel=%i, srcSize=%u, dictSize=%u => table %u",
+                compressionLevel, (U32)srcSizeHint, (U32)dictSize, tableID);
     if (compressionLevel <= 0) compressionLevel = ZSTD_CLEVEL_DEFAULT;   /* 0 == default; no negative compressionLevel yet */
     if (compressionLevel > ZSTD_MAX_CLEVEL) compressionLevel = ZSTD_MAX_CLEVEL;
     { ZSTD_compressionParameters const cp = ZSTD_defaultCParameters[tableID][compressionLevel];
diff --git a/programs/fileio.c b/programs/fileio.c
index 879954078..68032af94 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -781,6 +781,8 @@ static int FIO_compressFilename_internal(cRess_t ress,
                         &outBuff, &inBuff, ZSTD_e_continue) );
 
             /* Write compressed stream */
+            DISPLAYLEVEL(6, "ZSTD_compress_generic,ZSTD_e_continue: generated %u bytes \n",
+                            (U32)outBuff.pos);
             if (outBuff.pos) {
                 size_t const sizeCheck = fwrite(ress.dstBuffer, 1, outBuff.pos, dstFile);
                 if (sizeCheck!=outBuff.pos)
@@ -816,6 +818,8 @@ static int FIO_compressFilename_internal(cRess_t ress,
                 EXM_THROW(26, "Compression error during frame end : %s",
                             ZSTD_getErrorName(result));
             }
+            DISPLAYLEVEL(6, "ZSTD_compress_generic,ZSTD_e_end: generated %u bytes \n",
+                            (U32)outBuff.pos);
             {   size_t const sizeCheck = fwrite(ress.dstBuffer, 1, outBuff.pos, dstFile);
                 if (sizeCheck != outBuff.pos)
                     EXM_THROW(27, "Write error : cannot write frame end into %s", dstFileName);

From 281f06e01f6ad818769e71804f625c9750ac459c Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Thu, 14 Dec 2017 11:47:02 -0800
Subject: [PATCH 132/145] saves 3-bytes on small input with streaming API

zstd streaming API was adding a null-block at end of frame for small input.

Reason is : on small input, a single block is enough.
ZSTD_CStream would size its input buffer to expect a single block of this size,
automatically triggering a flush on reaching this size.

Unfortunately, that last byte was generally received before the "end" directive (at least in `fileio`).
The later "end" directive would force the creation of a 3-bytes last block to indicate end of frame.

The solution is to not flush automatically, which is btw the expected behavior.
It happens in this case because blocksize is defined with exactly the same size as input.
Just adding one-byte is enough to stop triggering the automatic flush.

I initially looked at another solution, solving the problem directly in the compression context.
But it felt awkward.
Now, the underlying compression API `ZSTD_compressContinue()` would take the decision the close a frame
on reaching its expected end (`pledgedSrcSize`).
This feels awkward, a responsability over-reach, beyond the definition of this API.
ZSTD_compressContinue() is clearly documented as a guaranteed flush,
with ZSTD_compressEnd() generating a guaranteed end.

I faced similar issue when trying to port a similar mechanism at the higher streaming layer.
Having ZSTD_CStream end a frame automatically on reaching `pledgedSrcSize` can surprise the caller,
since it did not explicitly requested an end of frame.
The only sensible action remaining after that is to end the frame with no additional input.
This adds additional logic in the ZSTD_CStream state to check this condition.
Plus some potential confusion on the meaning of ZSTD_endStream() with no additional input (ending confirmation ? new 0-size frame ?)

In the end, just enlarging input buffer by 1 byte feels the least intrusive change.
It's also a contract remaining inside the streaming layer, so the logic is contained in this part of the code.

The patch also introduces a new test checking that size of small frame is as expected, without additional 3-bytes null block.
---
 lib/compress/zstd_compress.c | 9 +++++----
 tests/playTests.sh           | 4 +++-
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 0dec78820..37dd5a4b0 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -2527,7 +2527,8 @@ static size_t ZSTD_resetCStream_internal(ZSTD_CStream* zcs,
 
     zcs->inToCompress = 0;
     zcs->inBuffPos = 0;
-    zcs->inBuffTarget = zcs->blockSize;
+    zcs->inBuffTarget = zcs->blockSize
+                      + (zcs->blockSize == pledgedSrcSize);   /* for small input: avoid automatic flush on reaching end of block, since it would require to add a 3-bytes null block to end frame */
     zcs->outBuffContentSize = zcs->outBuffFlushedSize = 0;
     zcs->streamStage = zcss_load;
     zcs->frameEnded = 0;
@@ -2679,9 +2680,9 @@ size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
     /* check expectations */
     DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%u", (U32)flushMode);
     assert(zcs->inBuff != NULL);
-    assert(zcs->inBuffSize>0);
-    assert(zcs->outBuff!= NULL);
-    assert(zcs->outBuffSize>0);
+    assert(zcs->inBuffSize > 0);
+    assert(zcs->outBuff !=  NULL);
+    assert(zcs->outBuffSize > 0);
     assert(output->pos <= output->size);
     assert(input->pos <= input->size);
 
diff --git a/tests/playTests.sh b/tests/playTests.sh
index 9db3dadea..c48148fa2 100755
--- a/tests/playTests.sh
+++ b/tests/playTests.sh
@@ -126,6 +126,8 @@ $ZSTD -d > $INTOVOID && die "should have refused : compressed data from terminal
 fi
 $ECHO "test : null-length file roundtrip"
 $ECHO -n '' | $ZSTD - --stdout | $ZSTD -d --stdout
+$ECHO "test : ensure small file doesn't add 3-bytes null block"
+./datagen -g1 | $ZSTD | wc -c | grep "14"
 $ECHO "test : decompress file with wrong suffix (must fail)"
 $ZSTD -d tmpCompressed && die "wrong suffix error not detected!"
 $ZSTD -df tmp && die "should have refused : wrong extension"
@@ -324,7 +326,7 @@ $DIFF $TESTFILE result
 if [ -n "$hasMT" ]
 then
     $ECHO "- Test dictionary compression with multithreading "
-    ./datagen -g5M | $ZSTD -T2 -D tmpDict | $ZSTD -t -D tmpDict   # fails with v1.3.2 
+    ./datagen -g5M | $ZSTD -T2 -D tmpDict | $ZSTD -t -D tmpDict   # fails with v1.3.2
 fi
 $ECHO "- Create second (different) dictionary "
 $ZSTD --train *.c ../programs/*.c ../programs/*.h -o tmpDictC

From a0e0985d38d05a9a28b8b94a9f9ece8120c146a8 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Thu, 14 Dec 2017 13:32:24 -0800
Subject: [PATCH 133/145] added test on small file

on top of test on small stream
---
 tests/playTests.sh | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/playTests.sh b/tests/playTests.sh
index c48148fa2..c93c58fe8 100755
--- a/tests/playTests.sh
+++ b/tests/playTests.sh
@@ -127,7 +127,9 @@ fi
 $ECHO "test : null-length file roundtrip"
 $ECHO -n '' | $ZSTD - --stdout | $ZSTD -d --stdout
 $ECHO "test : ensure small file doesn't add 3-bytes null block"
-./datagen -g1 | $ZSTD | wc -c | grep "14"
+./datagen -g1 > tmp1
+$ZSTD tmp1 -c | wc -c | grep "14"
+$ZSTD < tmp1  | wc -c | grep "14"
 $ECHO "test : decompress file with wrong suffix (must fail)"
 $ZSTD -d tmpCompressed && die "wrong suffix error not detected!"
 $ZSTD -df tmp && die "should have refused : wrong extension"

From f48d34edba069b33d30ad75d1684b2a8e1071520 Mon Sep 17 00:00:00 2001
From: Nick Terrell <terrelln@fb.com>
Date: Thu, 14 Dec 2017 13:00:20 -0800
Subject: [PATCH 134/145] [fileio] Merge end loop for small optimization

---
 programs/fileio.c | 51 +++++++++++++++++------------------------------
 1 file changed, 18 insertions(+), 33 deletions(-)

diff --git a/programs/fileio.c b/programs/fileio.c
index 339c968b2..b57ce14d2 100644
--- a/programs/fileio.c
+++ b/programs/fileio.c
@@ -118,12 +118,13 @@ static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
     exit(error);                                                          \
 }
 
-#define CHECK(f) {                                   \
-    size_t const err = f;                            \
-    if (ZSTD_isError(err)) {                         \
+#define CHECK_V(v, f)                                \
+    v = f;                                           \
+    if (ZSTD_isError(v)) {                           \
         DEBUGLOG(1, "%s \n", #f);                    \
-        EXM_THROW(11, "%s", ZSTD_getErrorName(err)); \
-}   }
+        EXM_THROW(11, "%s", ZSTD_getErrorName(v));   \
+    }
+#define CHECK(f) { size_t err; CHECK_V(err, f); }
 
 
 /*-************************************
@@ -733,6 +734,7 @@ static int FIO_compressFilename_internal(cRess_t ress,
     U64 readsize = 0;
     U64 compressedfilesize = 0;
     U64 const fileSize = UTIL_getFileSize(srcFileName);
+    ZSTD_EndDirective directive = ZSTD_e_continue;
     DISPLAYLEVEL(5, "%s: %u bytes \n", srcFileName, (U32)fileSize);
 
     switch (g_compressionType) {
@@ -776,17 +778,20 @@ static int FIO_compressFilename_internal(cRess_t ress,
         ZSTD_CCtx_setPledgedSrcSize(ress.cctx, fileSize);
 
     /* Main compression loop */
-    while (1) {
+    do {
+        size_t result;
         /* Fill input Buffer */
         size_t const inSize = fread(ress.srcBuffer, (size_t)1, ress.srcBufferSize, srcFile);
         ZSTD_inBuffer inBuff = { ress.srcBuffer, inSize, 0 };
-        if (inSize==0) break;
         readsize += inSize;
 
-        while (inBuff.pos != inBuff.size) {
+        if (inSize == 0 || (fileSize != UTIL_FILESIZE_UNKNOWN && readsize == fileSize))
+            directive = ZSTD_e_end;
+
+        result = 1;
+        while (inBuff.pos != inBuff.size || (directive == ZSTD_e_end && result != 0)) {
             ZSTD_outBuffer outBuff = { ress.dstBuffer, ress.dstBufferSize, 0 };
-            CHECK( ZSTD_compress_generic(ress.cctx,
-                        &outBuff, &inBuff, ZSTD_e_continue) );
+            CHECK_V(result, ZSTD_compress_generic(ress.cctx, &outBuff, &inBuff, directive));
 
             /* Write compressed stream */
             DISPLAYLEVEL(6, "ZSTD_compress_generic,ZSTD_e_continue: generated %u bytes \n",
@@ -796,7 +801,8 @@ static int FIO_compressFilename_internal(cRess_t ress,
                 if (sizeCheck!=outBuff.pos)
                     EXM_THROW(25, "Write error : cannot write compressed block into %s", dstFileName);
                 compressedfilesize += outBuff.pos;
-        }   }
+            }
+        }
         if (g_nbThreads > 1) {
             if (fileSize == UTIL_FILESIZE_UNKNOWN)
                 DISPLAYUPDATE(2, "\rRead : %u MB", (U32)(readsize>>20))
@@ -813,28 +819,7 @@ static int FIO_compressFilename_internal(cRess_t ress,
                                 (U32)(readsize>>20), (U32)(fileSize>>20),
                                 (double)compressedfilesize/readsize*100);
         }
-    }
-
-    /* End of Frame */
-    {   size_t result = 1;
-        while (result != 0) {
-            ZSTD_outBuffer outBuff = { ress.dstBuffer, ress.dstBufferSize, 0 };
-            ZSTD_inBuffer inBuff = { NULL, 0, 0 };
-            result = ZSTD_compress_generic(ress.cctx,
-                        &outBuff, &inBuff, ZSTD_e_end);
-            if (ZSTD_isError(result)) {
-                EXM_THROW(26, "Compression error during frame end : %s",
-                            ZSTD_getErrorName(result));
-            }
-            DISPLAYLEVEL(6, "ZSTD_compress_generic,ZSTD_e_end: generated %u bytes \n",
-                            (U32)outBuff.pos);
-            {   size_t const sizeCheck = fwrite(ress.dstBuffer, 1, outBuff.pos, dstFile);
-                if (sizeCheck != outBuff.pos)
-                    EXM_THROW(27, "Write error : cannot write frame end into %s", dstFileName);
-            }
-            compressedfilesize += outBuff.pos;
-        }
-    }
+    } while (directive != ZSTD_e_end);
 
 finish:
     /* Status */

From 2cff66b62f68ec2e76f401629c7083f65a8198ec Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Thu, 14 Dec 2017 16:11:20 -0800
Subject: [PATCH 135/145] version bump to v1.3.3

---
 NEWS                 | 12 ++++++++++++
 doc/zstd_manual.html | 29 ++++++++++++++++++-----------
 lib/zstd.h           |  2 +-
 programs/Makefile    |  4 ++--
 programs/zstd.1      |  2 +-
 5 files changed, 34 insertions(+), 15 deletions(-)

diff --git a/NEWS b/NEWS
index 215c0a329..a45960b96 100644
--- a/NEWS
+++ b/NEWS
@@ -1,3 +1,15 @@
+v1.3.3
+perf: faster zstd_opt strategy (levels 17-19)
+fix : bug #944 : multithreading with shared ditionary and large data, reported by @gsliepen
+cli : fix : content size written in header by default
+cli : fix : improved LZ4 format support, by @felixhandte
+cli : new : hidden command `-S`, to benchmark multiple files while generating one result per file
+api : fix : support large skippable frames, by @terrelln
+api : fix : streaming interface was adding a useless 3-bytes null block to small frames
+api : change : when setting `pledgedSrcSize`, use `ZSTD_CONTENTSIZE_UNKNOWN` macro value to mean "unknown"
+build: fix : compilation under rhel6 and centos6, reported by @pixelb
+build: added `check` target
+
 v1.3.2
 new : long range mode, using --long command, by Stella Lau (@stellamplau)
 new : ability to generate and decode magicless frames (#591)
diff --git a/doc/zstd_manual.html b/doc/zstd_manual.html
index 872dbf637..da11ddb2a 100644
--- a/doc/zstd_manual.html
+++ b/doc/zstd_manual.html
@@ -1,10 +1,10 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>zstd 1.3.2 Manual</title>
+<title>zstd 1.3.3 Manual</title>
 </head>
 <body>
-<h1>zstd 1.3.2 Manual</h1>
+<h1>zstd 1.3.3 Manual</h1>
 <hr>
 <a name="Contents"></a><h2>Contents</h2>
 <ol>
@@ -633,12 +633,12 @@ size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMet
 
 <h3>Advanced Streaming compression functions</h3><pre></pre><b><pre>ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);
 ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize);    </b>/**< same as ZSTD_initStaticCCtx() */<b>
-size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize);   </b>/**< pledgedSrcSize must be correct. If it is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs, a size of 0 is interepreted as "unknown". But it may change in some future version to mean "empty". */<b>
+size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pledgedSrcSize);   </b>/**< pledgedSrcSize must be correct. If it is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs, "0" also disables frame content size field. It may be enabled in the future. */<b>
 size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel); </b>/**< creates of an internal CDict (incompatible with static CCtx), except if dict == NULL or dictSize < 8, in which case no dict is used. Note: dict is loaded with ZSTD_dm_auto (treated as a full zstd dictionary if it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.*/<b>
 size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs, const void* dict, size_t dictSize,
-                                             ZSTD_parameters params, unsigned long long pledgedSrcSize);  </b>/**< pledgedSrcSize : if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */<b>
+                                             ZSTD_parameters params, unsigned long long pledgedSrcSize);  </b>/**< pledgedSrcSize must be correct. If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. dict is loaded with ZSTD_dm_auto and ZSTD_dlm_byCopy. */<b>
 size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);  </b>/**< note : cdict will just be referenced, and must outlive compression session */<b>
-size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize);  </b>/**< same as ZSTD_initCStream_usingCDict(), with control over frame parameters */<b>
+size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs, const ZSTD_CDict* cdict, ZSTD_frameParameters fParams, unsigned long long pledgedSrcSize);  </b>/**< same as ZSTD_initCStream_usingCDict(), with control over frame parameters. pledgedSrcSize must be correct. If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN. */<b>
 </pre></b><BR>
 <pre><b>size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);
 </b><p>  start a new compression job, using same parameters from previous job.
@@ -863,7 +863,8 @@ size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long
                               * More threads improve speed, but also increase memory usage.
                               * Can only receive a value > 1 if ZSTD_MULTITHREAD is enabled.
                               * Special: value 0 means "do not change nbThreads" */
-    ZSTD_p_jobSize,          </b>/* Size of a compression job. Each compression job is completed in parallel.<b>
+    ZSTD_p_jobSize,          </b>/* Size of a compression job. This value is only enforced in streaming (non-blocking) mode.<b>
+                              * Each compression job is completed in parallel, so indirectly controls the nb of active threads.
                               * 0 means default, which is dynamically determined based on compression parameters.
                               * Job size must be a minimum of overlapSize, or 1 KB, whichever is largest
                               * The minimum size is automatically and transparently enforced */
@@ -990,13 +991,19 @@ size_t ZSTD_CCtx_refPrefix_advanced(ZSTD_CCtx* cctx, const void* prefix, size_t
   - Compression parameters cannot be changed once compression is started.
   - outpot->pos must be <= dstCapacity, input->pos must be <= srcSize
   - outpot->pos and input->pos will be updated. They are guaranteed to remain below their respective limit.
-  - @return provides the minimum amount of data still to flush from internal buffers
+  - In single-thread mode (default), function is blocking : it completed its job before returning to caller.
+  - In multi-thread mode, function is non-blocking : it just acquires a copy of input, and distribute job to internal worker threads,
+                                                     and then immediately returns, just indicating that there is some data remaining to be flushed.
+                                                     The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte.
+  - Exception : in multi-threading mode, if the first call requests a ZSTD_e_end directive, it is blocking : it will complete compression before giving back control to caller.
+  - @return provides the minimum amount of data remaining to be flushed from internal buffers
             or an error code, which can be tested using ZSTD_isError().
-            if @return != 0, flush is not fully completed, there is some data left within internal buffers.
-  - after a ZSTD_e_end directive, if internal buffer is not fully flushed,
+            if @return != 0, flush is not fully completed, there is still some data left within internal buffers.
+            This is useful to determine if a ZSTD_e_flush or ZSTD_e_end directive is completed.
+  - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0),
             only ZSTD_e_end or ZSTD_e_flush operations are allowed.
-            It is necessary to fully flush internal buffers
-            before starting a new compression job, or changing compression parameters.
+            Before starting a new compression job, or changing compression parameters,
+            it is required to fully flush internal buffers.
  
 </p></pre><BR>
 
diff --git a/lib/zstd.h b/lib/zstd.h
index e4541c3f4..9ac0a73dc 100644
--- a/lib/zstd.h
+++ b/lib/zstd.h
@@ -59,7 +59,7 @@ extern "C" {
 /*------   Version   ------*/
 #define ZSTD_VERSION_MAJOR    1
 #define ZSTD_VERSION_MINOR    3
-#define ZSTD_VERSION_RELEASE  2
+#define ZSTD_VERSION_RELEASE  3
 
 #define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
 ZSTDLIB_API unsigned ZSTD_versionNumber(void);   /**< useful to check dll version */
diff --git a/programs/Makefile b/programs/Makefile
index 37788db39..51888d3ef 100644
--- a/programs/Makefile
+++ b/programs/Makefile
@@ -226,8 +226,8 @@ clean:
 MD2ROFF = ronn
 MD2ROFF_FLAGS = --roff --warnings --manual="User Commands" --organization="zstd $(ZSTD_VERSION)"
 
-zstd.1: zstd.1.md
-	cat $^ | $(MD2ROFF) $(MD2ROFF_FLAGS) | sed -n '/^\.\\\".*/!p' > $@
+zstd.1: zstd.1.md ../lib/zstd.h
+	cat $< | $(MD2ROFF) $(MD2ROFF_FLAGS) | sed -n '/^\.\\\".*/!p' > $@
 
 .PHONY: man
 man: zstd.1
diff --git a/programs/zstd.1 b/programs/zstd.1
index eb53e2c33..e0902e858 100644
--- a/programs/zstd.1
+++ b/programs/zstd.1
@@ -1,5 +1,5 @@
 .
-.TH "ZSTD" "1" "November 2017" "zstd 1.3.2" "User Commands"
+.TH "ZSTD" "1" "December 2017" "zstd 1.3.3" "User Commands"
 .
 .SH "NAME"
 \fBzstd\fR \- zstd, zstdmt, unzstd, zstdcat \- Compress or decompress \.zst files

From 3cbfac1cdb7635b799809575208cc0318055a1fc Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Thu, 14 Dec 2017 23:29:00 -0800
Subject: [PATCH 136/145] updated levels 15-20

taking advantage of `btopt` improved speed to tune parameters.
Levels 16-19 are stronger than previous release, making the graph more favorable.

In theory, I should also update small-size tables,
but I got lazy on that one ...
---
 lib/compress/zstd_compress.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 44f8c68a8..ebc9c1854 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -2955,12 +2955,12 @@ static const ZSTD_compressionParameters ZSTD_defaultCParameters[4][ZSTD_MAX_CLEV
     { 22, 20, 22,  5,  5, 16, ZSTD_lazy2   },  /* level 12 */
     { 22, 21, 22,  5,  5, 16, ZSTD_lazy2   },  /* level 13 */
     { 22, 21, 22,  6,  5, 16, ZSTD_lazy2   },  /* level 14 */
-    { 22, 21, 22,  5,  5, 16, ZSTD_btlazy2 },  /* level 15 */
-    { 23, 22, 22,  5,  5, 16, ZSTD_btlazy2 },  /* level 16 */
-    { 23, 22, 22,  4,  5, 24, ZSTD_btopt   },  /* level 17 */
-    { 23, 22, 22,  5,  4, 32, ZSTD_btopt   },  /* level 18 */
-    { 23, 23, 22,  6,  3, 48, ZSTD_btopt   },  /* level 19 */
-    { 25, 25, 23,  7,  3, 64, ZSTD_btultra },  /* level 20 */
+    { 22, 21, 22,  4,  5, 16, ZSTD_btlazy2 },  /* level 15 */
+    { 22, 21, 22,  4,  5, 48, ZSTD_btopt   },  /* level 16 */
+    { 23, 22, 22,  4,  4, 48, ZSTD_btopt   },  /* level 17 */
+    { 23, 22, 22,  5,  3, 64, ZSTD_btopt   },  /* level 18 */
+    { 23, 23, 22,  7,  3,128, ZSTD_btopt   },  /* level 19 */
+    { 25, 25, 23,  7,  3,128, ZSTD_btultra },  /* level 20 */
     { 26, 26, 24,  7,  3,256, ZSTD_btultra },  /* level 21 */
     { 27, 27, 25,  9,  3,512, ZSTD_btultra },  /* level 22 */
 },

From 78de28239fa35a0b0ae7f1ab3b4b552d1c1c5d5c Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 15 Dec 2017 13:26:39 -0800
Subject: [PATCH 137/145] minor readme formatting update

---
 README.md                  |  47 +++++++++++++++++++------------------
 doc/images/zstd_logo86.png | Bin 0 -> 5963 bytes
 2 files changed, 24 insertions(+), 23 deletions(-)
 create mode 100644 doc/images/zstd_logo86.png

diff --git a/README.md b/README.md
index 99f320c45..50da24ba4 100644
--- a/README.md
+++ b/README.md
@@ -1,14 +1,15 @@
- __Zstandard__, or `zstd` as short version, is a fast lossless compression algorithm,
- targeting real-time compression scenarios at zlib-level and better compression ratios.
+<p align="center"><img src="https://raw.githubusercontent.com/facebook/zstd/readme/doc/images/zstd_logo86.png" alt="Zstandard"></p>
 
-It is provided as an open-source BSD-licensed **C** library,
-and a command line utility producing and decoding `.zst` and `.gz` files.
-For other programming languages,
-you can consult a list of known ports on [Zstandard homepage](http://www.zstd.net/#other-languages).
+__Zstandard__, or `zstd` as short version, is a fast lossless compression algorithm,
+targeting real-time compression scenarios at zlib-level and better compression ratios.
+It's backed by a very fast entropy stage, provided by [Huff0 and FSE library](https://github.com/Cyan4973/FiniteStateEntropy).
 
-| dev branch status |
-|-------------------|
-| [![Build Status][travisDevBadge]][travisLink]   [![Build status][AppveyorDevBadge]][AppveyorLink]   [![Build status][CircleDevBadge]][CircleLink]
+The project is provided as an open-source BSD-licensed **C** library,
+and a command line utility producing and decoding `.zst`, `.gz`, `.xz` and `.lz4` files.
+Should your project require another programming language,
+a list of known ports and bindings is provided on [Zstandard homepage](http://www.zstd.net/#other-languages).
+
+Development branch status : [![Build Status][travisDevBadge]][travisLink]   [![Build status][AppveyorDevBadge]][AppveyorLink]   [![Build status][CircleDevBadge]][CircleLink]
 
 [travisDevBadge]: https://travis-ci.org/facebook/zstd.svg?branch=dev "Continuous Integration test suite"
 [travisLink]: https://travis-ci.org/facebook/zstd
@@ -17,8 +18,9 @@ you can consult a list of known ports on [Zstandard homepage](http://www.zstd.ne
 [CircleDevBadge]: https://circleci.com/gh/facebook/zstd/tree/dev.svg?style=shield "Short test suite"
 [CircleLink]: https://circleci.com/gh/facebook/zstd
 
+### Benchmarks
 
-As a reference, several fast compression algorithms were tested and compared
+For reference, several fast compression algorithms were tested and compared
 on a server running Linux Debian (`Linux version 4.8.0-1-amd64`),
 with a Core i7-6700K CPU @ 4.0GHz,
 using [lzbench], an open-source in-memory benchmark by @inikep
@@ -43,7 +45,9 @@ on the [Silesia compression corpus].
 [LZ4]: http://www.lz4.org/
 
 Zstd can also offer stronger compression ratios at the cost of compression speed.
-Speed vs Compression trade-off is configurable by small increments. Decompression speed is preserved and remains roughly the same at all settings, a property shared by most LZ compression algorithms, such as [zlib] or lzma.
+Speed vs Compression trade-off is configurable by small increments.
+Decompression speed is preserved and remains roughly the same at all settings,
+a property shared by most LZ compression algorithms, such as [zlib] or lzma.
 
 The following tests were run
 on a server running Linux Debian (`Linux version 4.8.0-1-amd64`)
@@ -56,8 +60,8 @@ Compression Speed vs Ratio | Decompression Speed
 ---------------------------|--------------------
 ![Compression Speed vs Ratio](doc/images/Cspeed4.png "Compression Speed vs Ratio") | ![Decompression Speed](doc/images/Dspeed4.png "Decompression Speed")
 
-Several algorithms can produce higher compression ratios, but at slower speeds, falling outside of the graph.
-For a larger picture including very slow modes, [click on this link](doc/images/DCspeed5.png).
+A few other algorithms can produce higher compression ratios at slower speeds, falling outside of the graph.
+For a larger picture including slow modes, [click on this link](doc/images/DCspeed5.png).
 
 
 ### The case for Small Data compression
@@ -99,19 +103,16 @@ Dictionary gains are mostly effective in the first few KB. Then, the compression
 `zstd -D dictionaryName --decompress FILE.zst`
 
 
-### Build
-
-Once you have the repository cloned, there are multiple ways provided to build Zstandard.
+### Build instructions
 
 #### Makefile
 
-If your system is compatible with a standard `make` (or `gmake`) binary generator,
-you can simply run it at the root directory.
-It will generate `zstd` within root directory.
+If your system is compatible with standard `make` (or `gmake`),
+invoking `make` in root directory will generate `zstd` cli in root directory.
 
 Other available options include:
-- `make install` : create and install zstd binary, library and man page
-- `make test` : create and run `zstd` and test tools on local platform
+- `make install` : create and install zstd cli, library and man pages
+- `make check` : create and run `zstd`, tests its behavior on local platform
 
 #### cmake
 
@@ -143,8 +144,8 @@ Zstandard is dual-licensed under [BSD](LICENSE) and [GPLv2](COPYING).
 
 ### Contributing
 
-The "dev" branch is the one where all contributions will be merged before reaching "master".
-If you plan to propose a patch, please commit into the "dev" branch or its own feature branch.
+The "dev" branch is the one where all contributions are merged before reaching "master".
+If you plan to propose a patch, please commit into the "dev" branch, or its own feature branch.
 Direct commit to "master" are not permitted.
 For more information, please read [CONTRIBUTING](CONTRIBUTING.md).
 
diff --git a/doc/images/zstd_logo86.png b/doc/images/zstd_logo86.png
new file mode 100644
index 0000000000000000000000000000000000000000..216f228061c460c4e4725785486ebcff38804fbc
GIT binary patch
literal 5963
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
HN@xNAPrx2g

literal 0
HcmV?d00001


From 64d1701c6476f79961e8c20a96986688d7e0a6e7 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Fri, 15 Dec 2017 13:28:34 -0800
Subject: [PATCH 138/145] remove last paragraph

---
 README.md | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/README.md b/README.md
index 50da24ba4..3755315ad 100644
--- a/README.md
+++ b/README.md
@@ -148,7 +148,3 @@ The "dev" branch is the one where all contributions are merged before reaching "
 If you plan to propose a patch, please commit into the "dev" branch, or its own feature branch.
 Direct commit to "master" are not permitted.
 For more information, please read [CONTRIBUTING](CONTRIBUTING.md).
-
-### Miscellaneous
-
-Zstd entropy stage is provided by [Huff0 and FSE, from Finite State Entropy library](https://github.com/Cyan4973/FiniteStateEntropy).

From 5c2f2ebfdb8fc8e074269ad4f85ac79267cc36fe Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Sat, 16 Dec 2017 12:48:13 -0800
Subject: [PATCH 139/145] zstdmt via compress_generic: reduce opportunity to
 free/create mtctx

`zstreamtest --newapi` (and `--opaqueapi`) create and destroy way too many threads
resulting in failure of tsan tests,
and potentially connected to the qemu flaky tests.

This is because, at each test, the nb of threads can be changed (random).

The `--no-big-tests` directive reduce this choice to 1/2 threads,
in order to limit memory usage, especially for qemu and 32-bits builds.
Unfortunately, swapping between 1 and 2 threads is enough to constantly create/destroy new mtctx.

This patch takes advantage of the following property :
via compress_generic, no internal mtctx is needed for nbThreads < 2.
As a consequence, when nbThreads == 2, the currently active mtctx is necessarily good.

This dramatically reduces the nb of thread creations when invoking `zstreamtest --newapi --no-big-tests`
(only when parent cctx itself is created, which is randomized to 1/256 tests).

Expected outcome :
- at a minimum : tsan tests shall now work continuously without exploding the thread counter
- at best : flaky qemu tests on `zstreamtest --newapi --no-big-tests` may stop being flaky, due to less stress from constant thread creation/destruction

Real world impact :
minimal, I don't expect users to constantly change `nbThreads` between each invocation.
If `nbThreads` remains stable, existing implementation re-uses existing mtctx.

Also : `zstreamtest --newapi` but without `--no-big-tests` doesn't benefit as much,
since this test can select a random `nbThreads` value between 1 and 4.
The current patch only reduces opportunity to free/create mtctx (for example : 2->1->2 doesn't need a new mtctx)
but doesn't completely eliminate it, since `nbThreads` can still change between 2/3/4.
A more complete solution could be to only use 2 out of 4 allocated threads, thus keeping the pool at a constant size.
This would require a larger change to `POOL_*` api though.
---
 lib/compress/zstd_compress.c   | 4 +++-
 lib/compress/zstdmt_compress.c | 9 +++++++++
 lib/compress/zstdmt_compress.h | 7 ++++++-
 3 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index ebc9c1854..0a2d589d7 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -2851,7 +2851,9 @@ size_t ZSTD_compress_generic (ZSTD_CCtx* cctx,
         if ((cctx->pledgedSrcSizePlusOne-1) <= ZSTDMT_JOBSIZE_MIN)
             params.nbThreads = 1; /* do not invoke multi-threading when src size is too small */
         if (params.nbThreads > 1) {
-            if (cctx->mtctx == NULL || cctx->appliedParams.nbThreads != params.nbThreads) {
+            if (cctx->mtctx == NULL || (params.nbThreads != ZSTDMT_getNbThreads(cctx->mtctx))) {
+                DEBUGLOG(4, "ZSTD_compress_generic: creating new mtctx for nbThreads=%u (previous: %u)",
+                            params.nbThreads, ZSTDMT_getNbThreads(cctx->mtctx));
                 ZSTDMT_freeCCtx(cctx->mtctx);
                 cctx->mtctx = ZSTDMT_createCCtx_advanced(params.nbThreads, cctx->customMem);
                 if (cctx->mtctx == NULL) return ERROR(memory_allocation);
diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c
index a5e996d3e..659992f34 100644
--- a/lib/compress/zstdmt_compress.c
+++ b/lib/compress/zstdmt_compress.c
@@ -459,6 +459,15 @@ size_t ZSTDMT_CCtxParam_setNbThreads(ZSTD_CCtx_params* params, unsigned nbThread
     return nbThreads;
 }
 
+/* ZSTDMT_getNbThreads():
+ * @return nb threads currently active in mtctx.
+ * mtctx must be valid */
+size_t ZSTDMT_getNbThreads(const ZSTDMT_CCtx* mtctx)
+{
+    assert(mtctx != NULL);
+    return mtctx->params.nbThreads;
+}
+
 ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbThreads, ZSTD_customMem cMem)
 {
     ZSTDMT_CCtx* mtctx;
diff --git a/lib/compress/zstdmt_compress.h b/lib/compress/zstdmt_compress.h
index 4209cf3c5..d12f0adb8 100644
--- a/lib/compress/zstdmt_compress.h
+++ b/lib/compress/zstdmt_compress.h
@@ -114,9 +114,14 @@ size_t ZSTDMT_CCtxParam_setMTCtxParameter(ZSTD_CCtx_params* params, ZSTDMT_param
 
 /* ZSTDMT_CCtxParam_setNbThreads()
  * Set nbThreads, and clamp it correctly,
- * but also reset jobSize and overlapLog */
+ * also reset jobSize and overlapLog */
 size_t ZSTDMT_CCtxParam_setNbThreads(ZSTD_CCtx_params* params, unsigned nbThreads);
 
+/* ZSTDMT_getNbThreads():
+ * @return nb threads currently active in mtctx.
+ * mtctx must be valid */
+size_t ZSTDMT_getNbThreads(const ZSTDMT_CCtx* mtctx);
+
 /*! ZSTDMT_initCStream_internal() :
  *  Private use only. Init streaming operation.
  *  expects params to be valid.

From f299fa39ac07b9de897a5f0e930459528fec0bb5 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 19 Dec 2017 09:43:03 +0100
Subject: [PATCH 140/145] fix a subtle issue in continue mode

The deep fuzzer tests caught a subtle bug that was probably there for a long time.
The impact of the bug is not a crash, or any other clear error signal,
rather, it reduces performance, by cutting data into smaller blocks.
Eventually, the following test would fail because it produces too many 1-byte blocks,
requiring more space than buffer can provide :
`./zstreamtest_asan --mt -s3514 -t1678312 -i1678314`

The root scenario is as follows :
- Create context, initialize it using explicit parameters or a `cdict` to pin them down, set `pledgedSrcSize=1`
- The compression parameters will not be adapted, but `windowSize` and `blockSize` will be automatically set to `1`.
  `windowSize` and `blockSize` are dynamic values, set within `ZSTD_resetCCtx_internal()`.
  The automatic adaptation makes it possible to generate smaller contexts for smaller input sizes.
- Complete compression
- New compression with same context, using same parameters, but `pledgedSrcSize=ZSTD_CONTENTSIZE_UNKNOWN`
  trigger "continue mode"
- Continue mode doesn't modify blockSize, because it used to depend on `windowLog` only,
  but in fact, it also depends on `pledgedSrcSize`.
- The "old" blocksize (1) is still there,
  next compression will use this value to cut input into blocks,
  resulting in more blocks and worse performance than necessary performance.

Given the scenario, and its possible variants, I'm surprised it did not show up before.
But I suspect it did show up, it's just that it never triggered an error, because "worse performance" is not a trigger.
The above test is a special corner case, where performance is so impacted that it reaches an error case.

The fix works, but I'm not completely pleased.
I think the current code relies too much on implied relations between variables.
This will likely break again in the future when some related part of the code change.
Unfortunately, no time to make larger changes if we want to keep the release target for zstd v1.3.3.
So a longer term fix will have to be considered after the release.

To do : create a reliable test case which triggers this scenario for CI tests.
---
 lib/common/zstd_internal.h     | 19 +++++++-------
 lib/compress/zstd_compress.c   | 45 +++++++++++++++++++++-------------
 lib/compress/zstdmt_compress.c | 20 +++++++--------
 3 files changed, 47 insertions(+), 37 deletions(-)

diff --git a/lib/common/zstd_internal.h b/lib/common/zstd_internal.h
index 2f8124825..5d2900eb7 100644
--- a/lib/common/zstd_internal.h
+++ b/lib/common/zstd_internal.h
@@ -57,20 +57,19 @@ extern "C" {
 extern int g_debuglog_enable;
 /* recommended values for ZSTD_DEBUG display levels :
  * 1 : no display, enables assert() only
- * 2 : reserved for currently active debugging path
- * 3 : events once per object lifetime (CCtx, CDict)
+ * 2 : reserved for currently active debug path
+ * 3 : events once per object lifetime (CCtx, CDict, etc.)
  * 4 : events once per frame
  * 5 : events once per block
  * 6 : events once per sequence (*very* verbose) */
-#  define RAWLOG(l, ...) {                                 \
-                if ((g_debuglog_enable) & (l<=ZSTD_DEBUG)) { \
-                    fprintf(stderr, __VA_ARGS__);            \
+#  define RAWLOG(l, ...) {                                      \
+                if ((g_debuglog_enable) & (l<=ZSTD_DEBUG)) {    \
+                    fprintf(stderr, __VA_ARGS__);               \
             }   }
-#  define DEBUGLOG(l, ...) {                                 \
-                if ((g_debuglog_enable) & (l<=ZSTD_DEBUG)) { \
-                    fprintf(stderr, __FILE__ ": ");          \
-                    fprintf(stderr, __VA_ARGS__);            \
-                    fprintf(stderr, " \n");                  \
+#  define DEBUGLOG(l, ...) {                                    \
+                if ((g_debuglog_enable) & (l<=ZSTD_DEBUG)) {    \
+                    fprintf(stderr, __FILE__ ": " __VA_ARGS__); \
+                    fprintf(stderr, " \n");                     \
             }   }
 #else
 #  define RAWLOG(l, ...)      {}    /* disabled */
diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index ebc9c1854..5f952b8c0 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -728,10 +728,7 @@ size_t ZSTD_estimateCStreamSize(int compressionLevel) {
 static U32 ZSTD_equivalentCParams(ZSTD_compressionParameters cParams1,
                                   ZSTD_compressionParameters cParams2)
 {
-    U32 bslog1 = MIN(cParams1.windowLog, ZSTD_BLOCKSIZELOG_MAX);
-    U32 bslog2 = MIN(cParams2.windowLog, ZSTD_BLOCKSIZELOG_MAX);
-    return (bslog1 == bslog2)   /* same block size */
-         & (cParams1.hashLog  == cParams2.hashLog)
+    return (cParams1.hashLog  == cParams2.hashLog)
          & (cParams1.chainLog == cParams2.chainLog)
          & (cParams1.strategy == cParams2.strategy)   /* opt parser space */
          & ((cParams1.searchLength==3) == (cParams2.searchLength==3));  /* hashlog3 space */
@@ -755,24 +752,29 @@ typedef enum { ZSTDb_not_buffered, ZSTDb_buffered } ZSTD_buffered_policy_e;
 /* ZSTD_sufficientBuff() :
  * check internal buffers exist for streaming if buffPol == ZSTDb_buffered .
  * Note : they are assumed to be correctly sized if ZSTD_equivalentCParams()==1 */
-static U32 ZSTD_sufficientBuff(size_t bufferSize, ZSTD_buffered_policy_e buffPol, ZSTD_compressionParameters cParams2, U64 pledgedSrcSize)
+static U32 ZSTD_sufficientBuff(size_t bufferSize1, size_t blockSize1,
+                            ZSTD_buffered_policy_e buffPol2,
+                            ZSTD_compressionParameters cParams2,
+                            U64 pledgedSrcSize)
 {
     size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << cParams2.windowLog), pledgedSrcSize));
-    size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, windowSize);
-    size_t const neededBufferSize = (buffPol==ZSTDb_buffered) ? windowSize + blockSize : 0;
-    return (neededBufferSize <= bufferSize);
+    size_t const blockSize2 = MIN(ZSTD_BLOCKSIZE_MAX, windowSize);
+    size_t const neededBufferSize = (buffPol2==ZSTDb_buffered) ? windowSize + blockSize2 : 0;
+    return (blockSize2 <= blockSize1) /* seqStore space depends on blockSize */
+         & (neededBufferSize <= bufferSize1);
 }
 
 /** Equivalence for resetCCtx purposes */
 static U32 ZSTD_equivalentParams(ZSTD_CCtx_params params1,
                                  ZSTD_CCtx_params params2,
-                                 size_t buffSize1,
+                                 size_t buffSize1, size_t blockSize1,
                                  ZSTD_buffered_policy_e buffPol2,
                                  U64 pledgedSrcSize)
 {
+    DEBUGLOG(4, "ZSTD_equivalentParams: pledgedSrcSize=%u", (U32)pledgedSrcSize);
     return ZSTD_equivalentCParams(params1.cParams, params2.cParams) &&
            ZSTD_equivalentLdmParams(params1.ldmParams, params2.ldmParams) &&
-           ZSTD_sufficientBuff(buffSize1, buffPol2, params2.cParams, pledgedSrcSize);
+           ZSTD_sufficientBuff(buffSize1, blockSize1, buffPol2, params2.cParams, pledgedSrcSize);
 }
 
 /*! ZSTD_continueCCtx() :
@@ -780,7 +782,11 @@ static U32 ZSTD_equivalentParams(ZSTD_CCtx_params params1,
 static size_t ZSTD_continueCCtx(ZSTD_CCtx* cctx, ZSTD_CCtx_params params, U64 pledgedSrcSize)
 {
     U32 const end = (U32)(cctx->nextSrc - cctx->base);
-    DEBUGLOG(4, "continue mode");
+    size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << params.cParams.windowLog), pledgedSrcSize));
+    size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, windowSize);
+    DEBUGLOG(4, "ZSTD_continueCCtx");
+
+    cctx->blockSize = blockSize;   /* previous block size could be different even for same windowLog, due to pledgedSrcSize */
     cctx->appliedParams = params;
     cctx->pledgedSrcSizePlusOne = pledgedSrcSize+1;
     cctx->consumedSrcSize = 0;
@@ -813,8 +819,11 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
     assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
 
     if (crp == ZSTDcrp_continue) {
-        if (ZSTD_equivalentParams(params, zc->appliedParams, zc->inBuffSize, zbuff, pledgedSrcSize)) {
-            DEBUGLOG(4, "ZSTD_equivalentParams()==1 -> continue mode");
+        if (ZSTD_equivalentParams(params, zc->appliedParams,
+                                zc->inBuffSize, zc->blockSize,
+                                zbuff, pledgedSrcSize)) {
+            DEBUGLOG(4, "ZSTD_equivalentParams()==1 -> continue mode (wLog=%u, blockSize=%u)",
+                        zc->appliedParams.cParams.windowLog, (U32)zc->blockSize);
             assert(!(params.ldmParams.enableLdm &&
                      params.ldmParams.hashEveryLog == ZSTD_LDM_HASHEVERYLOG_NOTSET));
             zc->entropy->hufCTable_repeatMode = HUF_repeat_none;
@@ -865,8 +874,8 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
                                        tableSpace + tokenSpace + bufferSpace;
             DEBUGLOG(4, "Need %uKB workspace, including %uKB for tables, and %uKB for buffers",
                         (U32)(neededSpace>>10), (U32)(tableSpace>>10), (U32)(bufferSpace>>10));
-            DEBUGLOG(4, "chainSize: %u - hSize: %u - h3Size: %u - windowSize: %u",
-                        (U32)chainSize, (U32)hSize, (U32)h3Size, (U32)windowSize);
+            DEBUGLOG(4, "chainSize: %u - hSize: %u - h3Size: %u - windowSize: %u - blockSize: %u",
+                        (U32)chainSize, (U32)hSize, (U32)h3Size, (U32)windowSize, (U32)blockSize);
 
             if (zc->workSpaceSize < neededSpace) {  /* too small : resize */
                 DEBUGLOG(4, "Need to update workSpaceSize from %uK to %uK",
@@ -1666,6 +1675,7 @@ static size_t ZSTD_compress_frameChunk (ZSTD_CCtx* cctx,
     U32 const maxDist = (U32)1 << cctx->appliedParams.cParams.windowLog;
     assert(cctx->appliedParams.cParams.windowLog <= 31);
 
+    DEBUGLOG(5, "ZSTD_compress_frameChunk (blockSize=%u)", (U32)blockSize);
     if (cctx->appliedParams.fParams.checksumFlag && srcSize)
         XXH64_update(&cctx->xxhState, src, srcSize);
 
@@ -1838,6 +1848,7 @@ static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,
         cctx->lowLimit = lowLimitMax;
     }
 
+    DEBUGLOG(5, "ZSTD_compressContinue_internal (blockSize=%u)", (U32)cctx->blockSize);
     {   size_t const cSize = frame ?
                              ZSTD_compress_frameChunk (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) :
                              ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize);
@@ -2062,7 +2073,7 @@ size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
                              ZSTD_CCtx_params params, U64 pledgedSrcSize,
                              ZSTD_buffered_policy_e zbuff)
 {
-    DEBUGLOG(4, "ZSTD_compressBegin_internal");
+    DEBUGLOG(4, "ZSTD_compressBegin_internal: wlog=%u", params.cParams.windowLog);
     /* params are supposed to be fully validated at this point */
     assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
     assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
@@ -2086,7 +2097,7 @@ size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
                                     ZSTD_CCtx_params params,
                                     unsigned long long pledgedSrcSize)
 {
-    DEBUGLOG(4, "ZSTD_compressBegin_advanced_internal");
+    DEBUGLOG(4, "ZSTD_compressBegin_advanced_internal: wlog=%u", params.cParams.windowLog);
     /* compression parameters verification and optimization */
     CHECK_F( ZSTD_checkCParams(params.cParams) );
     return ZSTD_compressBegin_internal(cctx,
diff --git a/lib/compress/zstdmt_compress.c b/lib/compress/zstdmt_compress.c
index a5e996d3e..500806188 100644
--- a/lib/compress/zstdmt_compress.c
+++ b/lib/compress/zstdmt_compress.c
@@ -355,7 +355,7 @@ void ZSTDMT_compressChunk(void* jobDescription)
 
     if (job->cdict) {
         size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, NULL, 0, ZSTD_dm_auto, job->cdict, job->params, job->fullFrameSize);
-        DEBUGLOG(4, "ZSTDMT_compressChunk: init using CDict");
+        DEBUGLOG(4, "ZSTDMT_compressChunk: init using CDict (windowLog=%u)", job->params.cParams.windowLog);
         assert(job->firstChunk);  /* only allowed for first job */
         if (ZSTD_isError(initError)) { job->cSize = initError; goto _endJob; }
     } else {  /* srcStart points at reloaded section */
@@ -367,9 +367,11 @@ void ZSTDMT_compressChunk(void* jobDescription)
             job->cSize = forceWindowError;
             goto _endJob;
         }
-        /* load dictionary in "content-only" mode (no header analysis) */
-        {   size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, job->srcStart, job->prefixSize, ZSTD_dm_rawContent, NULL, jobParams, pledgedSrcSize);
-            DEBUGLOG(5, "ZSTD_compressBegin_advanced_internal called with windowLog = %u ", jobParams.cParams.windowLog);
+        DEBUGLOG(5, "ZSTDMT_compressChunk: invoking ZSTD_compressBegin_advanced_internal with windowLog = %u ", jobParams.cParams.windowLog);
+        {   size_t const initError = ZSTD_compressBegin_advanced_internal(cctx,
+                                        job->srcStart, job->prefixSize, ZSTD_dm_rawContent, /* load dictionary in "content-only" mode (no header analysis) */
+                                        NULL,
+                                        jobParams, pledgedSrcSize);
             if (ZSTD_isError(initError)) {
                 DEBUGLOG(5, "ZSTD_compressBegin_advanced_internal error : %s ", ZSTD_getErrorName(initError));
                 job->cSize = initError;
@@ -637,8 +639,7 @@ static size_t ZSTDMT_compress_advanced_internal(
     assert(jobParams.nbThreads == 0);
     assert(mtctx->cctxPool->totalCCtx == params.nbThreads);
 
-    DEBUGLOG(4, "ZSTDMT_compress_advanced_internal");
-    DEBUGLOG(4, "nbChunks  : %2u (raw chunkSize : %u bytes; fixed chunkSize: %u)   ",
+    DEBUGLOG(4, "ZSTDMT_compress_advanced_internal: nbChunks=%2u (rawSize=%u bytes; fixedSize=%u)  ",
                 nbChunks, (U32)proposedChunkSize, (U32)avgChunkSize);
     if (nbChunks==1) {   /* fallback to single-thread mode */
         ZSTD_CCtx* const cctx = mtctx->cctxPool->cctx[0];
@@ -688,7 +689,7 @@ static size_t ZSTDMT_compress_advanced_internal(
                 XXH64_update(&xxh64, srcStart + frameStartPos, chunkSize);
             }
 
-            DEBUGLOG(5, "posting job %u   (%u bytes)", u, (U32)chunkSize);
+            DEBUGLOG(5, "ZSTDMT_compress_advanced_internal: posting job %u  (%u bytes)", u, (U32)chunkSize);
             DEBUG_PRINTHEX(6, mtctx->jobs[u].srcStart, 12);
             POOL_add(mtctx->factory, ZSTDMT_compressChunk, &mtctx->jobs[u]);
 
@@ -893,8 +894,7 @@ static size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* zcs, size_t srcSize, unsi
 {
     unsigned const jobID = zcs->nextJobID & zcs->jobIDMask;
 
-    DEBUGLOG(5, "ZSTDMT_createCompressionJob");
-    DEBUGLOG(5, "preparing job %u to compress %u bytes with %u preload ",
+    DEBUGLOG(5, "ZSTDMT_createCompressionJob: preparing job %u to compress %u bytes with %u preload ",
                 zcs->nextJobID, (U32)srcSize, (U32)zcs->dictSize);
     zcs->jobs[jobID].src = zcs->inBuff.buffer;
     zcs->jobs[jobID].srcStart = zcs->inBuff.buffer.start;
@@ -945,7 +945,7 @@ static size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* zcs, size_t srcSize, unsi
             zcs->params.fParams.checksumFlag = 0;
     }   }
 
-    DEBUGLOG(4, "posting job %u : %u bytes  (end:%u) (note : doneJob = %u=>%u)",
+    DEBUGLOG(5, "ZSTDMT_createCompressionJob: posting job %u : %u bytes  (end:%u) (note : doneJob = %u=>%u)",
                 zcs->nextJobID,
                 (U32)zcs->jobs[jobID].srcSize,
                 zcs->jobs[jobID].lastChunk,

From d88c6716633619b629129f6e7d536c1b57746263 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 19 Dec 2017 10:16:09 +0100
Subject: [PATCH 141/145] added test case for "wrong blockSize in continue
 mode"

---
 tests/fuzzer.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/tests/fuzzer.c b/tests/fuzzer.c
index f799b5f9e..d64b46ba3 100644
--- a/tests/fuzzer.c
+++ b/tests/fuzzer.c
@@ -25,6 +25,7 @@
 #include <stdlib.h>       /* free */
 #include <stdio.h>        /* fgets, sscanf */
 #include <string.h>       /* strcmp */
+#include <assert.h>
 #define ZSTD_STATIC_LINKING_ONLY  /* ZSTD_compressContinue, ZSTD_compressBlock */
 #include "zstd.h"         /* ZSTD_VERSION_STRING */
 #include "zstd_errors.h"  /* ZSTD_getErrorCode */
@@ -365,6 +366,23 @@ static int basicUnitTests(U32 seed, double compressibility)
     }
     DISPLAYLEVEL(4, "OK \n");
 
+    DISPLAYLEVEL(4, "test%di : re-use CCtx with expanding block size : ", testNb++);
+    {   ZSTD_CCtx* const cctx = ZSTD_createCCtx();
+        ZSTD_parameters const params = ZSTD_getParams(1, ZSTD_CONTENTSIZE_UNKNOWN, 0);
+        assert(params.fParams.contentSizeFlag == 1);  /* block size will be adapted if pledgedSrcSize is enabled */
+        CHECK_Z( ZSTD_compressBegin_advanced(cctx, NULL, 0, params, 1 /*pledgedSrcSize*/) );
+        CHECK_Z( ZSTD_compressEnd(cctx, compressedBuffer, compressedBufferSize, CNBuffer, 1) ); /* creates a block size of 1 */
+
+        CHECK_Z( ZSTD_compressBegin_advanced(cctx, NULL, 0, params, ZSTD_CONTENTSIZE_UNKNOWN) );  /* re-use same parameters */
+        {   size_t const inSize = 2* 128 KB;
+            size_t const outSize = ZSTD_compressBound(inSize);
+            CHECK_Z( ZSTD_compressEnd(cctx, compressedBuffer, outSize, CNBuffer, inSize) );
+            /* will fail if blockSize is not resized */
+        }
+        ZSTD_freeCCtx(cctx);
+    }
+    DISPLAYLEVEL(4, "OK \n");
+
     /* Static CCtx tests */
 #define STATIC_CCTX_LEVEL 3
     DISPLAYLEVEL(4, "test%3i : create static CCtx for level %u :", testNb++, STATIC_CCTX_LEVEL);

From 574e75354bfa88084a3d162e49e7fdc9d9bc747d Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 19 Dec 2017 11:24:14 +0100
Subject: [PATCH 142/145] fuzzer: ensure existence of CHECK_Z macro beyond OS-X
 systems

---
 tests/fuzzer.c | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/tests/fuzzer.c b/tests/fuzzer.c
index d64b46ba3..141bf6548 100644
--- a/tests/fuzzer.c
+++ b/tests/fuzzer.c
@@ -95,6 +95,22 @@ static unsigned FUZ_highbit32(U32 v32)
 }
 
 
+/*=============================================
+*   Test macros
+=============================================*/
+#define CHECK_Z(f) {                               \
+    size_t const err = f;                          \
+    if (ZSTD_isError(err)) {                       \
+        DISPLAY("Error => %s : %s ",               \
+                #f, ZSTD_getErrorName(err));       \
+        exit(1);                                   \
+}   }
+
+#define CHECK_V(var, fn)  size_t const var = fn; if (ZSTD_isError(var)) goto _output_error
+#define CHECK(fn)  { CHECK_V(err, fn); }
+#define CHECKPLUS(var, fn, more)  { CHECK_V(var, fn); more; }
+
+
 /*=============================================
 *   Memory Tests
 =============================================*/
@@ -144,14 +160,6 @@ static void FUZ_displayMallocStats(mallocCounter_t count)
         (U32)(count.totalMalloc >> 10));
 }
 
-#define CHECK_Z(f) {                               \
-    size_t const err = f;                          \
-    if (ZSTD_isError(err)) {                       \
-        DISPLAY("Error => %s : %s ",               \
-                #f, ZSTD_getErrorName(err));       \
-        exit(1);                                   \
-}   }
-
 static int FUZ_mallocTests(unsigned seed, double compressibility, unsigned part)
 {
     size_t const inSize = 64 MB + 16 MB + 4 MB + 1 MB + 256 KB + 64 KB; /* 85.3 MB */
@@ -257,10 +265,6 @@ static int FUZ_mallocTests(unsigned seed, double compressibility, unsigned part)
 *   Unit tests
 =============================================*/
 
-#define CHECK_V(var, fn)  size_t const var = fn; if (ZSTD_isError(var)) goto _output_error
-#define CHECK(fn)  { CHECK_V(err, fn); }
-#define CHECKPLUS(var, fn, more)  { CHECK_V(var, fn); more; }
-
 static int basicUnitTests(U32 seed, double compressibility)
 {
     size_t const CNBuffSize = 5 MB;

From 9096088f4529a25763ce4080376919c9479f48cc Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 19 Dec 2017 21:20:46 +0100
Subject: [PATCH 143/145] changed variable name for clarity, suggested by
 @terrelln

---
 lib/compress/zstd_compress.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 5f952b8c0..04b03bfcf 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -757,11 +757,11 @@ static U32 ZSTD_sufficientBuff(size_t bufferSize1, size_t blockSize1,
                             ZSTD_compressionParameters cParams2,
                             U64 pledgedSrcSize)
 {
-    size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << cParams2.windowLog), pledgedSrcSize));
-    size_t const blockSize2 = MIN(ZSTD_BLOCKSIZE_MAX, windowSize);
-    size_t const neededBufferSize = (buffPol2==ZSTDb_buffered) ? windowSize + blockSize2 : 0;
+    size_t const windowSize2 = MAX(1, (size_t)MIN(((U64)1 << cParams2.windowLog), pledgedSrcSize));
+    size_t const blockSize2 = MIN(ZSTD_BLOCKSIZE_MAX, windowSize2);
+    size_t const neededBufferSize2 = (buffPol2==ZSTDb_buffered) ? windowSize2 + blockSize2 : 0;
     return (blockSize2 <= blockSize1) /* seqStore space depends on blockSize */
-         & (neededBufferSize <= bufferSize1);
+         & (neededBufferSize2 <= bufferSize1);
 }
 
 /** Equivalence for resetCCtx purposes */

From cafedcbbe4b36a6b7253ee3bcc4b28bbc972e433 Mon Sep 17 00:00:00 2001
From: Yann Collet <cyan@fb.com>
Date: Tue, 19 Dec 2017 21:49:04 +0100
Subject: [PATCH 144/145] ZSTD_resetCCtx_internal: fixed order of arguments

params1 was swapped with params2.
This used to be a non-issue when testing for strict equality,
but now that some tests look for "sufficient size" `<=`, order matters.
---
 lib/compress/zstd_compress.c | 20 +++++++++++++-------
 tests/zstreamtest.c          |  2 +-
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c
index 04b03bfcf..a9a8a265d 100644
--- a/lib/compress/zstd_compress.c
+++ b/lib/compress/zstd_compress.c
@@ -161,7 +161,7 @@ static void ZSTD_cLevelToCCtxParams_srcSize(ZSTD_CCtx_params* CCtxParams, U64 sr
 
 static void ZSTD_cLevelToCParams(ZSTD_CCtx* cctx)
 {
-    DEBUGLOG(4, "ZSTD_cLevelToCParams");
+    DEBUGLOG(4, "ZSTD_cLevelToCParams: level=%i", cctx->requestedParams.compressionLevel);
     ZSTD_cLevelToCCtxParams_srcSize(
             &cctx->requestedParams, cctx->pledgedSrcSizePlusOne-1);
 }
@@ -169,7 +169,7 @@ static void ZSTD_cLevelToCParams(ZSTD_CCtx* cctx)
 static void ZSTD_cLevelToCCtxParams(ZSTD_CCtx_params* CCtxParams)
 {
     DEBUGLOG(4, "ZSTD_cLevelToCCtxParams");
-    ZSTD_cLevelToCCtxParams_srcSize(CCtxParams, 0);
+    ZSTD_cLevelToCCtxParams_srcSize(CCtxParams, ZSTD_CONTENTSIZE_UNKNOWN);
 }
 
 static ZSTD_CCtx_params ZSTD_makeCCtxParamsFromCParams(
@@ -247,7 +247,7 @@ static ZSTD_CCtx_params ZSTD_assignParamsToCCtxParams(
 
 size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned value)
 {
-    DEBUGLOG(4, "ZSTD_CCtx_setParameter");
+    DEBUGLOG(4, "ZSTD_CCtx_setParameter (%u, %u)", (U32)param, value);
     if (cctx->streamStage != zcss_init) return ERROR(stage_wrong);
 
     switch(param)
@@ -311,6 +311,7 @@ size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned v
 size_t ZSTD_CCtxParam_setParameter(
         ZSTD_CCtx_params* CCtxParams, ZSTD_cParameter param, unsigned value)
 {
+    DEBUGLOG(4, "ZSTD_CCtxParam_setParameter (%u, %u)", (U32)param, value);
     switch(param)
     {
     case ZSTD_p_format :
@@ -326,7 +327,7 @@ size_t ZSTD_CCtxParam_setParameter(
         return CCtxParams->compressionLevel;
 
     case ZSTD_p_windowLog :
-        DEBUGLOG(4, "setting windowLog=%u", value);
+        DEBUGLOG(4, "ZSTD_CCtxParam_setParameter: set windowLog=%u", value);
         if (value) {  /* 0 : does not change current windowLog */
             CLAMPCHECK(value, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX);
             ZSTD_cLevelToCCtxParams(CCtxParams);
@@ -760,6 +761,10 @@ static U32 ZSTD_sufficientBuff(size_t bufferSize1, size_t blockSize1,
     size_t const windowSize2 = MAX(1, (size_t)MIN(((U64)1 << cParams2.windowLog), pledgedSrcSize));
     size_t const blockSize2 = MIN(ZSTD_BLOCKSIZE_MAX, windowSize2);
     size_t const neededBufferSize2 = (buffPol2==ZSTDb_buffered) ? windowSize2 + blockSize2 : 0;
+    DEBUGLOG(4, "ZSTD_sufficientBuff: windowSize2=%u from wlog=%u",
+                (U32)windowSize2, cParams2.windowLog);
+    DEBUGLOG(4, "ZSTD_sufficientBuff: blockSize2 %u <=? blockSize1 %u",
+                (U32)blockSize2, (U32)blockSize1);
     return (blockSize2 <= blockSize1) /* seqStore space depends on blockSize */
          & (neededBufferSize2 <= bufferSize1);
 }
@@ -815,14 +820,15 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
                                       ZSTD_compResetPolicy_e const crp,
                                       ZSTD_buffered_policy_e const zbuff)
 {
-    DEBUGLOG(4, "ZSTD_resetCCtx_internal: pledgedSrcSize=%u", (U32)pledgedSrcSize);
+    DEBUGLOG(4, "ZSTD_resetCCtx_internal: pledgedSrcSize=%u, wlog=%u",
+                (U32)pledgedSrcSize, params.cParams.windowLog);
     assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
 
     if (crp == ZSTDcrp_continue) {
-        if (ZSTD_equivalentParams(params, zc->appliedParams,
+        if (ZSTD_equivalentParams(zc->appliedParams, params,
                                 zc->inBuffSize, zc->blockSize,
                                 zbuff, pledgedSrcSize)) {
-            DEBUGLOG(4, "ZSTD_equivalentParams()==1 -> continue mode (wLog=%u, blockSize=%u)",
+            DEBUGLOG(4, "ZSTD_equivalentParams()==1 -> continue mode (wLog1=%u, blockSize1=%u)",
                         zc->appliedParams.cParams.windowLog, (U32)zc->blockSize);
             assert(!(params.ldmParams.enableLdm &&
                      params.ldmParams.hashEveryLog == ZSTD_LDM_HASHEVERYLOG_NOTSET));
diff --git a/tests/zstreamtest.c b/tests/zstreamtest.c
index 70922e2e0..5590c9af1 100644
--- a/tests/zstreamtest.c
+++ b/tests/zstreamtest.c
@@ -1527,7 +1527,7 @@ static int fuzzerTests_newAPI(U32 seed, U32 nbTests, unsigned startTest, double
                                (MAX(testLog, dictLog) / 2))) +
                                1;
             U32 const cLevel = MIN(cLevelCandidate, cLevelMax);
-            DISPLAYLEVEL(5, "t%u: cLevel : %u \n", testNb, cLevel);
+            DISPLAYLEVEL(5, "t%u: base cLevel : %u \n", testNb, cLevel);
             maxTestSize = FUZ_rLogLength(&lseed, testLog);
             DISPLAYLEVEL(5, "t%u: maxTestSize : %u \n", testNb, (U32)maxTestSize);
             oldTestLog = testLog;

From 3ddfa42fe867f18e999032ee9ace0f86a01ddb5c Mon Sep 17 00:00:00 2001
From: Shawn Landden <slandden@gmail.com>
Date: Tue, 19 Dec 2017 22:00:27 -0800
Subject: [PATCH 145/145] meson: fix build

used absolute paths which are deprecated in meson, also missing some sources
that got split

also move source files each to their own line so future diffs are clearer.
---
 contrib/meson/meson.build | 49 ++++++++++++++++++++++++++++++++++-----
 1 file changed, 43 insertions(+), 6 deletions(-)

diff --git a/contrib/meson/meson.build b/contrib/meson/meson.build
index 8cbdcabec..5ff370fa7 100644
--- a/contrib/meson/meson.build
+++ b/contrib/meson/meson.build
@@ -2,14 +2,39 @@ project('zstd', 'c', license: 'BSD')
 
 libm = meson.get_compiler('c').find_library('m', required: true)
 
-lib_dir = join_paths(meson.source_root(), '..', '..', 'lib')
+lib_dir = join_paths('..', '..', 'lib')
 common_dir = join_paths(lib_dir, 'common')
 compress_dir = join_paths(lib_dir, 'compress')
 decompress_dir = join_paths(lib_dir, 'decompress')
 dictbuilder_dir = join_paths(lib_dir, 'dictBuilder')
 deprecated_dir = join_paths(lib_dir, 'deprecated')
 
-libzstd_srcs = [join_paths(common_dir, 'entropy_common.c'), join_paths(common_dir, 'fse_decompress.c'), join_paths(common_dir, 'threading.c'), join_paths(common_dir, 'pool.c'), join_paths(common_dir, 'zstd_common.c'), join_paths(common_dir, 'error_private.c'), join_paths(common_dir, 'xxhash.c'), join_paths(compress_dir, 'fse_compress.c'), join_paths(compress_dir, 'huf_compress.c'), join_paths(compress_dir, 'zstd_compress.c'), join_paths(compress_dir, 'zstdmt_compress.c'), join_paths(decompress_dir, 'huf_decompress.c'), join_paths(decompress_dir, 'zstd_decompress.c'), join_paths(dictbuilder_dir, 'cover.c'), join_paths(dictbuilder_dir, 'divsufsort.c'), join_paths(dictbuilder_dir, 'zdict.c'), join_paths(deprecated_dir, 'zbuff_common.c'), join_paths(deprecated_dir, 'zbuff_compress.c'), join_paths(deprecated_dir, 'zbuff_decompress.c')]
+libzstd_srcs = [
+    join_paths(common_dir, 'entropy_common.c'),
+    join_paths(common_dir, 'fse_decompress.c'),
+    join_paths(common_dir, 'threading.c'),
+    join_paths(common_dir, 'pool.c'),
+    join_paths(common_dir, 'zstd_common.c'),
+    join_paths(common_dir, 'error_private.c'),
+    join_paths(common_dir, 'xxhash.c'),
+    join_paths(compress_dir, 'fse_compress.c'),
+    join_paths(compress_dir, 'huf_compress.c'),
+    join_paths(compress_dir, 'zstd_compress.c'),
+    join_paths(compress_dir, 'zstd_fast.c'),
+    join_paths(compress_dir, 'zstd_double_fast.c'),
+    join_paths(compress_dir, 'zstd_lazy.c'),
+    join_paths(compress_dir, 'zstd_opt.c'),
+    join_paths(compress_dir, 'zstd_ldm.c'),
+    join_paths(compress_dir, 'zstdmt_compress.c'),
+    join_paths(decompress_dir, 'huf_decompress.c'),
+    join_paths(decompress_dir, 'zstd_decompress.c'),
+    join_paths(dictbuilder_dir, 'cover.c'),
+    join_paths(dictbuilder_dir, 'divsufsort.c'),
+    join_paths(dictbuilder_dir, 'zdict.c'),
+    join_paths(deprecated_dir, 'zbuff_common.c'),
+    join_paths(deprecated_dir, 'zbuff_compress.c'),
+    join_paths(deprecated_dir, 'zbuff_decompress.c')
+]
 
 libzstd_includes = [include_directories(common_dir, dictbuilder_dir, compress_dir, lib_dir)]
 
@@ -19,7 +44,15 @@ if get_option('legacy_support')
 
     legacy_dir = join_paths(lib_dir, 'legacy')
     libzstd_includes += [include_directories(legacy_dir)]
-    libzstd_srcs += [join_paths(legacy_dir, 'zstd_v01.c'), join_paths(legacy_dir, 'zstd_v02.c'), join_paths(legacy_dir, 'zstd_v03.c'), join_paths(legacy_dir, 'zstd_v04.c'), join_paths(legacy_dir, 'zstd_v05.c'), join_paths(legacy_dir, 'zstd_v06.c'), join_paths(legacy_dir, 'zstd_v07.c')]
+    libzstd_srcs += [
+        join_paths(legacy_dir, 'zstd_v01.c'),
+        join_paths(legacy_dir, 'zstd_v02.c'),
+        join_paths(legacy_dir, 'zstd_v03.c'),
+        join_paths(legacy_dir, 'zstd_v04.c'),
+        join_paths(legacy_dir, 'zstd_v05.c'),
+        join_paths(legacy_dir, 'zstd_v06.c'),
+        join_paths(legacy_dir, 'zstd_v07.c')
+    ]
 else
     libzstd_cflags = []
 endif
@@ -39,16 +72,20 @@ libzstd = library('zstd',
                   dependencies: libzstd_deps,
                   install: true)
 
-programs_dir = join_paths(meson.source_root(), '..', '..', 'programs')
+programs_dir = join_paths('..', '..', 'programs')
 
 zstd = executable('zstd',
-                  join_paths(programs_dir, 'bench.c'), join_paths(programs_dir, 'datagen.c'), join_paths(programs_dir, 'dibio.c'), join_paths(programs_dir, 'fileio.c'), join_paths(programs_dir, 'zstdcli.c'),
+                  join_paths(programs_dir, 'bench.c'),
+                  join_paths(programs_dir, 'datagen.c'),
+                  join_paths(programs_dir, 'dibio.c'),
+                  join_paths(programs_dir, 'fileio.c'),
+                  join_paths(programs_dir, 'zstdcli.c'),
                   include_directories: libzstd_includes,
                   c_args: ['-DZSTD_NODICT', '-DZSTD_NOBENCH'],
                   link_with: libzstd,
                   install: true)
 
-tests_dir = join_paths(meson.source_root(), '..', '..', 'tests')
+tests_dir = join_paths('..', '..', 'tests')
 datagen_c = join_paths(programs_dir, 'datagen.c')
 test_includes = libzstd_includes + [include_directories(programs_dir)]