From 9439cc238e2f68c50d00cb7cd57c05c45e32604f Mon Sep 17 00:00:00 2001
From: Vivek Teega <vivek.teega@gmail.com>
Date: Sun, 17 Jul 2022 18:24:31 +0530
Subject: [PATCH] Added files required to create mongoose binary

---
 example                                       |  Bin 133936 -> 0 bytes
 mongoose-server/Makefile                      |  163 +
 mongoose-server/examples/.DS_Store            |  Bin 0 -> 6148 bytes
 .../examples/http-server/.DS_Store            |  Bin 0 -> 6148 bytes
 mongoose-server/examples/http-server/Makefile |   26 +
 .../examples/http-server/README.md            |    1 +
 mongoose-server/examples/http-server/example  |  Bin 0 -> 162096 bytes
 mongoose-server/examples/http-server/main.c   |  103 +
 mongoose-server/mongoose.c                    | 6776 +++++++++++++++++
 mongoose-server/mongoose.h                    | 1383 ++++
 10 files changed, 8452 insertions(+)
 delete mode 100644 example
 create mode 100644 mongoose-server/Makefile
 create mode 100644 mongoose-server/examples/.DS_Store
 create mode 100644 mongoose-server/examples/http-server/.DS_Store
 create mode 100644 mongoose-server/examples/http-server/Makefile
 create mode 100644 mongoose-server/examples/http-server/README.md
 create mode 100755 mongoose-server/examples/http-server/example
 create mode 100644 mongoose-server/examples/http-server/main.c
 create mode 100644 mongoose-server/mongoose.c
 create mode 100644 mongoose-server/mongoose.h

diff --git a/example b/example
deleted file mode 100644
index 281d2a71e9fcb66d994961e2947d2973eea1106f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 133936
zcmcG%4V>Inb^m|AGn)sJKpr9Cac2`M7#<P{lB|H4-Jn6C1vj+V;?K+`ga-*E8=`=r
zG9gybRLKAptF~^yw(M#pty<WsWs~>-#)lB<L#w|!vq>QSKn2mtR?_{yKj(Yz%$?a?
z2>xSuE#L1w_ug~PJ?GqW&wcpbx$R9Czd4g6F8s^7hn-T}PD&wppE18F<KLXiyG8B@
z{(piy-i-y?#9!X$Ha=hUsKax-FPG)1dW$^T#^>?ATzCc!^&I2#MtbBPN=t^Pv(}{l
z7q8pCl;&^yQc5^HX^{OJ@1LQbN~vDIuh;MEg{SlUhi7P?+NQtDe17Be0`l}PJXKcz
zF5SQWO1=N^gDIbl&rgoCVlF&Gy|+<Md>-n*DZXHbr#G5hF7*V$Gv&&;d8@BoF>m#i
zXRN;VhIik5MrY@`mDike_L(=XIrDXCyJvu3I$rumf9#&W>hd%HW96-HdExZlU%k6^
z%=f?l)d_i_6%WFvGWw_TzIg^$UZAJ^L;aU^6J7st!%Jt~F(@)9EX{wB$F$)^-2)IF
z30@op{>UhJjvWQQX%zSj*vpaE_^){sx<97iNPPaEQQ#i|&+JCzq+c@%{*F=L3xQ7^
z0nf@&=njnnFN}i!HKUZDI7<1`M=5{iDCO0iN0QrTM#1ydQQ&usg6E$`DKED=65X+*
z;JIv+^8Y+a`FD*{UL9#9x@V74{)JKC^GC7I-++H4d$?~DJe5)4pBaVEPmfam+oP0!
z(<tzN9|ivCDEKcP1-@z&JQs}uf8!|dzZnHSaTL1J;YfNsFbe!{MuC556!<Zt@N?cM
z<rj})54%PwzhM;ke~dzR{V4F#D0o(nQr<CMt<?B*j=OQq%Ij9GcQ>wIw{q<*Zq?1#
zu6OHJbzXVpwd>qfYu2v1K{+?9ynd~o3~TG$^5xf3r?qwYjW@3Byx}Uha?K4ltXjF=
ztz5n4##L5r{i@Zg-Hq2?eM9GJO5eD?bLDl*S6*}7@~b+pUG3Jsd;Q95I@iI$jq8Pd
z)oN9~{yNp{T(M>y@2jpC9q6rJv)WyC^{VwN-OA3@tJka)Y_(Oo;Yt;|5yqD<U$t)C
z4QrN@-MRkSH8;2w*QS}`nYwD<nzd@w%J&#*T6vZ6>eh8q5*)Q6ovYV&uD^z|*ROfc
zDyQa)Emgg0-J0tme<j4+RX44>cKs@MmE=U`4V~AoQtN3Y^wwWXs&oCCYsIYEan;&&
z*WR%Hs=$ktz7fRh*SOA=D_6nV^5rXU?p%J=waDw*_kwrj4eM8nRbxU}Qt3l_jl?hA
zNviACFTcL?+8f+eH?CTB-5Rm8irkyYS?@-UMPg-K{qD|nSGuJazomW2^0Ur--9oqg
zEtmb_a@x1*YH4QOWq-J2^_m-2UDml`wa{LD{hAv*(dB8;5es66`j?6Rt53x_FaNFx
z=;ce)a_ea*PD)$_+gD7L<L|!GM+pbB?g;v){wbeq%U3$h&s6h69Gvy>-XqN_<=i7a
z-VN}z0sd%;IKanWFYL}8Xn^0T4#~gg8sMM2I)#t-@mLj)PfuxpFY@?v4e-2&&u@Si
zJUrh359KdyfM4Uw7aHJeJ$!8g{7w%qHo&)d_?8CvHV^M^fIs5l+Zy1Hd3b*Ve7A@1
zZh)6Pyxagk;Nj0Tz+d!mx4mAEq5PBvxVs_MSFQm*-oxiNz-M`Qz5$-|@Jk!u^F6%K
z0AJ+cYa8GfdU&w`eyN9VX@IZw@a_iq%^tq30e+{4_cy?|c=+xHc(;d_8{iLm_;U^L
zeh+s$>gE5KhfisMAMo&81N=D;pWgr<zb4gJz5zbP!!K=s=RCa706*2k*EYcO9$svK
zU+Cdm8sKmD@a_h9!Na#Tz}I?se*^qx58vGYzth9Z4e%`<{#*mR+r!<?dig)-;Zqvm
zk9c^l0UrFx{04ZxFQ0FKKjz_=Ho(gsUTA<H@bI+_@E1M2*Z_BHQ@w9#fKT!8?gscQ
z58u`RKh?wg8{qRjyxagku-M$ZJJ0|x=2Q4{4e$ePDg4C-_!rt!xch3oUdkRmz5#yg
zlC=Dk2KdK3d{zVeIS<b@z{g*Z;yJYeeu9V3Z-CGD@I?*q7d<@R0N?he6#s<{@E1M&
z(gygfH>c&_-T=SQ!wU`Yn?3xR2KZ+^d~E~##~yxj1H5TzO1IbmU-ajxUESFLzeW>a
z{%vW1ul4YcHNbE7@a_iq77u^00sb)$@AvUT(&WNYozZ<Pf*)y+^nbe}cv$OF&JQE_
zA4KKL5&Sg~{KW`<ZUq0~S5o`Tz)v=Umm@e?)qe*fc)Wi3Tm&CmE$!Tk5j?DkS@yrx
z=!UgM!N*7N2@#$t5nOZ1@NZTGpA>*Ra}hk2=cy6=sHpt>2tGN2FN)ytx<EdH$Me_=
zBlz?P&!rJuYl`9D+avhV0m!ou!CCFA{<|iE&#Xe7TN}Y=Mev&=xYqE(zhVTBml*Gi
z;9<>Lb+$zC69N*RAB*58M)2+k?w8;#_rVD6LvVv{i{QBk&m$4MC4%=y@Yxaku?RjV
zg71#tCr9ufM)10R6v0o4${&c}r$+GSBKT_~_=^#IZUlF}KdRrI7Qx3yaIFP~e^Vm(
z83D+1Rs=sYg6AUmya;}31fL(l=ST3@Mes!t{HzF`kKhX;_=OQ%YjWY=r4jt~0m$?1
z5&WD8UWnieBltBDd{G2n8^K#6_{|ag4H3K;!L=q7{@oeD&ksPJTO#-yBlyQ6xDOpH
zw>yI8qw)_%a34BY?!gU@_8iQ*()h&PdvL?{2m7<jzaLd|&yjy=;&xB{e{UX~(!Q{i
z%QSz#IhXxj__Ms9leZ$xv-B@X-yWs^oAmur`hQ68h|>Q{dLT+?mJUwIEHYY#Z!GEA
zQF;RD_9%T6=@n6W8tL1k^f9FGkJ87H-VvowB0UhLXOqsf*66>6^z0}-mvnoSK9lr{
zD18>`+oSY3r0<W?Zy>!RO23ixK$LDLoq0oz{+mh9j?!->-5#a?i1dmm-9h^HDE%j-
z?~l@dMtVn-ekbXHD7}Jo=G+?nt4Pm|((fYO9;I&}y&_7lBYk_6eh=yUqx5@8?}*ax
zBRvqMZzr8OuSWj^q-RIz50P$<(jOtcB1+#)`t~UOQPTHE>5r4%5vBi@^gxuppLFK@
z8vVZ~Jv&PGl5UUEpCi2@O8+zI+oSZqkiI`k|10SoQTpFV4@Bu5q%&`<(f>N>*-`qN
zq}!wPcSx^@(tAkX9;Lre`u;S1qATt>iNF0>*IUWv2M6Z3(o^*RJbm1~xO8v{&y~Mg
zI(Pxk_y2h5;AKNY_ig6S@}FHgh)?;#rlFyk@)Pm_z@Kyd(@JeTTX^D&p6O@Xmh|qH
z^3uUh%0HJ)dL4d4bsEbvw(gq!(rr(+P1?A5XxzqUT3%|qNA=sO-~Q6l!4+0NQ>}k+
z!@rrodSRj)Tn5d;j*eDvzTWuTw{);bd85&kA3XTKL-+j<-gB<lQP?r9^@WMRHtaAT
z_g}POXo-8GJlXY?C+GW`uXJ6130=LrrerEH)C_}vD}tYpOeLmE;lGODQ{3B#F;n=9
zu8THbRv1(4Akv&s<_VpW+FnP`C0#%B^qQ|pV%l#ben@c@qcR7gGAAT&BX&y5eA(6T
z?5pExDsf|4=CdhJ{o{%q#H!VL;<F5_$~$cm%#BZZcdj@s@P2T^S4{5Z+gxh}*$*6#
z+>X!pF`t;$-}|AC?%v*Yxm$Ce$h=f|GIwk9^mgYiDrYlu-ObI*SZke_Q+ghC<{@k6
zx{@rkZ_Bs3TQkcz2r=z%(9=NH%`G2a?5m(B%5QE1o;cTP<tCl5EFmqL91NIRHu}ZB
z0m|kn+tPHxv=(2U^bDiZ<hr(tPJ}aY`4r!+O-2_wb4CBpUy1&VlU|<wq?4-j!8v1O
znq%u|7G9C2n|67%OntkD$*4{)`M!f2cAA}6^)}fJR%RmqnR#@OK9S=z>7pN<4*;)B
z&JUvVj=z9rS!L0cl^O54wkF7tGNj+8JdSzHP#XPD6<&91{vOq*?VGn^Q>M4HywTYD
zzeChVx4sN?TUEct=a*CanhBq$xV{1S9a`-AhR$_;X0zu~cV>#;p~Hd2DZhUvUMW{T
z*UN|U72eCI<oobN*IfkN3T5fbgI@_{Ngv$sRWF|}4WnB=rADiK3VbYdeOIRKMLzk~
zql5=K@IQz=*h<T{9uaU0Ha>+l3AV(So0P(a@JZ#Rz~HeNAK)^`)!tnfd$*UB;Z1OS
zn16R&&#0d+N&C%ay)RAQ-=)5azLttNwST?Y=yc(5w>C}3uBXesGd#-+y{>3WtgC7t
zi}-HF4|F%B^xbOfchg0mzWVBM`gRMawN-eoJWhRSy4vxod7R=(*x#VZ9^92v@`LF4
znNwfDz80dl*uH4<!3|#<-Vg9!vIoZ);c|)LV>%>zmVUwQ@$;^JCj2c!;O8CxVYIRD
zL8X6uaOggbgEc$$eiHkw(m0tq)7>ER{u$-z5e>b=gLoE=jp(xiO!fX<wgW$^r#j8f
zJ>P;Yhq${&uP?P<?6fimzufEw_a5&C_tA#^)P1U%J~R&;;1Uk?^>TA+Kb?9%-r%hU
zo55Hz*=%ahhvBu-4E=d&pOc)`w`J?@g#6v*1>jte;@m1clv7{8w+y~p?Ih1Nz4va>
zERG>x=^x+xWHRICy9Yepyzo(H0NnQOaYLuKyb$~gQ=FAKseB%%uZR!9tGqNFXa1$4
z{zALJH<fs1?tWypk2de6eFKyi4t&Dk7m%xXQrjJI5QCG(3hT4ton^ghyIbH-d>bwJ
z418SU>t3L`&=J0F=vR1`oEM|Z9h9j+TluQLoj4$o&m(PeLN``^L7Fe$rh1PHkFQ4@
zusPO&>IFRvP_IG^SI%a8KlRekeK9WCOojZQJEKS2V*c)L;Ey)64x{De{@5?%yCeJI
z9h^^yPqj^TMeE>(Z}`6EeL1#R!4?Ow#l7&fZ?YR4i@zF!-1kjJH^_o<hcfVrP5dFc
z8RnN`9G`Nn!eM+;PqfR}yrn%a^4FQ9xF>;*`q5{RjoJ9=?)jiMvro!5yYbIo>vg$S
zdiORWJ*@O_eC&)S_|5Vc^ZE^VP0n-EL<7CvVtw7^Z$TDa!M3iDeUML|xy7BAznjft
zv!N>A5xv02AE^#-%06Lz?H#k0L1((bCV3cXaLjc)t2{KpgX)bRp&q(2TqD&RPrXm&
zTg7)jZLab=#ZA>X!P-&E&n)`3WIY1U^pmvAtED~3%WYCBAK{j4WaHAo3a<l;HM|_L
z`MJg;btpU0otpAl^Yi~&8_%&h#S!_$ZFA2pHQ!yKA7C4MWY4mdBDSJ-WlpZyOtWkT
z+ib4cOb3o{hWv*cpTFhf7r1+o{j_G{ORu+%O(7q??hg5<*77%md~D%E<X82E?F?b#
zM=O7)EA69C&%t&FkVWXP=W8rD%?*}MOZ%X=ua2vzWBLFtxv3rMN7moL8Th@y^CKHn
zUy*DdcxmV|(Y-jLi;dUOZ61a0g{mWc6kVw)SKPA~o@0I;^@j1ahQ2X{I8yP>)x0CS
zHoae$zE|YG!P&ePUn1POw6C<#57h74T(Y^v5yLoQC-Ph1H5u<(PZlr2ohQ~0xYyDL
zBixDJLmiJlGhg-$ojiWb`x3_Do_v$*sg?!5#h#5aMaRdEAk&?{9=a?CU$W6)a|848
zgIQvRc9(rdJ|vG#Kk!@hnN8*%-0*etmqXd{PaNFf%x*QWEz9Q-rv<+ma3zXIhP?d}
z+cYaK*Zc<l>EHPKpnuYeIk0b=1IlidFB?j2c(4LrvV)(h&jZU4hjeqin^P_&=54)y
zopJZd-h@N>_=o4W9~`>uH<Gt#&qBt>yUT_Y%Oaob>6De6&W6XGNojyNKXS0~>3HnH
zF~@Swb?6DMu6}d^z1^HCE@h?{JB)TdDM@}Gm`VTg<%;m9JXcIgzXC2AnV6Q*$n?Hx
zmb>@U@D^~ch;SCc*%jeLo|lz(wY5r5Wq6ex!|z=2YqVUZ^dFv<#fV;(A5_~TSyuMu
zZ?W|J{4L1xy6wbHmPVGYdr7NvCr%6PaFbG+YP%a7m3uolp1}_auj*~X?$xFzlTv0<
zzGwC%*OM8aADlhj4Z2zRzT7O=CmtoY9WzXBTN30}ppA>7HWp;_9_RE^rN;>WlCh=R
zCl&X6{zP}L(eg6bi_VyXqqpgj!xopzl<t!peBEWQbNA9tV!L+QR?}r!Hn^nS#*m`k
zt-q)(`MPr5;>pwc@<Q;A8`~q?V`z7%lbo72dy*_N1^Vcwq;xWE+lx&G9hI|VdjHG0
zd)W^%ePmU?sz=k|mZXruj<dZ_v#yQd$u3N0D~_qjOt$vSF*RFrvWp-mWajN*i|fyn
z{unt}>`B{x#`vJRn#X0pt(bgRU->yPlb@$;2XCN1duBcTT@n3aYU{{7TWXcuq1Al0
z8??0^^|_qusz`=Gz9&nsZjgOLlSACceSby{S?kY#ha3X`U(xv1(6<vmx1euq(O6j-
zLjL%S7MFP@<NemV|7YmFbPX-vgU_-xt%DnS>&M&0?v}kbIjzYV9`jibd7m{WDc#<Z
zj<atDS9x*%mT$DDV`=#wcZ<svJ9dWjeU9<H*zssce}ZvR<D23S{NwA?X2xjYmppQe
zf3&}~`4Jz-kS80ej(6TJnRiYzzt5987cn=sbY)pmnte@fk>y#eFJI&~XEja)I?!gk
zNn>)}$={XsmnQRbUm2uLrkgZYQoWdmjO;7q(+0gaAILuc_~4K}Z!tTnAS3Y*Xy1?Q
zyXlKbxAd6p{j_M1?`C)!H$}0V;KYb(%k9}>M`%xCV_oEv883cvMr!xixW+2e)xbl;
z$Ep`a&&I0n``G^T={U74>G?JBmF&;vovgvwyz>_gy1zQr{gB2UVs6<eKJfYN-qw?T
z+C`r`NPjjvR~htXWxNk-QvddKHHOL_&2MF!dY3hOA4Y!C<Z1Z&{TkamzRJ+hb1hR^
zOUcFcWvYA>n~aYi!3Xn%8A(%d5B9gm<Q>Ic)$;vm`R`Kx9ijh0*T!9q!;G(LgYm$-
zV~lXjO%*pv*Rt)3;<ouU-=CaJJAoxyTkw8JWs;NK;1NrFI~N!GTChPY$C#j}`n9!P
zPsW`Vcj8&tODlG>Et@;0)ZSe4IYsDx?&zA&%c);b&&CMZ4{i9h#zo#|sBd}s*|>x+
z*0}KpCwN|<t#+}OFn1qg$KLD=eDu+bqkjBwV@l)jZ^B_Z^yT;dg7rJ<RG?8threJ=
ztT8?)d)-z2Soaw7V>cpi`P*Q#m8*yQsf)1L7nZeQpPG|?yM9hO8G9wh3iZuD(H9eR
zt@WHY<l*;@Opo6Gl6UFrZ`-1H{q5*$GVNxZR^Kn*(cW{)Ni}&E#W(qP&U5!3FS}4#
z*#%=E_Rxh+EZ<;^Z%uI-V&1a)l&@oBp?}X%zx;sa2bsAxZ}#zu$|}C9lL>yM(RYtU
zCbhY>U!!7P9@bhdhP)uPS!81|WfN(GU&vgYwhllGTk8|7=oWw9@-A+uL)ze%j$B84
zhPA7qO|`h!VqUEk{Fb!>VqENLaR0bu@TrN(;M0?n!SeFr`IVK$^9Qajp1=3H;`#g5
z6wlv(WAXf_ZYrMt^oHX3b^3hR>+=EmQslX5Jbl|g)t7gUvvsQSnBuhZO3f#DUQN8s
zKFwbIZ^6$43QcXy2a=u&aC~6N;v@N)TyalltGn0wSK*k_{TbiC%3~~k{r-%aJrump
zN0;XB<sURxO5>R{R&lwprSs{N8V{0B`~LgsY^(a9Yz*7%P~P2PUPZeW6T25=OO*N2
ziw*jJc)0#QK$(LZ7`Ksy_M#4Mh}PRRPiCDk$)rB-YRXC<Ha_9Q3i89~TyZGlX`jZm
zJo+~uES}}BcxoPHeu($r=QoN+@eWSSH}zh#!*nl?Jvg&@`OBQ-73_afKJ5$mp`7du
zc+s~t?BgBW5Ut<W=KHnS1HG$ni}n!qrFLjOrnz=?9HBi0@XwY{=3QkTLDptF$k+V1
z*2B#grtvxcd(VlDa*{6<{wd&~o@Ai4Et?C`ZqYEA0h9jB7XZJ=%Vwf{0eOm9a`<@Y
zwyMpdUqp_!PDa|~4gPK7k+Q-W>|blCjq}ZM;uHTI)<`BzxP8yi%F}m+Ij7dUD_(Yc
z8-3#`<5T$!xz?ZlX6U~C^bgi3%m=~$mP}!6DRH;&QB3~tis{L3mmK9Ak;PRFa&(fT
zWHh5DBkkc;XjfG}q}c;`rabdg$CaTgS-x9%hEgADeF_{&4jkyqY=d;>1mR3d(qSH1
zb53xEXjwVnRt_BSR*QK~xp0`gzC=6Im?z)kWwp6K%l>Wli0VAO8uwsVd+|^ErsJ<>
z;;)X!Up3>e@KY81)Bt{JFMetteri8{>Z#j`=a-3{$GHZd^^Md{%X65wD1OKuQL;5~
zJ<lb*1Ru7TXH#)nd6V~9cX*%mz$iXzrT1Cbh<w)Bi_p&kaLmL1EJ%Gz1=(u+-yr!e
zPg*PFi3izdL4B9>1Cqz`biQ1*vu_Nyv+E<dA**!Hdz0<4+n75r&e136i<_eT@BqWd
zO2*aw%E%_w2Y&hAtSQN+(5-A^Hhpb?ciD|}JR92dlXTt3$`E_uODvysj{Zb{Y;9)0
z+{woP!xo=Vew^1yn{(K&Vl;T|2xHYqenxb^1z%;x7#kbGDcDYAsXi<D3D?o!lK;_K
zlKQ8~oN`}F%XO(-k#g4m(UoKV5&ZAN(hELJIucIJ(^9_DeXXHQkxfQ2%jsN3b<H!e
zJ}ln4J-<UM$Fz#4MGZW4d!CBgvyl&r_8hc+RAC=OG3Q+ATK*J&CB7=M72tOUJ@L+0
zQ=3)B{1$2CylX!;xsP|^iMd5SYswVyAK0e+$5+pB_YN%|(^^?ctVg+DgG)LsNMEFb
zzSXxYq|1~$0X`H%DXs`}DEY)#hUSAJ8E$+r-A4;Ds?2K}7BBrPwA1l2wd3k|srZro
z?oc<5ABXUv^v&A1f^FrcKlBpD9?42Jh7R{=T>_o-IoE7!VzL9lWhY5C9gE)&A0|WD
z7P7YSRbvFYv~fW1^ozic_SPEx{~f|%{y*$_4<C0$Tm9@o%1V~C@wFjN&{z%aV4n#w
zf$FtrPGWM8))h%7#J&cnob+#Fz2F*yRX&Apw*KS$_cOnSUzKUV&3doV3h@JeMCW%#
z_ASc8w;-Fr@;GRTZ}_Zag*SZ<_!WyU#^3dL85qx$4dujRqt6mvbX9-0C-r473p=>s
z3-#+I@D+4twzS-(eRZ#22SnDVy_GqS`ax<R=1)>T$iAa^UYOc|U}h8WE;}odSGh=S
z_wb9bwMjFkHBZUg9#t9s)n^JkY0uoi$H4O8HuT@piLC>CtA0Ke`5f8Br&TWU3pvL7
znX+^AnYq}N;OV)fd#ugn4pLU_Dyx6T`Tc4BuYG<S?ci*`;c(!H{eb$!qoRo~6Ara|
zD|;J)ZwDTHLa>?Y_#(TZAFKaqFJdD!#G5OREoGr)?~Zwb+9!KQh8w|G8xQLH&^qy2
z*KeXZR*0>@BRg-Qk4smN*Wr8R^53f~U!$-2tmdo4vuWG~jn7e5JTJ03>6y21b}sap
z3UyTGOO!D^5N~N7UhDfc8Y*|<A(Y#?nDK$K|21maf2r+rjLY^6AYbhbcQW@dndiop
z-gFjm%DC}8(xJsblE3^n`n6aH*-6iN<|Qwf%@_C37xyfrUSVveNA{79@9j2!tEDxc
zb3HcaW;}HoXZ^UKGdq=YQ$JvP@C!vViVe>8af7c{AwL&l3ikOnvNxi281;e0_>#xf
zFI6_e%es>J_lIQ5KF?ykdDLTUHNJQ^zUDcL)8hJ7z9>_r9r*I~M&!%zr+gKUfG?FD
zfiK(N@UktA!*?tdU!IoAQ%`N{VgDk|tD|{<Jt<-b!9v~266_va|Bw9x+1XZnLR{Z?
zq5N#*8N)@7cJ3no35{{um-;twl*b*>vk`rpy%fil`hdv}G*{Lfy*%zMJ!2-x7F<ul
z{;rkl9#?v3gmS-~sB%e9kV&kMZqA6RPgnC4J1?MJi@mORH(db_x@R2Rr81_UDK(qA
zmUz`<67m#_qPq%qqw>O2Cr4~533-w|@|h#~U^iuKOmb0s4JYfufB&nr4|o37;~PQ0
zQ)PG4{n((`SUOtl<qi*e7hcIS$a@7cQ=c*(!I`fAf76cv{_Iga22l4+rlT>okJ@hU
z?DN2Ll1E3fMd;?$cV4{hNt4qS`k~foDC5q9HgTufnfj1m{mkiroi!QVH<Y<%0(+1;
z{|7u-1a9R+hn~iKkC?>w@9bsn3D#-M7Lqc49hp7x0&5cfd|?GUFP~fNGk(yGoi9Yz
z?f5bD-B;H6I-NV!xj)*V@lr76BG;WpOs+Oz+s`}AOE`ZgJ>@wEd6utVr6W0yK<Ctv
z=zz14P6gcZ9Ulti)o$8bW?fjkC+|R(26HBhI+@UqWJAo)Q#s_BQzD1Ekb}nPZszmZ
zZuS)?6g!F<rwikeA^QkZYU^3u8moo>RA}<dbZ3m7^ro0za|W#ssJ`nSU%G?3>9`oq
z1`R)-p*07M8Im9M?3|t6H6}xUn&iJqwhKMxaH*Wd2ezhi@SWNTah%fINjqQ9<8A$8
zZ~Fz>Dqm}D0GHvUUQV`x&n-063p8b)=S4gO8|@cu+U)!po92(vr{({E1^;LB&R@B%
z7T^QendQOz-_K9|VW-wafP=&A+<1YW{GV`>w!Xf-iLsUR(`tjaYqhsiJg6)%^AEm`
z?VC<aV-D=7S9M><`nlONc0}E-Zz9LMZ?nxmDI-4A-nb3oWih^gJaeZIQ{gZAs%IFM
zxY}8I=GdGc)O@0^d7tb0N9juM#iR!RSai1CC0*YR<!2>bt9j4)*wpcKy0VA3q;?kF
zulW)4Rfsi146(17vyNUa;{RgwrL{CK!*u?CZ>k5uY}_HnP`lnD9r(7Zj&vZseUtfH
z*u%HIl29)yvpp)~v{oA7F`tdys?Q3ie0H1SKl<H2FF+R_pZGlverfNtH^|PKQ~h)!
zyJ2nMJbwilSzPMzCfG*8df^dKn_EQB)6VnWLVHvu@F$w$%k(YVffvPGlE)6|!{=47
zRly$Qe2dwaPv76bLo>Kz9D9`y4)s&jU*U1ee$>ve9%<i2EQYVejERhUWtG!A<6|+r
z-<qDK%Dt>z)Xv^2CLUs3k}NCu7WHGvUpn3A_2r^73<c<jrv;KdWob)o{V1v{{u0?U
zFyvOheng)9ztx}Qo<BlkegkdQZ}aQv!|K!C&VXAn4|N02s<%<HNa;?Mp8Y%i7u^BZ
z96)m3L?5Ls(c0Ara|`)g%BvnWk;a}W?ixO?x7!0x$WDB?C|!}yhtI$NrNtl5mld;s
z7dabl_}@jDUcnOfXD!AZg^ulyD-SvW?-q}@Q)4W7wfUF#0h-78w*2&Y{38CqjiG<x
z8>D}}0Z!#a?BWh=crwV;Y+tm1InK{i;qo8Wf8pQvg*LTUFxoT#tU_BBvcHFor1NNO
z++wT7cHtwWkJ;20e$$ud!}RLMtAv;heeDVT;oycxhOH6oP1l@uSJ(82K@;jI_Gwca
zAJAH_>n(DoDw99L*1$z?qt>6)&*wz>1@hI`$-hPU$VuyKwff_$`CUH0avJ5&P1}>h
zSDGFdAQSpPd=^}`p|Qfpv`<v+w@6=>4#A_o)rl=P6I&l6-icj;Zf4U*%XeImp2Hgk
zf0NDU<UdpwAJGT>sT$8LE@Cc^ys!JrZ>sBiCNJ`at?%u?Rt|1>%*V0A_mJfCB%f#W
zy~YA!z6H@YA=p-CTkX8)J+iw6slV3PrT5RPUFh8U*Mk|0Z;}Vw)8`{;T7Et0&J0$-
zt+L5yBlx!T9Ub4DeA>T%x;?G`<uqN@R}p=JOZ<)r`UIcLv!5AkA}aHe+9aK;On+2{
zcrf63Aui+Xv|DXc9ropd4zb&5H~Y3`{d%49ZEiyRt8wm2l8@P7TCeQKNc=&`+C3%Z
zrMezR{TA7Q^+Su}Qy(H3&G39fOE!#s)$%6!JeQQRtWz5gUM{C07xj&#oBb5<Jg4^g
zSV3*+Rv)+VF5mMd))DYOy~Z1|5BhP)-}n+AUI$uhy+4hocPC|V)86@KroKV@SBf22
z!!Z4-K5I??R8jkNo(uo6k$0^L8E<X^^)tQee0}j$&C8{E*ZI7DuZ!l0zra(V(-P6?
zSNouo!6uAWKE-#r$G3eneAsf$FZI;cZY*AKgD=2uj&C)qe(7Oneo6jF@$>-e;d?m`
zGHg#Bc<OUFbBG?3Tyf7|YOcs!dH}y-JQm;)ot!Wo_&jV1xakGhLnpg?{XAxOqInFk
zUSJi<i8g+qx_|Y;bLrY#;Is1ZaDVV`lu75dKkz=`bEyvwG3Ex=scz$3!Y00}xr6U&
zHoL*6@50`i+2@<XKHn+q^PR>%-#qsD7O>B^kaG#=7S9hf6OD%py=*q=>=1SJJdNj0
z&Ojln@*$o_C@)FRo@jg`P8|F=wk>}cXjK*tZ{G)K-@y%geA|Y{164bd%<&_SPILDP
z7X09{MtM`_kAR787?bP1Z~gaiUEMkltGJ){&xZHi<GPARc{uOShW9(ib`_5FaNbW3
z@Jq*b<#l#ecz9nO%3M6QD>u=@dH-xEbHUgy$C`kZ=l$7GCO@{TJl?~3KRv+vo4Wd0
z>$38^uMTw|Y3l0MIbG4^{j*v()B6{ix{BHx^Y70FoQtwu1<fG@=l%2mpP%i@D<%}2
z_tk;csoAca`lsN$e>TwCl5};aeX+0k<gC4)iGNjpaK#CwGs1iSgp$6^FnD=FiMvA5
z_uRzN$>F^)v4p=$;oTEUiiNDan^e--Bzw<ID$NS-g-NBO!+ZCn(zNhio>bBq)3p4N
zCGAhyd*R5E;!u0<KC+}WdV6<Ag*EiuE`L-h%-e=`M(2IxKR7>I{a%f8KKt26e~Nwd
zr`bm@AHx25uy^ZQ-|&5F4(k!>OFQui^f!B+%QNhsXN#|X|D1j%|8ynub&GX4*ZU^=
zocSX9pT>`ZbjEu&$e?gkX+QpowGdmA9H5S5lN66KU-k6V;XduXbG-ke4YB{)`HP1B
z{f*)M`y-UG{Yu)M?xWYQ-8;@>ovb}u`gHT9$b)CX8cj?06gv}{_T#WmFx)?cH5zLV
z@vqvF$xp7vnSV??EWZ(a!NCpDI?pNSc{2V}aXRP6noscaI=zqQyAAafa4JS{ZsQ*F
zjo@-xTatg&yVeEq@sdlAWGz@faXYZnC#1A(9n6<ixgF|Lq!a2|`Ft8L*j^EFsN#9W
zJ1YA@;q)-ex7Y)H`m;Pulr>z@8e@(aMf<I02id0H0{hZtd!h*~jae2iSekZ#U$*Mu
zyV5jp$~9v{8#P8#wuEh|Uzx0O>0DoM-NT@`Te=D{aCQA9JGFK;WgL4T$eaGLtvW6@
zXVP&Qz5n0Skk=h!dbB64K9mp>r1OWQH+e7Lxv_>`A&&Xr&r^C@6L5;vC@((3yr><1
zH9puH17-5WVw8JAazVCs7F*w}HkMI-nLQud-yseiPn!nrTGCS<*WPo>>CwE3dBAIw
z$K0jDeyHMwcM`9J^%%_w)rJ|8m3Vyi)+Z~B{lc$rCxma6$CpU9z8!Hn_I`Vg4E33t
zSsP<q*A!lqZnPF()Hf0N*3yTOpJL0s$SKIU(%jD6R{CywM&AqOv8Nv7r+7}Xw7!|0
z>ig#K`9?UOwo<&vUSucmF^9J7NaM?GNpZ5pm!APIJaui=SQV9Ze4}UcC&7r>RUcXG
z0$$xexk0)g*JR&as9i<LMYb+|v2J%noM!FrPVd)D|HMM&aToNwKwmeTNB8)ULAyV~
z`U~<?oKK&W9mMf9a;l?aeK^pC&Jmg$QcpY;;<8`x_CFea`1x+&C-rGYUwFzIUjq%=
zc5R%7<^j>6|Aw|r40aG~9r-2t?h$!nC*~*S@SS<+d#W2^<Dn&E=zmGiL1Huck9b`&
z*oci&|KQSoi0mA`#dIJU`?SUn%I|jlQ|#Q=Y}RpXZRgzl;63S@|De`5b)KGa)%I+v
zGNX*<Bb6n@-t?KYA2W}EfB7cLb!{XT!H#!l%g2-k7TP-hHm&m)pmQpIH1w^0cw!&J
z=C73B=DH`B?j>LEP36g&Lu||Drr0yXShw*k=6c9uoaR;3`yjl2k+#S`Yt6g7DZ@O#
zzTxRj#uxWoO*!%1k4}Uu$<tos{ULoDr*<t#Wz#PmQP=DZ*lF0W+F|_}I%}X~^^4Sp
z{#5oG?t`v77Jj&UVd%D_dWLSB%-<CLrt&w9zv(?gOA`Aoen@+I@EG=)KRTDbjV{`m
zgMLPBVXx8f7p5A2E5zSY>MTw9Q%qUeq_aqoyvZAfuclmI_y*`7758~Rf05o7r1hWC
z7)5Ll&LA)^O#6=Z6e+KAiy5CjD;wdxLcXPui#yx5QE?7!*taQ*jBO2QTc$X*w2`y=
zI$wVS-+G*gO!~b{D&P?>xzt}<oTPm@qX&NAo7I1%yQjdpA3vAIF&V8dZOgc69{1SZ
z%fYR6q0B6Bq7VFt;n5i_blCS>zBLk0<xA3iAv=#UopQ|IrGN0Hwoh8NFZ>RB8bIed
zzf*>OIm=uNzMjH<#LED9RW9kCW;(xjGCIR{3|5|QbLg$;v1%vSMS8CKq_Yy8tA@`C
z`=#dh$+K@m3g@NYhA2&bq8N#H#UPTo{2YHa_J;mk`G?_g*y%r09M*<?jWJ(8>4b3B
zHq&#EIqwS^L+QU2{A9pmeql{|&Q|`ad@f~>sbmy<M7QJ=!Rq|PVtfJi!aXH}LswvP
zDu?|(wG!RQE?5hx+J&3p&+CruJ)p6%DgQiooTok^KeMzWU-Jn$e8QX~YCa*)oJ=-h
zI?Bx`Z6WV^WFmRW?+iS^IBk6)i$6jC%i(1?wypje{0=lSZS^!JL^NzpC;q{wZ&J=f
zp2(-KOj{Ul=W5*5_a(+dVMb{Ub+ykUI?kPB=jg~YpW^ywgn5YBl=+pYT%JC(k62r{
zvgH}6FT<xLT0f@WbR!>&!{{$6SCiq<)iU={MtyeQ&L}@u%fCzc$gKTYKVP67S<XwV
z9fI%DceY+<<7u;SS$~Q6?DTzK<BnrJZ~z<?__1|w^$}=WA0f_o3Lj}Y=V|`-3g1`q
zM^k2e@8d_I^K`AiV#CUs3x}<ZZh+Spj@Q`M-sA1p&Oc8&CfIWNt+Lh-E5vajwy(42
z%Ts$cJ+Y@Oo45D=6VsS}a?Q4-FU?0}>veXmdE887f_-azH2qP|{O?4b7p3qq^b;FD
zvH8ja8NR70cBC>6-yo0aeL-j7StrI;%^trE%?j(wWy-(ywdmlEvFW)W`6j;mP}+C`
zchygcN78kE%KO`-e6qy}UC38F>kNX;6|rS>Jy&|I@GcvcKY1EI_Ea`IcRyp}KI|aa
zR+4{>;aLtI$tzPh-Rv^KE`|3`g?}DAD8AdPF~{{feIHoNl{AM^zq5MXXQcJ|&#-zI
zdA@93f<5Q({rgr%HrqXqJKR#cA5e^lf08d^zvub4AS?U!68d(Yfcoy#G|sPpL+f|%
zd!{-^P3`LP;dZs3GKzz}9i?aLHxVbwhR4w!<}9{f$9qmOnBd4f!@F#(g%}kd+^VvU
z@d+PcF>6liF)?gy(v<+4BflWHFV`(Q3u(%14QWry&MAg`z9X$DUQF?p3<t2b0MkB>
z$J-z91eoY6Zc$y$DSZ2^JigG*=ma{7$=I(`JF&A?_04eBv^s~T?`XWRwUT=>J^MeA
z^gOM(G`31yWczP^onfx&zBsmIV?6e-M!KXQRj`>5OI#~{(V@*%rAv+Vl*J~hce&W!
zIC+aTH&$Dyul4$haQU(of2WPo%CFYP9&9ZiAHv<XwvM0BHx=J8pW7A6Yp!B^rge9z
z->M%}vST^xHKup0`s_&jL2sSnE1u8(Kc4VJyLV@cGfM-P)W((~_--6m8^5}xyHnte
zaYeT6_bKMuJN<ee_(DH){qsscq^{<sYMW$aa%^lXdGZg=%P5v*un(uX4fHbU+WVG-
zaY^&S%TG;X6st?Dp)oYWTu=LYp)bqls~zQK_^xHC?`nY-?cI`1<8Z#g@$olpJB9f4
zPsB52!+2QG`lD~Jcr8l~K}Q}gzNNpwbHCc-^UTKdj*KK9<`uHDEs2|NYguO>$+>;_
zThu_eNNgK)O<%0)x&<3h{fv7Za>(|6J&o1UdEY2<C|^$dFHhUAe)+O^^C{kK9<R0K
z5b(m&Wuj50E&6sS(2!izHzm{RddtpCZN3-xPvX0MjElMW`}fOTI_HCj5YHJcpY~(k
zHk<Qly-RRx;l@+wyLXK1;f{^LA;!9)OZZ#nWN$MR<4Knl@qEXdY`l_874xjJdSiM_
z$Le>!AGcF>it2h@s_(svvKm7em-v?TO+CkYo6J+zzMnGOoW;H4&HNqFV=*3c9gRJ|
zW!wz&#f>_5$oOD!2>pEjC*IPt_nr%Ts^^`s&2KTEk}U<<3|yYte0(>`JJg@CFN>jf
zX3`jXQhnS}y(0x#>+Da!mmsssyzspm?SCLCCI7q8*0bnS9j_H`c+_0p))i?-6S0`t
zH1G<1OZFd>Z@C0}yCk)@ZjCRzhyLW$H>lfK?-A~TvoYs1?-SJTc;ER`;wfaTI{myO
z1ACXuC40rQDtCG$PugVilpW|>m+D*|{=WShAD4;;_%<A#_y3~*%V+o)Z;RIdD)WYq
z#TjG~?sAxv$~PU4m*D5Zov5std|39SJqp%K&QN>w9-rglUefF3PXy;2SG7EMnpV$!
zF>dD79+kN@NzeD_owXh72YP=ov9lC8^d$ZrPdD1RuZFnO)<YN{&!%1ldC0zV-j`X-
zhwV9?#l?3oW<0xwHi3W78R`qfgZf@8*l`g)0}lKY=SO|~K_AzC82zGpj_PRDC*Q_J
z`2g}ocdI{(74VqvBTr?OFMYMh$K(5UDE1V8iW9(LeN*uW?WxcXjq&1n33o)OTv%^9
zxFOw(ZCq>8{b<;Z>D~In!>R8n%3l}pi`dWWv=1O!;Kqlv>PgvFjn9eF(2;NH*1EiS
zqrY(9&-1VKX^m5UO_H%J^|c?suBp?NXl+AvD3jINnXk_p<lD41>+N{1+TKDus5KJK
zeA_w+V_yet?Q-3>AD3|VnEJ2Ew{ec37yQ;|ec$TVejoW2(#TY20Ol$k#X(#2ZJFtS
zcAX(PH<pJk->6-L{@$kk#~3)gzVwECPNe>YUf+^UQGFrE=7jXDm(n&5Mz<#Kaw?m}
zUN#l=0bhrENZw}e$O+pUmF^J!_%!GmK6jSsZ@a$dlK#LYUUKlVF+JzL#pTW_{rV3g
zpPtg|Y16q+*8DXVs7}B7Ebk__dBi^0B>u?8b(5QK_fMd2>!R3AQ<1%V;94IuexRj!
z@<i6)g3qb*I}a<K(VBSe4w-!iGzSQK?0%1G9Ov)B%Np489~58oQ|za;`A+O9jP>NB
zpIVGUUW?>OS<MerpFZ>i?ICu|^nL*uh^O+nww~JeEPhYQ_D7N)&1rP5xI%l>x7GLZ
z^v@iBM*mmD`|J}dUwMMdhp6l~X$NxbYGVz)vA*m`WrL1nw}u1XWN^jM=tXhmV*2)g
ze5~~3+uTVy7x_W?FgtH$x=j5<U4894`+03n@)B<BS-86!a2FbIJMUxF7VUB1cxP03
zdDee>8F(xDvzZ~iE&V1f<~7E*@qhezQFv*gkLsLPPBN5^fL(-+Zo~K5**WAZxs}n0
z*#b7|<cqytRFCiRY%Z&It^DQCWsK>29Dl9g32|BDH%_vTmbgEFPx~{P<8NdfmEW(~
z$MA0*wZCMt$A=hyq%BUsCd7yBfoaSkUp$%)ImcO)+<|HSY<pn5EB5#({YgIicfzT8
zgvXiFJ8eO4&v$!T8ixeKhu86VzvL+T^kL%>Im#Zz|KrrH%i~U6KmKwaF?=r?eX|wq
zZPbl3#HP}R_9e9bE?UXyX`4mU)<S^kemJeQR~GQZ25f9xn3gje0Y>><l{wY1g8rQC
z{cFW!=eoi2xoMmGr_}6R_=Rt_=*TwJKFX<mJ0%-nN(--iL};Jdy}->%_ZILO|G;^c
z!q{_qw3ghKFz15bFKQ3Z^Id^Y;oK^j!KZk!wkc-ky?KUvemwrd?%SP5K5(sP43mY{
zvw|#^AdAH+>t(TockJZlWbr4G#ZqvDwk~aGE9u6zYOT!Zz?aFKx}s^agT9^v7a=F}
zpV{7{o+eIJ8-Q6G<+CWSeGf~k&AhA4ua$i%FXcP^4j4U4R&(O-1!!{u+`a*#d>(z!
zPAi{q&zaE+IM9KeXX7cj&OlC(uO5ZYre|yWa&=?SCBw&{CA6*nJEq#X@uKEX1;#bj
zHT9kpd7sSq$bNyHnS{UQ;G5_}YV!wl4hsL-iCv833u|X0hM!sHmvl<5={@XKvnLB3
z>oYvnPfX7EoASi`;18tpM~TfIWn6?-S>q%+R9tK0jQl6IE&mzq$6DIT$u|%)SWF2%
z*WGUV=~4esU5!1Q?QX-bSQ&5|ef4+rCch(n&PLaJDX+dG8>US99h%C}Pm52%r`n-@
z4i2+pOFQ%HI)@VEXXQw%9P`H17F3qK7wIs>x^?$%G{pXl5zp1mIHdO+3=K8)3=MI<
z0Y5Wz8}sMe#`AXse-rqd$loOXj^uBIy}?gVN9Q%sZ4>d1_E9-YYU}j{eG^qqW1jDD
zF1=c2CuNR}$`ti|SyS)VRAy(J>1!);Q~f5lfV~m-oc2!j)Y?s=y;JPy5#l<=GdnN(
zPWcUZu(O=lTVChY;6*XA{OmtV&ge$>9zM0Vi9I^kYx_Lt*6=#^d2*U#jP1RFajs06
zzvIrmA~v1vpIMsyu40GEg}vV%_94O?C=aiJHvV9)>e^fv9jlJZFDOmTY8*>-xm7kK
zz2(p&Wpmp5;n@za=1<7m$3Bj1Q?@4kE3W$*ZD8Kfr?UHrJr#orf3`c7Q7oG-WJBLF
z+1NTQII}aL2R=KSgRBy4I`FMImULkIP|_#m#KS($-5QN@L__<c$p7t%tI1cJgIx_Y
zw^>XduTd<J>}`!g_aKJ*AsWtGu~zo{e#N@!nW~}e%-Z=J*>H3wD$qg}gO#87b2>U3
zHH*2>3}mbK9P81%e^Pb<uUS8~%1`KQOm%&LK6tTwmD)^O<SUMpJ}L8c)?b2-kwKlW
zDt{N>^4)x^BObJOPqR~Xp=aavk1~VhAGHq-JlZ~3`9Ztx<lV*mX&3uXgGY)l>WiM)
zkEi`J=u{RK(Q(8h_?}^{B=9#O^<~!Htr0!5J<+DEVck)>OWfHO2R_F>)e6z|wEj?d
zC~v+8J{RM!9`J3qIk(1i^82Z0Z7MK-RC}0Xs!y%pj?4>Ud^+=)%A|U4ZMWvYq9OUy
zE{iz=P0~5VE@pd~-g{<i9yY6#e}Aie{~CN>MKXb|>Q~DPhxVLJPJAQgdHt)vtM{8*
ziS>t`L=O$+Hv4kHE&_iiYkY0s&(@3R8}ipPu+cc*{I!*LHr|??Xsh~cS^b<m*@DvB
zpQ#^ngB@3X(mrh7ca`-8^_Q9c4Ak&gTjvA!;=eS%3iG8OO-SSA;A^_Y1AZsLkA<^~
zO4nl5L&H0N;;X}JXPd{-Z?ouVT-yEuwq<Liq!Y&13i-&TwVbu|6Dlh?CH!`T#<Oq^
zw(c$&+N_v?y@fuF^D4hlc8m-(ch*zuFTtkx-69)b8LtP=m+r`?j+JBnY|r@qlDzCW
z-~j((`b2>>nhNjG-Sg}|a45!LJQwYJdWM-;0zFVh<(5+?x25=T8*jYNH(L;1_^6(N
z1V>T$fRDucLlN&sdEOOApiARhw2<TAba*C)?kj4nB0gHddRoE8s<RneiXH#UT1N0=
z*qq5qGBSSs7~;CmE?q-^W{%C8eVE78d~^l5*U7HoP8jhaepKdO_zr&jV7PBCng{9r
z3az`z4kb6)ZqDW+9wz+}<4E>DMYlFT2XD0ud79^D#&7?)o^7`#pO9ZwIm+y^xQ%z=
zx9_n;C&HPhPuSf<fj%-7trfB(U>a96r_tC*+0Bao16+DHAE9#auC!>zK4PMDO23zV
zn7lnsUv{(BgDUbFD%Zfn2Yr7vJxj)c4t4M~DIbE94)I>~j+Q9aGr!|ytF{?l`6BU*
z{LNn=JHzSWD)+eeS=Kgam^`H`l|e3QQ+F6QNQ)1XkJ=--k(LceZdG4uG;6VKqr4v7
zo60NT&-*b=_(WItD0-Z`sJmG@KcKT_qUrN!$F4N(tZZ!#QM2KM{wqAsQa6p4!})Dr
z<~DrMZTZ$U=%qftHs4V{(07tY(C5U5Xo@FzZ~eLYD`}^>gLJ{We3az+0P_UlO!0=_
znyT?uRNu|dD$V9@%z};CuP5FucJLiRweNPL8_`t0%fG&KD|tDsU30!naQTILzQ34$
zlY?)lpmWYC^zB8L*ko-EaJi#iaZg@8l^7`ClP*4$!yj<2qoO;^(Cg#UlVWIWQg*Nv
zel|`_^L8}k(H`qdl7-d}R9|(E*876A{zjFdpWdjtioZO(DE+ICpN2gVYnU&G=DR5e
z-SoTOdHKOrzTUt};u2zgtyj<Hn}Fc!wsWsh1%IY^2OV6u8eg5|{M~`QN$F|i_0(zk
zzWw0cM;XOSl53{>^`#a&&osVwHMq(l2LB}II>Z<E919lajQBlhqib+x@Vm49o!HIY
zta0l%kcgux^Mv;QZoocr$XW7mJZV=gZoWKS3y<SwYoEo<yX-rpx_O=aDfhh&@EypA
z_bGDsYlUw@2DnpkFLx^L<4(o>+^P5!cPc*3or-lf@MvlS;?d^Dx<irm3%gTsfu8=`
zkg>&S<r~qH?ti_BZxoiWzP)mkyA<bWzmNSo`L7)JPfM1kfy?Vv-xubI*;;s-e}}gE
z2|6&{cSzUt7x>(5dvcGaV`RKGej;VkbK?H)#CR|6WY_hWaIse=d*Hjxsd`%c5n%5~
z3|5OX>em|rZTTVQAJ$LgKQ#Uieaf}U54>IWtUf;}f4BO?cEtmv^<KbU+UQ%fX}5Fd
zlzuLsMI4%NuZq5tRr@PEh0Acfbn%niM?UR4$V9yUr^*ZWOBWjaF%SRuD*OV2@9^;N
z0C!`H9ojeU40Lnnly;N0^#^d}yszT-&X$SB=Y8ErM=Ap^pYiz*3pe)t#SzLi-|D(_
z=B1H__9&%;M!4+1AD>eBRK9gK-y;vu{ucJH29QnunwCY@<`I18&R-2(rf;d@w*58y
z==XRM@KnI#z@zzHwJ(y_d>&`n@xQSyHmjc3#htuM7w_X)XLHzU<9<wWKsNU^|6QPu
zo$;xa<*s$$3fD?((^qFV^wR`gly`Fe$+wBKm#x*`iMyh|6`kle74=(j(<s-9uS{)r
z7Qg2x7<$9Er|?_HEh|GqWw5cXvTR&7!uaC~$DUPJUhqKEm+x13@xp!h8lTkXHtGI1
zU`oSFIv*ol^}X19Gxw6$$%cO2D4SN3%?PpMJnjI$!fAbDkNI-&P4xI`aiZUAk}Mfx
z>tu*8G8r<Kx~6u{Rb+aKn(whDpz+n^+gja}6V0AoQ~Dbs<-3p<v6=dz&5`%IQVV;2
zb2#H-V+Coo4_L=P;zx$K%hkRC;BNA8pSfa2)i28L8*TgmJ{up_hnyy|emK>5xGR;t
z=}&Z3c2YxK(xcXO$DLJI_k^@=L2;IFot&o2fe-Qxm(Oc~mnu*E4po&WcTzpx3)8hV
z8+U_jWDnxsHP@HDAT8Tn%|E`DPu<WK;%;aYS0EFuwY4aYK)<c{jREh2lKeTgCj1fI
z*?pJ3xvAN~2L)3*9?ah|1>Lyw+%&@tjy2$r4h1`+A@3UHVXqbPV>^Af(NKHRv(2oN
zrZPlk!t)!Q8Hs4v-T?FyoyQj+lv6CPHmnG|A%E35&`@`&cu?J(uS>a5cUh?GZO8>(
zk`}J-HQ+is;8M&hJ}4J(<pVBnQ&n7~g-d55;x=haHNF%Z3m4@At~0<@*N^87@5f6k
z@^N4HKF*JciZ?cAIHQ#G?4RlSp1K4(pNXH+@72n8H8smuO)p=Pu4xspn_Lv@U?=9|
z%Jb-F!G4GdtNrK_m##AwXO(UzrlkJvq;QVKz<<Qrm->hNUCz(Z+^MPVpCUez-_pE;
z^V@T^7P6ncsePOkPR|RCor^sww%hHx&nZ2mbu{=EE<1a332jh6hW=jO2j;c4cFKnF
zZyFbZ{aqW&n7qf7*JyvhzsFtn0soP*Jz&yhQq14d!Wh+pzLFxp-9lPCRMfvlDHGr-
z`<4d!4~jl*)jY0h|KRx|^rhcnW0dA2o0A^hi&E!X!}ug!B4fsjX?oh4Cb$_VrYbhy
zOAL+w?nvZ!X*c^GX>9UJZKLc+?H3Ng)wXGI+kkfow`e1)i4A%08mZmXxk+;WZsc2l
zt@E-7?bW_a<CyiAW!ZWdvqt#N@F&E1=ki??X9_aoYIm5dpq|MeI>{7g^I)CFxW?N(
z>$quLsBxKCi@uTm_TgjJZ_@Gl*2Irlew;_2$+w{A&)u_s+n35o`zmhm1mR5Q6E^2?
z;4Z^o`6v0-46#CmGYwj2cWW67Ij57)^&e-x^jvf+KP`NeLC1CnO!+7Mt+K&yYFq){
zJSn|1DvzGO0<8+PM4vvI#sug@cZnb1?4n{g*;yIfDn}Xil97YQ`3!PUzmy)8rx<@R
zvBtGtK7S|t!0Pa;{o%fn$M7S>@J0HNp3hFx{Wts`2xklRT&?s8uIqF?`JKGC;urL7
zbP@b&ht}*q6lkRU?UH_0ldtyu1$n6~k)i1BcCEL082+FX_+8=4-xBhq&-gbciLayw
zY;`*AtpAP4g1hBiq235MuMByw5~uhUkFtr5fMW#w_MMN)9s+*#HNN}4+hn12QR><G
z5y{4{H(Gxcom8HiMc-^B(ye5Brg);B`&K#@IQc=(bE8~YJ2E{S3Xcgq8h^+&;2Vtx
z+h2hP@kcvsJyCVgQEJO-7x&);J9h9LeCE(jJJV@#=m2ZftPR+jQo{E(<*c`L)>EvF
z?5S0N$+lNwE8y8<?U(=Za+i<B_m^6fW*oFWsklLMCeP%owB&5?lunEK)HomejZ5#w
z(fmgJ$@Gs;ukt`&3;jzxSo?k5T!<UxZ>2xqCz;o_3O{r;mJibIm)&b{@x3)++(3@a
z#K@hr9bc5L^#HSd3C3N~5^l{SX?HI;wrM`Ebpf6Ii`P3|`xAUBF?r1&k8rO7xQR3O
z1iXI*-r8DUbPrhlexcE{dHiCR&Ly;8$9`d__6y-J>;u{UV7C4&&3iTGc%N+dFW_qm
z`hKE+R_XrZELPd3SS5!I&EY(;#!qBYo0}<CNn?<0&Mho`MBl_hGyd(Gjp_&T!PMKz
z-7f+E?Bi?ri{PIa<Ck8+qxnIF-)AHauy3VwF0nF?buB$lQ#_Qep@DOoD=sYEAo`TA
z^Ot;kz@RY$`Im^4m>cmsI;=$sf4}w~o=oQhZBg3?BHjw{wvYYtYTI?LRlL=;eNpKW
zXfJ|JwS6bl+9&xv8R0Oy4LG20?F(|uFDjikf*k2HRopuw+~V)cF>b|?0XP23;z<01
z&e~WUX>uDej@+g=@<h=#JHf_%O!OY)6#PlZ+wSw$NQR=PJ=BG1%$8usQ{k!L?@ew_
z*SpMC8Ow*oDxLo&TMu`z)z*&nJGAtPj*X&4|M*XM6Rz6adU)BbzU+4op{%t5yk8ww
z)~_#XZorzDzAXrQJE5OjpSwKmbKxv(h4^2w?KYi>P|Se*<wNq)$r9F4C#G@M5wuq_
ztNIt^$wq;xKdIg?r3aq)uq`cX`F=saS4X<e*IYi_*Bm9>=4;Zm)#@Ij;$*Frvko!R
z{_4-gGwl`s;)`}#{9Z?&JjFiYo9LQ98~Hx4I$1rO%1Ue5T7w<fbm;ei-Kn(;t=D41
z@!enBxI0JvlDVz@4!wMX@GlPQt)&0^|00hC4RU*UxZL_x4!Nc0!NR%Z!*lmnog5aX
za<K0xH#Mc}(t2tQc_-hvBb)N?c>mYmYJN=YqIjUrP8JSt@B4jwYj=S~_w;x>spC7W
zRiS@ZNaLR(W25=r{zdkEwY`@YrFW;W4z+{dE-`zi&T;JNn4fU@TfW6PT*YPNai&OT
z-V^4ud{3tNGyPGq!xDazR?oV2pwGs!wWHdObY4HSQ{Q9xZ|s+4dwzXIQ_pW!j_Kim
zC+8I1U}Xum$5>g{Hs6nRjxn^2ctZCv47wcg=q1#>gm-xV8_&D_Hlkp}9fIHI;s32R
z3C?*u!Al<gn*irq2*Edd_=^D!9l`&?!)a)W=hPH_n}_rLPzs-)!f)~LUj_K06n>+J
zmswN&)kN1vy}qZj$Ig8!J8SO#>`cyB9fQn|o-3VYTx&^wxx9oimEUx<y)3moZ3Ev%
zGr!u@-fH@~qn+^z9yYhPqO-Z>yV_fy;<=x73Hwb#bZIyXHJrP_Dcp6synMJWfAVAB
z2bV2DZx^7qH=(!m`*ZZ_V>ll>`MZteM?^2_ZY}A&{~sKep1}mBn6*P^MK%7q@<Zz;
zArouEWPDf?ZQ|KnaIMM@v6lUo4BsIrKDK;(VZfz(%`9$J-Ep<L!@kq?yw%y5?>|G!
z(z~hE|KAKgi}&cSImN!jt-5<hcTf+5^WD{*ns1zf92qZi*Ay06TadR~f0E|K6SZa~
z-89x^kLYcAt)+%o@1<<l^<F;bsZGRZ_WQRUxAyupCvU`~-_+fxv5a!WSkH5=!sb6=
zya?r8{Cx&>Iz6ox(V{N-=J&Fs9kM@OaAaU``7iuMg|z&5mOEUH9``6G(0e5s<An>o
z%62P!r^)zLr)SA5=tVJ6qd$3LYJ+@t7}g2>UWnJJc;h~5TMrTMe<XVNDbw8n+A5hS
z?dQ+Uz_!zVgQb1HRj^=FZ=`-6JkrfH-mQI$?L1g&4<Adqa-rQZd{$D$afWz^*FO|*
z&)~jw-N6hm=+@53F;?m<l6@ERbABgXYl_PlGi(fXt|P>_fw!5$D_P>3GVJXU*LD2o
zkLaVoc%Md0(rWJ)`?ZD()3m!3*;A$k9kg(+Gw7g&`bo9Fg|(^pTO9Tu(Z9aq%WJP%
zW1{4Ztz8@Bsy?zhN!J&>oXd<?Du*wALgy3IF5UU1`_tk!<)Hs%+N3+SJ{V+8OcVFL
zpQ0<%K@6wwy_UW=49@qDBbG;JJwazN9=?lw3+p_?@Sw{(wZE!9z;_oF>d5x5_5J3q
zz$^K)wdO>=%EGtqSt|vdvKGfVCuA`XJnXHiPfHK#KWbxzb>t+6j(i`iP;Ry_6X!!a
zwZoWqY__61ihzk`S^boE_5FT)LTD3tPY74&4;ASRdZtU2XRYeBad~tWmv5uILr)#>
zP{ptQBc2&+6<1g1BEXs#VH;jfZ&IDmHrm|+AB$<PWFQ)u9QTQjAdldOUhipI`xFby
z55co^@qm8EUG(Vtw*SsNs`<g{Z@6{5#?w~*0oe-qDi7UVjxjm#kfkpf59EudCZ#D?
zPSg4>#pbA$Y?GbK{M>)Cz961`dDY*p`#C&ro6jOIo#A|evg(iZ{Ve#ghH+Ck=_41g
z1`zs4Cwd8e=QR<0D>@1Ar4hV>+ynfm5&D|+BwafHZCMy&tLM5VI~!y9?P%_B<SrY0
zQ;xag<7x-}*!n*9)h!#6F5o%Q+7eI4z83H4cTTfXnC*2@E;%)=I~u)X6*CG4>qer}
zB;Cn>XphR%)w}3P_v}0Ayahf_`Feui*VnnTP;R5_)Wh*vwKA-)jaY{Db*=d%e$M(y
z_NNNOGTHL1Qf7v&A8bj=t)&7o+^KH@=&SU%bp1tiYHJW%T<#5}GyT1u59xf9@|lyr
zM`zjf&K;RI@}4=Vw$^{Ox0iq9na-=j`K^)9&dP6UJW-$TR$JwN<&WV>{oHuZ9b3Bp
z=o;_nv*X@~_Z;6zQjTwH-cZWG?;m>E+wYDFzxOFIzJUgO#Ry+F>oJC}`wgX^18?>C
zOjqDCUCDO*`|ZeE<&*w5@NG|i@EEmSGUbkL^Ouy%@!RQnckF^3znw0A%<e8oc}ss+
zz1e<OU3rP_Wj{I1t4t()q0>3GZCT_na7;}O(qTu$H!(=+OVQx~e8~2#9pyKazDzmU
zh5E5*9D`j1|GHcIGr($d@0ZaP?fwJJ2_v~C^l{^_aBQi4R*gUDX>P<{zyF@qc*>ny
zx{tiKA=|*mIou;8dvsCU&>i8vy#e?12)EjPA#%rd`a-;Fbn@qx{+x1Z-+1zaKTc)t
zOy-UH`}_ZR1^ron&6`~{+JflBx()h^W&bep4)VI6??c3A=#%<wyU-`|UY`m26ke@e
z?nSTi&(^lw*wUMQ+eXw~w5}^3qjO2I-ujVk`IKUx>_qshHb>u1ylsxe{~fZISCB!C
zpJ-29>t39%4C`JAdxY4?o)yU3*0$8fd{WvE{e84^?>uy=`8(s%e`vjiXV`bBu0aKV
zFByT~Vs+}sms?wT|B&#5J3fofSu*phe3zE`RPU#)zS<W5Ryt|ys_Mt(t5lzUYHNre
z<qmn%XZNusd|{nF-xcYzh<`J^b)Q@MA@I~chM2Xs?wC2U=1-@?JAHOfH~#$DAJPu#
z=BAAuj7NQX@6=kJ<9<OuhFMzo4YFSouWMGnF&LN5Gb`hYoJZ(<#N~?9lTVJHrn%>U
z!B#xt3dQN}lWy8<_UHsx+04x?kA!#CtDOUU*v`$`y(x@yS`VZzZmE7Z$NC6zO7|e<
zaORY|b2F1%&+JKUJQJSnJTp9(@XV&)vgo@l_R($pY~nra?T+VN^G)ev67Ng=`xM@n
za&DJ73Tpy=EzZ5Q%w8+c2}&<e8rtyD@o)GpVv>nv_UPT};&jSP%q_U9BY){<*5!ED
zeGz&JpK!SG#p$A7;k^ug!%bboO*-Ii0rx)y+~61yH@p~b@h$qoO*<>Rdw$=_`cR4+
zdI5JExVHq{;204%ycllDNA!hTGT~jcjPF!76O<0PJHf5rX)&3AV?^BWVz{LT(HCyo
zP~qM4`&KWT2}%dt8^OII;Fc^$k~h2<Zs}X}g_}0Kk}kJ``=Wpw93$d}7sLH3b-5kf
zI%8xqkt|2zo3<P7SE<VixK9kYCCia;|Bkv;%r`dRKFqpo0rxK$KTIZvS(k0#{$ap<
zn046+?(G5hVb<kFaQ6n>hgp|f!F^A_eVBE*9o)AD+=p406>zT#xDS&q<+}!M!`ED=
zb5;0q*5K^PZ%*e)yIb)Y7vVohQx@MnO22xQeb(r1g6<km?{fd->|2#CXW`1EjqYKx
z0i$~dbZ_+ZuJBLVU8T#KujF8K50iZuU1V6k$<tfzpR~J5_j2fxHoC9Yb|_yRLy?uy
zLw4m2p3X}Dq`g&oS3r-n(OVelb^YIT<bL#z>vAtQW>da8t|B9&hs^kHDYc)g{gZZ9
z=`DvIX`>h0QA`isMc3jF@f5~!%2&r)+G_NWRe6)A6YQ6ER_U#T9%-Wo-s*S|(}Q=T
z*EqIQzB>NGhtWe;Wo*a#N3dJkS*3S1^hg^$@Qz3i-i==4cu)Cid_`N09<oxuGkU>Z
zX=jz*b<iVi^uRkJJ$N^IjWGb_huI6VQhzggH`Ur%rMCupwA<)`cSL&dZuA=C0?H4w
z7i3lSHydj0tkSy?dbHc<fp<iD=*j3c#tM`lW-rJ}{ma^STdkc{dN)Cjb{oCJVK2x^
z{mbZW@=w}XrMCfkq>bL;uoq;d{$=#;@K4%VrFR?jNE^L#N0BFbGI<_~y&x;~FQXUi
zly+9>ZGs+YqX*s*^@pB}-l5nFvQqytdcjU<XO-R^&?9a1z&j$nC9lF>kkuiNi{KrR
z-eOPhQ2YzBI^^*Xyd%;>uO`n!@h`~gkjKHpVK3OoA&-BD!(OnFLmvMQhrPU-@$Ych
z%jL8Wo3Z|YZ?oshs6WKx-{G*AE1-wX7#)0@J+F@F#pB=aZZC8FI5=Sd92%qO-xKK5
za|f1_4u0m9#>2>dil4Zzqp<g%4mF;c>&L|j1K`k@Ri%$?4|#ly?5U1Edbj>L`gmo(
zPfvR%41hypSd~7qKIHKdI>A5G(MO&}e{_GOJMZN~Ck%i?F;JC0Hg?G4XJl`6^pU60
zAKgFA^>NpP0dU9`s`OvYcpBMX9evtn^hY1xMz_CLGrmG+MEN66qd)q1H@f}ZggjRI
zei!<|CX-J(Pm9M}=!{4oc^duS#r`%x9~-oO|4QR8bVj8A|HuArgMRRH_*&xwIba{d
z=c&IB`$N`;JU;(E?C%cf2fufPZ$EOVwm+V?{yyvvSs(KF{rj-LS2LdfKI{)!AM*V6
z_hEmRLmwM7yAS<fWu*Ujy#IaJA2xT$<Nxo&{+2@@8?^R^et;aR_8-rOe;@XTtPgqo
z|9#jWzW0#F|KErGA?rgP|9^M;duvz+8F)40ePnO_Z}?b8{^GtvjrYR-%3BApsY9MW
zNA^`m552#__!{=l-a2p-^suQgj@fflWY6(<9@$eJJ@jn!Mvv#-8rDGuHb4&>GCHp`
zen<9GM-ROkz0u>hu+R4D)|DfBsiTKpjo#?-TFqXN-64<9hr?d(fL`!JS9rNHM&v_0
z5|77+!(Q-xhdlls4tseu<L%+F7i4$H<LlwDm&>7t%~*fHx7l-Lq`!DPJskFejU4j$
zc{uE4IrOj@Yge#S+F7;Fc)UCu_JZsVd3-z^_JS`v<ni!u*bA~d<nixt*vqRK{|<+}
zU?Yb-{v8f`xe0pMjM-<f(@l|m#^c}Nu$K+c!)A=$D~*4z(q8<Tt+3}XF-^PlJPqgS
zx$mL+uJbP3!8<Y0w+=dQqx1S9U+0TyYhC{QD4+KVvaid}NBO*0u!U+qXLB<AZg0Zb
zh#!2H`-QabK)&s-fhT-pV&{P1OJ`<uwyCUpO7t5<ONW2|SpiS_-QDBqeQ>((OyA#d
zo~fnq{*J8&KD*A^rgYa|b!;8{%DTjVgR}ippXg|t`T2ExYu=~w+duN5j<&J)uj5RW
zrIR;)vZL+2kF4V^3rq8DbPAu9PoFbV{%U8WhM%W2na-d*-;UThHJv$AnloLxlY+Ia
zR6pQ~%T_qYwwUw7kL#?g^a4%zo~n0#PdY6NOlJ^VUiv>zCc4Wa<mr6fOG}>Q>yW!e
zQ@BKr*kyC`OYZr{^}T?~NI%pOJc}+9bR#(FT{=T&XYx3or}N=6k@Em$jhD65(^*2k
znR+kh5+`!DQ+am2lXG~&7xLHX+@j9uIlkQlr@g;KefUxPF64Zj&IV_|q2I|EiLZcH
zcW0`eaEQkNcnD|RfAO8hb9P=AoExlgcUIZkP@=Qh(8C7z=ziFlI`cb^Z(g_`qkKnt
zpMcIn>P`XshV57Hds6L5bUux8<!o-Q(|s`LE_ZUjo%<EMvXgsObk8C0<WJ>W3M;Ss
zIF8V_G`b(~A-<n@D7udYIyZ8TNB1TUjgYsRJl%bO9{b#k6FI*<u8T7+b}w0mbNnV_
z@^$t~ZJF-dlH8hErg{~=?@Bns*U0y5_%@!sO|)?qmp;-ujQ5MV!w%kW_un21=TDKd
z?nM)Q_2d0s?#MU&MjQKSyievu$_zUv>h<C{18sHzZk@O64(H%G8_xF((_|Nvsoib-
zW%vB4oM+AJu7NV=q&bJe`?jQfUMWYp@%$cC^;|7?23TJ1{F0uI`|{V5zg}{p?VR=G
z9-8cQ(b0V=xd^ZB9F6h*lHWQDc#HgQl;ss_c;5-$cY65?S5aqfWmkMl72{pefcM7{
z-hS>1H@w|7ycdG^!oY9%E{rqhEfKHxH{kq6gfqt(cf;x4Se3y7a4rZqyZH{npYcW>
zeS5fr4!fFL{_b6OcYo-iU*@p=vj1KueAD?jWz3)PJxzsgiS+HWJFwwN`uHwKf8n{=
zJ@@BN>bu<XDflaVQF-uh_Y~gs<zIHMfAW{bS^IvOyS4ulnU^kjvTc;SguK!4w#h$1
zvmoBQPZ@SzSZ7pE;XY36Oy8`Ry?w_0AKvV~i;ez1_RQ(D1wWSFcai$H%hU%w4cX_B
z`i=?vm+xuucR`&0J?=`BJ?4%p-OqiHyqi51vBxW8UC8g^yDG?{6IpCU78{X8a%<Zs
zT3%Xuk9+C1dvdf*-^R-KHp(o2YyJ}n<?@tc+%Or8BzG^Lx$wxnD%rW>#}(gL`Xaoj
zeObQk2<=om<O}8FKhJNB*>|dv3pU*8#~$vNwEMHlUWOV^8vFRrx8puuySFgZF}cr6
z{jT*rzLRh+y_XQVcIAUT=Z`C`;J!}r9QyS1NQNqB_5JrN*0%09mflAhjYC628Gg4T
z%U@GZ0bTI@aVvkN%vkR)>G%J{o!-r9T#@>$dBfYY%i0sZe;Pin%ckOQS~emp<Haqu
z-+kGOKO2CSja|t64KE;j-_NRk4ml<|*FFEp>hH$a{AB(8%1*Y1kH4Mo;^lYci$4I5
zdbW`U&n=P*a=t~dq=__7`<4}W3*#4M(zv6Les|*}OV!7Rj#fXDOTUwHJo)CSC*S0H
zidpZE@o(WfDf{->`*gmMZx!CkV(uX2n@!`Z$@3*XW4@+D-+5AAwouUb5R@5-b|Wt7
zvGxshdbYkFxyY9xZ~n05ZzbvPN$CA_{|%IXFUrRC?(JP;NEmZm_1m-hJFy>Z#9zeU
z2Rz-0^_!Q+Q~g$=&&MWaht@~%sp^j=WBga;9^{YxM)%qE-3xumsYP;9U(M4d?n2@l
z&S}2vT*WY-z<1TzIlj2D-%bTr&3C4ER=lt*>G`$3i#7jF9EjcS)tzd-{~MoorF<eg
z8@I7Diz#K>-;^xm_oHtsZq|6?%l_k0X}%+$J2vfZJ+;U2-O$hwzppdI@9PZl`#PUb
zZmIiyojI9XtRGx~ULQzGp)Y*(Tl9lDnQFRUY3SQ`H1dHf@pqK3$`GHpgm$Y;W=dOY
zg}TbW1bOA<$BW06W>4`xsJOV4$0mNsZ}o-opFUvin;{?c0ClO~j(>UMFNW^pZiimo
zJ*W1_Ccw9CdjDd(<HFv{_y_T}jTm@S*6Pitp8T-EyEFC;FL&?s?gz%b2>hnv^xlE&
z(Zsqldc~h}+#9RkvP7O112P7GRB2Dwd}Ne&`w@)S`rSs+)o;C!$9#di>3H&+S!LuS
z`rGAKfPL`Eq5E{Fu$AZAKb4p4WS4W1gYMl>`HC<9=ajFrv%7}d*-hx=g=KBnmA>uS
z<L}YzOYdU$-;-#pF2^>u(A${CWQ`YvW2?5(ulo!HmmKFLr7v(6+2)Ue@%@zUmC&~!
z`xoc?^qWAs52)&ovt#Ezvy1YIYml96_6+$#UzfJcwfB5=o-=nkwh_J=68;$9TC=|z
zuA=&-$J>hy=+5e3JDutq<mtOnhdjNnx!d&U+di;x_}v1hhz2@1xZxXhva`N=MW*LB
zicuI}D}47pK))sS944~@vC9DZt(=y({BFfI$XGU&?LMxwgYQOp-<DwW1?2Vm*ybf~
za8B3vS3GAR1EZ1Wo*c<b^sp`6RZ@W0qw&A*<S9S=D`fpNI(UjZL-y0QecU0kmpeoT
zuxI^lvFN*kD}5MxCRfS?9)Bdgl9rCjKS<|iN69v!HwN1bJT$qDd-l?{0orD=%#P`O
z4ZqQ5_53|?W`9?-BP-cpkfZ+|i?M=l_c}Ud(~Jj`jrXI^k}YiXunE9s^WNsuV@b>I
zYj;X{d-mhtNVbg5?f0jK9!<x{CcY`teKyB%FK5Ej#<yHLMm{(#y=S2vJN(phsSUa4
zn@Nq|l3li+xRX2AcsJeU;P30SJ=mO^&Nt<Z2P*5zuCxF--y<1LMrX2d`pLe7$eDc<
z)#bjVG*0OD<FWi0F@kJ0uYC4*^ev^))3>nTUWSh4^JL#Dqq2r;3Ak9>(Y<QQ%Mr&Y
zuU~jr|IxW3ts#}^r~jfpsl64}EBV&{b!}1mbgx?6zK_K1V?MT%y0SHNuXq=GN=k#2
z`BSx%c>Vp*(|n|zXNzb<W47m6{!(=$$AJ^;>8y|F^fOQBX{6Jglzu{)#iD~8bxzFe
z5ByJkGnGk<Khs=~{~a-Y?sq8F<KO1WN$DGuIYsy-$0oj)hF`N&Xnd`n#x}Esl*ShI
zW9dM@RTylco4PkQ(#T~>pQDWRt6&qzN;3MM?1JYx<|~S6+bEOp-LmOdcKj&w=*TYn
z<>RO$9TxoiZ{btrq@OY|uibYzf}i`D%CT-y>z^Zz5mw*g5I;uPomex6`#k2Ub>qZb
zwMYAtD(lCI$_vC;8Y}RxBaIc^;%S7jB4O;2-G=x}-+&9x`Op|`tk~Xwt8uKjgt|dj
zuP|1OD#K5vGJN^5f-%Br?S(NTjRTO!|2#SkJGM2)ynIQ4*an~a4^Ir;cZKYa_k{Zv
zEH1#;=a_>wztsHvcx+0r41Lb>bSHz$Ro4jrn0x-@8@8Ko(7Z0iTLN#mcO%i<8yp%#
zz?=To>j?BTURgPtKOSF;2f(dyv$7z?bNdu`?-+QFVb{xsX|LLr%^hD_akBMA>n8>J
z$u0aQUyyxXb_0DI?|9mHC;q~Cr*}WzeHwXdyt|*Le9$7E)$xvTYJ~A_o5s5*pf?A)
z1C$ATH_JXrk33eTeW7m5*H|xJ7SV36OYvxT-U&XEoRCok8mjl!Ag2iSaq*DG1>3TP
z<4ZgKpk7Y%en&a|nU~Ysy_|mjcqAuuH=3O8fL=8&@O*#orF85aSx&WYtZj^=pUW5Z
z%NI>XCZvA=ZM}1k@}Qn$iNWi~^4k2n?ERJbo0(}$YQB&8S-?lEKDW$VEsQgY6SnhL
z&W@RTr>7;l!^$zP+IU2{_fgKr(bl&s_^8JD+TT$o%()M4s9R^L`9$m>VSF~;8sg@H
z^}%R-KFzm*d64?3<;P<^YYrLOK|I!nUG{w&`cA(mqVWN_C0>4Z&%(_oOiOg{g_p5p
zt~u(DRfm3|SSl~S;<&4jGNs+=y$~bunWr9f_t-c`*()il^hU{)bb)lce3EEs4#1q`
z^Sbvk#4gC1wQJMyhw1k*uD4Ow>QTn-q0@Y3fgiV-8y4ZW8i#nl71M5`{v2rUgI@3#
z4u7GxWxJ0r-F|v~e_4tD3*~Z}8^E*O^&sBiL31h9b@^=RTe=ff`RJ|1onZG?Xe`;>
zD8v3#hIx3Yvzd9rZDtmAYj=`)yC&Y%+QY!{u8(nG8or}$ZRr<}!3S|&Wo7-^!_Ne#
ztZYI0-HJV3>3P!{N?Cgy(YnyV4a4sZD98P2X=<xlOS3f(>5n<0<YKzX5>rLG*`3Z=
zsxji$G<MsTbtjZ&&#%c{{c}ttcSj5?yz=LZB3b(R$2RAhO4n2VBeE&QE-y{)`f!B%
z{s!DX=l9TpPH7ME4tFOM(=|rZWwELBr_v?3zKqOn7GC=E?w<jR)&Vz0G-ki9p8xMP
z(vV!@b<h5$Qr^>e02<3hLvwq@CCIEUE<uhn)j!Bj*B;o5<({;u&)AxW$!{Q{UqF6e
zjOd%)s;=m7s;#A1Tgy$Qlf(z@laDkWbk7m#bghAR<YPWV{K;ns7dr07kL&%@n&&Cc
z?Ea+mjvTdDYeY?L>3wA6=Sb&W^Mc%`)BANY%wMF}L{HXAs`pNeryp>SQj7LYwO^_-
z7kl1xAFk4u`m}yCRp|?S`U0Q6(5JbVNB!UYG(5Di7pnAD`6ANildkK7ONaNth3F^V
zr#|R^12Vo(13RkuaK`ln8n)iW9BOEYI2(CtJs0@2gtc5`ZE>vLEl+9YRAF6AZ94c3
z<jS)RUMY8r-lu~@{X_R!{t4rMA(P6-t;LU$Kbj0_vyD}Go)^gvK&#CBO@1J+yRE6K
zxg2Xn>^m?%koR}c*SONg+CwMx1pAnWZDqb=b=1d+y+fUMfLnF8vd$LMJQFx&Y;7iP
zv(XQ6J~B`n2H@i;kEc`dDX@h02`*Vl2IA$**qz#6$fWIX^3Pt*8na%c&q!8f<Uh;z
zVZlYSsD7`qq<2crQ9b2%hkR(M%)druM%1B~WkL0L|D4JXHO!fa*&6Si>{dBsp4!*f
z{Q6LI?>lR`er>I0UyHqc$@eqwcX~1}(jI&TeQ1sEa(u0PoQvjmW#p6BIF~=6)V`?R
zU-j^tQNbtX(YMOE+?di#{K%P-9do6<jBNw56R*eb$R9@gYi*K0bLcf{6Xmbx8F*7#
zydE!Htl^lSgIC!|dC>bY_?q2X<Eud4riicN|Ht0<fJa$fdA~CW5)m*0Dk?26|0F00
z0fK~oG9e(bqENtUD>j)V1BoP=Av1wc>2_4MrAk*KsI(OtmEA>3+q9)EbZr}z-LfnF
zmLhHGuDTPzmR7opt?fdKneX>I_uQFxCW+c_cfap>zK2nA-uIky&pr3tbI<+r-uJzf
z&$NhRgwp>azj+wb;2Y;yXVt#Ay<gj}kdC^Du6E8kx2OFBYX9_i$p6-?YhDgpUX3>5
zZP!0Ec89MV2!8joOUnjgzsZJCc>Y)Q%BT&O40Se)9O^pGZ5(5943072fhzC?z~^po
zzvzI^4?Y)su<vdDPof=f@L$I?KDqW?CuwKl`4s9HdsEIQImY7}H)0C+3CKB(@S`sF
z;jN?2vA=e_dlqmu+@*3(W3GH#I*C46(r|5!{R-0nN*eap#Mv|))36V~d^yB=!dj<U
z=TATD3(7h4z{}hujei>J|H6-cf$hij-1{y#S1=~H9r0@&l%HdRD(=z1b7rpJkE*LW
zXVan%S7UW`$UOXW=0Etc(TJk~xAP059ehvAlV)_Cn@S^fj4>|Ga#{T_+aL9Y9tp9X
z)pbN_z8Rz+kq2`v==GMYGw@!@bZv@n6yuW0diOHq{vVVfmwQg648I;I-!6Wuow|Q!
zA<l!l<T<XhNx#JWwN9uD^)34y#%U-o>+s~Wh`(cUu@30R_q21kR(|y4Kd}9wZn?ez
zyFZLr4S(B`6Ccs`;?41;@VB#eed)_M<Ic8wiJwTzc!zqpp$qAm&PnuZyOQmReu()=
z66<{8Qy8yyalA#J0u-OJYk=0Lpj%=p(xB~2nyE;Gb}4B9B@Jk7tG)T*66=TRR~)PN
zRVQpae~wSV4iD3wRj|8@SVNmTfDWD=$~OUFZ!=~YVa6=#3-s^zr^oyAi}$a`btygW
z_4*9-GSBNU=iu0idS>}d*YC}Fy`4O3m;3R4*mIoo&fjyc@$-yl6bZyZn}*}VF2ptT
ze@7XY;*8y#PcUwvemFnw`X>73XXV@Oc=qM&c@R9K$cH)dH24<%u}bYN?UU^m&voPU
zeZ4NjwZuKhHFMMJ%-mGkIC$B9nP&&aJTKvS8lK<XaoRkG3&3A}_~stzr?JLAi2g&~
zthP-Zh<^>|z@raJ%}o#JbAe84r|CWI^i8qT55-Q&av#1s?|bf@a+DkE3td=OuxZ6!
zIu`62ACR$29mXtIUG8j?ev@O40G`pIFT0KB(es}5hB*c{;>dg;RgWkq`?oUM664lK
zp(o3l(}_NFemvEtStsAdcOz|^ZpXeP^5?P71T^tH9Sf^qhqA%O_n+pu$SI!m`W$&q
zD9<yNN9>u&^Uwez=OOTl9O22#t2WQ@)DHCWq+>4g>UXK(={LyBlkRKCbBpG6i_J@(
zM`!X>X<k*#D~I2~zXadG?}u;J=i;07JWmhj>&bXGk8}7fPW+O#e}(PRx~JuJu|G@M
zCXF9u@lsawSr~KC$6bzF$xpoJ*=LZxo05~ZO#)-^F5u|{qcN|VW$Qo7hK`jh<xQvW
zf=$wL)AizVoDR7IF&>m}6<eL0w9WrqnQ_%&Fnsn3t7n!ztRv>T<d14kp{Mn-^zUZS
zKbW?kwNt?Kc~7f6@4kd|dDHb_<^DV6A`WKE*WbvBffz?+uhBh!kTJ0AIkamzcVOTX
z4;@X`OnmvB`<?VR6wyArFz)4dGCMU+NL#;au!)Tvw=KlK+Z?WkpY<gWk6?>6kj=gj
zV=n2(t0r*I#HG(Ap7po+{vv)<pVKe>6!~)U+eTg>ZAb>K6*R~_fcS`5@xW1zGe6)%
zthfzv6n^Ji1G_KA^*PMJhT|IJJ_q0C?yB+2*#RT>;ThD`ipMv&z4%dz_wn1}klzJ4
zqv6lw8O{B%HAC7?;#$YqTclhVbNn-OV%`C53;l7AF`0a?l=}%eW{__!Pcpjjz6;m1
z$y_|MkZ-&z&B4A-o`nFr$}?-~ZgD>BpS9^=SDt%z19kdE&1gLT!F~(K<5^Jwv}J!)
z|F*IR9>m_bOZF7yBDQk8j5V%-96#V1WxOJRbkhD2e?QH&DU7)>W|F$;g#Z2SHt2}^
zS6<Tc<Y0`2{s4LGIRQM^pEmp((*@3d3}s%4w!pk|oDZ~B=h}Hpf0?g;7~f;Hu_4Ye
zH1wt&+2)zX>FnS3Jb3P8d&;(R0Oys%&Mj)^cJ5;Y&l}L6&%91Te<^cko|d`ap0{|e
z&wG^lR+bra4UD}q%Z&RcdMh*VEc0BJ8P^|xJ`+4;X5T<Pd~s9eVV*L}7(2VniM+N?
zfroQ*Yq!y6|6oc+jz@-!PdSf~dQbbI6Th^r5qw>!uM_Z3tR<Ox0`D;BYTL^)+7>=N
z@+{g0VwlUm6m5xZ1pfP00zTK9j2y~9dmvw5Z9~q}ux*ermokUpJMr)%wwY%*kD+Z6
zIEx;2xfb?io2f#c)Nd$tW16=wf9q1{X6<pJf2K`;09~vfwNqc~KhA)*iLk+Y={ZF6
z>8l)~!v*L7y?e7o=j)mWV%UdKhQwmnk2b}axa(hKUh=NC>_B?ND&cW851el+^@ZnY
zM_t5Af7M{vsNbHyCNJ{2j`@^Jz3=JNczfcmJ9@08+)h5UO|zB~cur&YBb_;wKTUm$
zm}4|uQ=yHW_yBpg0b{_WT|?2{F(!NnV>EBSQN>sUJLkZ5)X#x_Y<IlQ!M^kp*TFCF
zjcE4W3$dSyydPox%Kj4j?O@L{DddrW4$O;w7pHt&A9#^#lV)#`e2*UA>9@~|%=t9X
zJqPLfBmHH7Ie-|SC;FqmddQr0X!*#)xQTKcfIbH>H(v7_Q;q{8>wIfA>$MX{98?}F
zBV&Ej_I0pZl68$TQs)5UD9R~*1fCN~tdX)^(iZGL&_BKgT$SIsE#)Kd_XkktOqYu5
zz$K^)<PvAU!_Pc?d>#Sc%3K>uKOf{X5Y*daU6;`gf%8X^UwS`J);lEN3BtZI?gp=u
zi!{)i>9{6Gomh_?i&vsga<|04An}>9(Ow^BTF!MCQ=#(<#(pLiAq{-tHr5^K>3zUG
zbqM?yboc_w_kXMd&NkxupzM1_nQ7lD)*;HrYlqij7u22jcKm3Fx}x4~ohMj#;O_!o
zYRwn*mV5zxz+t_Mc6bExW-yJlwb;3TIegi)h2%@9XP&imx$|5S@^MDkFsVaLFMc})
z&$#H{UL59DU1I_V@a+4*T*p~`AL_ut+9&cG=EXMx&)9wq>jUZGS28!VIwI|x&#?Z`
zMyNCIb1uNwv<$qjRvCPL=j9`wd9tnnm!d40XN<~uLB8i`Bj!z6^(M_x>O=eI14^uc
z&(U5i`w8$*gS|(>w>Z}I(z!QY+l;*LL7k~9(!R|2&pi095A->jvT-?Vd^!B}a`-F8
zQ$K=CxyG3`4Y+opyDfvGd!_BWaDeHwag6I&@03%bZI#yrI%ntgSlu7?E;8S_U)wF}
zUDkn6W{35{IEJ#|nt94KZ17f<`Wk)VRrtN_^U5#=l(A$lX{e`-1(ZkIGX3GK^o*A_
zPH_I7&^kNSAMHcih&_*pbx(add9JFtmiUYQ?mX&g7<FgNU>!Wexi;#?*2!qxi#{ek
zh%R`CPxi=r>lbr}87E*5#?FB140)?Z@wtrVpTL-+H(8@FR<N>0AuaiRe0~Qw3jTmt
zEY}X7v7vk_FI5I<BjAOdq@3-X+wmUpk>&19K6%CW5GN$R-ttf!WSF&j)-`PF_2Um`
z*{>SUjCz!DxAD0i_|0Z7otEdVIQ_*_4xiq$o_e(pY;F6g1lGG#dSSihM(Q<Q>z(_>
zS*N&X9amT#F}Jk-H4?fcvf3>DPUbPRCwQgokYQq>k?mSrtL>k*Ww5rl_W{OB=!o*M
zJRFBOXlozLvfs0BB8GYVZw&952K5-o%B$1L*1XDapKYh!>e*$?)48!7Q@wqc?>UxB
z=ER8SCo#4WS<vMu_Hp2h!acvoxQy+DcK#7?x$sT)ubfLIWH0fRd-%<Dw)3~|V*Av-
zg6%U)_9?`PHxM^|!S;%}lXw6dqs?P4Ao51Ov^nd?w#^AFpBJyOSL&(5S;M&{&mR+6
zs3(zyd)7N;vF=A(8Ni8buZ*|xoRsf(Vhl-p#~E*N%{-+&B2J|6j2Vz2c(i-s+bP?V
z*NgNg>Z^HCAC1>X*%pw$@rS<B(&tQCo)z}vRNDR~Z5Qc~&vHmv+0UbXP5{SzD^XsK
zfzox|^PJF5?$yOwGUC_yF3jnDsMGBDDf1D?qc2H0X&2tB-vx2+z^7)=mx1pOK1)9}
z#@7b_XghJztn>aNCl~Kk<mh`9zC9TGnfGXO`tMoGvC)kvgWBJPJt>E}v0N-C<8l#v
zkIygzco&MXn>uCiTEBtq#*i00!fR#SXwG62*(gH-_mIuC2zjUaDy9Liqydfc`F;=m
z8ay{xn{nS@_Osv*bfOGczew-*`HFcKNk4>N%ey?Ean7H51pfah{C}%+{+Cap%wytn
zy2i)noVYPQ=j5dLoKsWdbKaO9pYw}Z@j1Vo8=qtIlzN(L>M8M3t~|>TI2AH-a6cU|
zH$Eg0<+uTG9rk#a<GkJ)Ut5*FKUS4nhWE(O-ib$<Pr#<)OR(3c{8)2f9iZH_hs~F3
zCD~;?@dGI<_PM@d*3om&&e5(pra#diGGKR(JzdVX0+-3ShrR`Sil4CEIvaAA(XKoP
zm~}gf{U7SukG6unQIKQ$(^23>Tbsc;lXT$6*(C2j4dV*i$7S#*v?c1udVS$fSdT&;
z*1v$8!FZd5&vMQw<EXj7%{6@i=hSkIG1zXl1K^!b=ff<6?B6CI=4mNDoDZ1dd)4qs
zd}6v4K1pZCY~Higs9zE>m}6@~S)*my&un;w<&d!{+5l`TW0Ie0+!Z^55BNP&Uhp_9
zJ7h>aNBQR>E<DS58Tjnn)b;}+8@$}FkQ(QLk1?Nlm7%>dFUEc8Z!eU+LS2Lg8%Q02
z7w>eNaW1aeo|)%M$a5s-)BI=qhK&7bh(BHMJ-$ElJH&`iZ){p<eE!6<j3-0)^zdc0
z#azUR6A!_s!PA3IJbfKL-UZ)ATiJ6E@1b%nw`(fyffF4$R=_=NM*nwF-eK@_i4DjD
z<vX7Mw6QP<AHehZ^TXlO@1+~%_M>0FA04rFLLI-TIx?-c#}3)Mzp!U}?Eb!KkD2?N
z{@db@<oiDze>T9kvf_^^@7$i{eNoGsia!s@80)zt+YbEKGskF?c?sGzeU<f$__Dk!
z2lbA7`YvP2NX(PsT%XRyV{X(5-{txq`)#gIrQWkY_o-Jn|H)3nn2<nUL4L|75A%|?
z2;CTCtS--R+>o6o=6k<_Z}q?<?)(Zdi*d}Z^<e(Wv89xo{>rijwtxO;{PPEX8~^;z
z@vrN*Y}bq<Vw0h&2ku1=+|wp0J#gQvO}u!uNk)2WQ!gK%RbXAh;kynjH)vu5<b92`
zC*lk9=bRsWNBNBFUG40VFR>SU1~TmI$s<EQYiCb-j_*@;_TpjZ3G5qK-}I3U&KF^4
z?Grrx9QuZnvz!^Q*AeOC5W846VsFlsq(6ZFu-^cFB>J5Dc#S^J&RuN$d>U)-5<i(f
z2j3T9e>IE!3Famk`!gP=`T_QRh-IVbTZpmJUxLo{FURpeB4ZxVGWtz^(}6N!Z|d;^
zd>ZLxJ%eXPbIg<YrT-i4pa1-C1Nc6Kd^aM?*UK<Y;+Rz4Uwt3>%J^4h@|zP5zc=C0
zA&4~_j{nE9&Y^q4j@>-%GVvvx14|n6lkyrK857fX#If8=8{jo?gtqMOmX?0r^(7r!
zAiek|^hxz?z|l9yXq%(me5^m{BK604jq2*da}OWJ4_%<y@q`_FV>}`2qITVy-!G80
z3Z!SfVlp^P(y1)=)y%h^K1+Ylva@WwmU5!LyyX;~+1FDi>VOzS87CM=R0hi{u?{}<
z0N2aFXU974-2aW9&qq;L+83wef7n6&%lCWEv+wKhLwEYlBv0JfhWXes`0QMiuN?o-
zfAd+YgJ)`qNxm7$slFNH7kf{FzFFxL(?Oq(cOoz^e}ML$tGtl+zS1G?NV=(IGmys>
ziT9gdC-g=fb5NJm^S$!AlJ&L_WzT9S*qeKv`lsR(cxZdUzmIbJJnuHh8ai!(^VnbD
z`qcYKkMoV!Jk347*JA&oU;JRrm*EG#iTK{b*-t(e^gHJVLHE(Fb4B&F&Vg$1Rl+B}
zlEuURqWTiXzrfaj@tp(QqlIT~?^zFHXq(%5u?^FDZ37;$&HIqablh*i@iyAx8rtSk
z<nz94((YT+$@x8P+2LDL#`W@Y^(*-3`;vil;#Yrex=x?03A^l{;ll!%Cw1B4ThmS-
z=k+n4S*zuB!e^eV@Vd&kCXTuh9>@y1dX2ORoPV2`rS0Y2(jYzZO|2Ox<|55p_$bzn
z&9&(ls=yb3o_4(<u?%{mygbYO1=y^IPtATGKIP%*#i!0E?m-?W{cR_q&xu+1Cd55~
z^Vjnk-Yn<5yrancasK%KSpIiq<$o96Nz?qt!M}Qx`M;qZCGNr;9c85-)8>i0;s>}c
zn79kiM=*9g<+TUrTbK`YVQqpo!TwFGvw#<I#o@ZU#2fWx(7L7v&L@_c`2QefgAe(<
z^#Iq%K)+ntjIV7h>RIMRQv+E0LmKo4ccR=Fv+a?25chr{#wQ>T`Iz;ENzgftSVW&i
ze5L+D_EWQv9{J3*eGYX1&Sf8~_&W4Cr=S;bM{?RP<GV$ve5d!4?|bQbLoaE1=-T=I
z^*h8q5q3WXy|e9dc`tdrmwx_U()7>|w)An&kJ_>wdw#sO9L@VaZ24W*Bjdwn#255i
z|09074A1OPPYL)(s%|;H08Z+58O{i?bARB(PvA4#tZw-JPZz!s&_g#*Oz5*O^6>N;
zHx@hR?OudY^vA`<&*SuYT>s>|p6BuCU*4;}o<RG0SKs&gJNve5f7iau`aAvU6mTb@
zi`UmT^peke=@#xKO@=S2Zk_1&rQcQE=JB5X(~E95+B(8`jqTZ6&o9D;GLF=Gei~yp
zj&CI{FczSWuS5DjH_f~8cfpsl^I$(T5^F}@{#oYY9-kad-LFO&F*X{7c*8YK>KVYb
zod<aJ_R6y9=*y|G@pG8_dE`HnWedbSu>*ajlY3CGhJGU4bB*Hj@IQ_X&6>>rGV7!-
zWz7Yyb`EeZfc<Y~%@pJJ)U!*xf097^<5-@1?h-jH7a+<CT@jaYJrpsN@%kj5FW}tg
z(Kz?nk8__#<J@OI&V3$@bDw!mw>#XV>jFP)Eaz4yU-GPTLI=n>&-eD3ALV2GntJBQ
zdzAYvlsEO9t_%7wCa_<zX~@$~9?*O|9~`n$`IXye?diQVT<esz5te7DbN(*o4;|%f
z@vA}OHP-1lhhbjTlnorlBc|-YW6W;&@ZKTwXMdzJ4)7aSz?uDsMlNt46kL_%({x=b
z+ecj>m%c<f_(p9?zSX0gd&E-m%y{$#P0#Pe+B_`Imk*ibAI7*j_op_k&-vgK$wS|h
zbf63KK;AD44|HL<|1nE9`s*cXD<9HWUgBBDE_6<{9kvbFmOQkNPv0eAyGpMCXYR{^
zoDN?n*6lCHSP1(=46peXo2-k&Ux>5o*S+E%!r0_;_!a8dJ`-U636=$A<aM0a@DW}I
zaqXnXo{y#0xc<B3l*?Kfd>ixElrN^s{UGpCZg-%R`;!OEevWpGdtbD)fT68bS|`?K
zQnV^V3o9)F|4PY>8(N*x951ci(1J>%9bC^?-R^aG=YI2EA>Uj5T~3~?@po$cq0e?<
zZo#=ZVosaCzxh_-3drOdgS0EeMcSD<GX{#yc?~@J?H@B1qWmTfVr}dJ=qT|KbT3|f
z+N3e>6CoyX|6~u|80IP{3)cxsdZV8<V>8BP>f&R2oNlh4reD}RkY3h^=*M1N9N!ur
z^&hWknEpm{UB+vak?-A6zN{--d5ERd$&7;yf83MzC|vg_3+%zNFn@`=Ru*jAgBS7U
z>9@`L3dif*b1QZ79`V`MW!GG+>7hPHIsP~OsLufMy#)1W`jJEWeviImiuPsGW&6Ns
z_6umg&0JSk8-sUw7wrMtxQH>V_sbYZ)b8!1<J!_W?vnAS^2_=iuDc)?=^tU)|MB;b
z-#_QM1onv8Jpsr^`bCz7&t^tBxo>jMKmhVz+0TB_k9Ur9@chu0C;dGQn^ww$x)Ps$
z$Z50XxtZnBI&X(OUR!-QhjN*B=P-GOV`cUBy!Pv&2fyoPzcrfvhL}w!I-s8w9bQW7
zz`YL1N@x8uHZF9UHXMOW`0^UI?`lg+7+Ss3=tmCTe@P&HDn7V|r^=K5MVmfgXdm^Y
zubOVsr}B3ONz7W}<$2Taq~uf?ISai!AK55+*mi?*OB=HGECw(2#CZVgF+Sk)Z!_M3
zk7Pd+zL&i6{M)=+W#bk50GqBaAN@znm0Zfk-rRB4pR|qxT&vM`{Q&iY|1n;~+4dDr
zy}NKtUw|C(YmQ~Q!0W|{|9bp|{(Fth?|u637%6AA|GxkB_*W<^{mGX1{M)b_+mDuo
z{YI*cj72O1XtrEZ2He{^Vi`_b8Sk?Uzx@vDD!UAs`(5Qbd1&X{`$S#&z6c=RD<9PM
zRi;PmV?1PCuunOOYwm*^g|ad3_+Td)n*xXD;&0OL*{>yjfblbUABPO?&wL3GaU)~z
zaq7G1KM2fl9A~Lr^Xp{&L!Qs`9G`oC%=jd0uQv8YgJ1kr{0`$u+8yKT1IYhCg78s&
z$Nv%JvtszNQ8-@|XS2+3X6Kvhhj2Y2ZyCzX?<%DIA2!eS{~cme?*Dj6W3-NQ=Q`_q
z)uSBkYHnbCf)IK7W;;W14vpx6?-CAWo`m>k_nw%x*Gt}ik(D=|S8?Cffz;TG<;C~&
ziIaV2#)fUAJ9z%dve71Z-{(W*;k)Ycyh(6oe4C){aqruJ)&1HnOP%k0uNgXiNY<^$
z2RzdzCgIxqPWuS#U&UIj%mr9)96Q2iy7*iL>8Ka<P4Bs|`(6=8UuK@%qk18y$G+F}
z7_Qg7P3d~qKE&bk2h69ESbKW|-<>;Ej{O8v`TjND;T($ZE@0gBOFVne-lxPq4dvY8
zt3r&0?H_`z?YHGmK~A=eKGS!a^iihAyG*0_9uU5X@e=wH*kesQ=M?z%#1Hh|<vrd>
z`8!L;8V}Yr4t&Sbd5`rMrhS<)lGkzU59ak;*p+LHkne;4Qf|tpA(Ot2GTp#;#PB@t
z2F?w9{FaHzOVIAP_Q7W0yAADTi0k6a1+-TOZMX~V8+bVfhrZKp-|IlE%5E1w`?l>D
zvie!>+l9Z_v>AOZ>`WhF%&5Y%QRdsucUSS<6X0ckC;fKhUft7-m@fBt_EUv4&~XU#
zGkn~4fx7KNUA3s~C>OD4$kpV55B|=q)!jgQjl!9?wBKCp;eCL1P}$7;L=EJ?UlJIP
z+=%lvY+QPPz6=|SK3J0{KEp24d)lQfWf$9Dns||64~<!g8nY)Q4%^RVI@llbIj-#W
z`~N~iozi!!zWC{*oqzc5Zv#jE^|w_ur{(#sb7AQ#u#cP-V)HxEOI)clI%14uW19KC
zhI~5*?aJ=iIXQ-NlH5I3mel1BO}s@uTO0@P1YsPN(C-N(Uh=iY@NGHvYvd*Lb3Y#N
zpCcad!CdSQgxx-i`!3uk%5&O&#p`Et<eKj=Jb-VSb}{yu@$HPn7~?nX=r?7rO)vX}
zx=?qChh%T!o)h5r<;Rb{hPsq-F=Wg8fws-JLvQ%>>f=g>{_u-8tLPWVa}n(W|DdnN
z*>BTVxL(0{YW&8mC1YGfJNN?mBJVE9n}@#0LA&ws{XpdL>t7)bU{2kxZK=0+{Bx0?
znFnOP=P&iaxd{5|6Yv?tZ+?5^yx)Ga9(DWkZ$VeA<MLU`ulOtxeXxVJ!FJ<tPu=jq
zW3tYafp_p-lzv0u&qMiK!g2oMF*}z+z0F`e^l?25`j33u_ttKXSC9wmlXe<In}DYa
zbXiAXeRF>p(_!7FknN9Y&-va8>Ud7Ro3HE5FEKsS@S8!JM)ZaZ=)HbC+AaG>-)!hk
zI@UdgQzp_l1!yxWr$%M_fa^uhf#31j3d%QhL)9xHf4KQ>&~FqE-5#;>4P?C8eUxRa
zH}U4^P0UwxMEL=^mV-J^?P0D~zKN=z_zYt>dFeB-JNade5Bfu&m+6y&L)+p0=AlR{
zehS|r9`nQ*>T{2EO*c5!%Sogoz6v~L=+j5pHG1(+*nsn5)v*gWmZO|~G;lt)L!~hf
z<8L-b>G$*DV_kTk=ftDf1B3B>yZS8hCLTT^<1FfMfWCuw=%*0+pa)}@_zd!(&lIqZ
zfuk>SENgWQa2$!a0;e-;3&}5uy$e{E)DQLkx2PY&#QhjUsf-sc*R^Wi!%w>I53EOi
z>k&Ie-c_`}&Cl{u9=`9hhV?xc{hCdSegJ6?Fu(h}H26oC(gHY-hk9}>i8?jk4p8~5
z3!B#{*ua*p3v|XR+V=tIHHxxvPu~|=xJC>~#nTh0qwIdw$M%dEXwMLkF<*bw3)XQH
z{UJ-fJ>dDqKgScq<9nqk-^0C+-!BF92LN+q-TY<hl^6;+Lq(?_bI!qib>e@(u}tI<
z|C6#}PZDfIocN#eRN+3u|I{wBE=U_7Kl)w`e2=lujsxvGjLf$SdT>wbNvxH(_u^;b
z3oI+XRmXmpb&xuf;iT^UMEr$*Qm;H~K;Gv7jeCb^XUcdO-ynhhTXNhFwDEfxy!LhG
zx500g{utkSw6b0GSERdvb~uT$qMw!c?l@Pp&BV8LxmTx)Hh|n1<Vt<x`bp$1@ey>$
z&+LE4_pIYh`?Bh|d^o;WV!mY{wqYBjZ7`0{uucCQX@g=Leru2ZiMEJy)YgnD(DozW
zbVz^mqHLVvv-~DL*5LiUoYAwD?+&uPpe@ku|HOU~<@A2%VHm$}p!7n@;&rLBrcwI_
z2Xb@9I&IZx2V(Q8D=-$%*%L(BDbvMxmiU~i546p@BA%)j7xl8*Q!fFP=PNLFr(AiC
zi*Kqjy%WEp?G^B6>o=6~06OP*%QuGar|Wm|pvx+Gm(rHY(eLz_ci4lF&-B;+osrG&
zpLflTA7FaM!RPUf!dEm8eruV}0@>CBsDJ47i1eq7_gE`TOb46`SW`9w^Ya-J>wyzK
z#%$pEJ(9$m=yQ2J&>52W4_yBTVh`Wx!<>R}BA&VOy}owDO2WPPX2D1oV`IFNMmUl8
zux$eMMfhcW`@zX|K8&%!nhIPOP+yF>IDULu%Xb3Lvz7r5U8F7^#F+)WW*ezOUF3P{
zq7!n3<_tkUjduX>o^_12M_I}tk8)+b26pSm_L!B|50O`CFFL#c{1oEfG_kgmF-_Ax
zpnC2H5A|pM^cnwEnR>pC`mk*|q5kT?XBY>V#&L(V-AY}vbb1DIbC8E0b;>gNuvW!-
z{|Uw*gvRIb{Y-qrN%ke7PHbH8#fJ#*Hz9*_8OAzWhB$R#{h=OS;M`5G#h>9Ps29^G
zAU@#w$97FyuCb2Iyv66>SK_lsGZJOw__PaYP$ul#bk27Hj~HNl3GqPgsW-pDsrGc)
zhBW_9Ya948`ycXOO1akd9$kaHrXKKbjwk86_TDf08{KJRt~<>>3pxG!KWA-h>+V+A
z$CgLN=CJh{oMFdjqQsA+uGE=r75ZSGnHiVid*IrizT8zqzfHH@>F8Tw+qZnDlK7^j
zv3<a~EMLB()xW&QTKkRP<a_7=d_!iqS(A8ZVEP+T7>9Mi=J<BZ`I8u5pMqWA_>AxT
zFCOuo|K+2;^NF0iHph+6A@q$k&|hF+&O`%qiw*2oV&EmE2KJvFpVRJr?_sV_V)#kK
z2CiS*Snz4g9WWP_{Rb=;_LpPd3g$$NA1C|ayZC^p`~N%-zRz5Wa-i?N4gXH|n~^xV
z0RQlfv6JP9AAmK0V*pXVl;yA<AHq8EU64U|4`2>pC7?e(B=Hi*Mu0y=zk_+y$!GmN
z-nWqX721x>qac^_tH1mmbb%hotIg++AARGG=m%?{Gwvl$VjdS}UkAP4f!>VUSbxBG
z$z_e=Jm%%{eKMT!aQ^g3%mtY?2k%e8m&`YzFb_tX^e6DW9T(#<JRj?1o+vl^oAW1b
zgZ(ITVc`50&LJU(Hk*sFM-}}X_dovz@ZhBlQ+V9J0zA`oC6i}Ib>3jk3&XwmBJq%G
z>+Qtcvh&&Fv?rNf#%cV{!$9$=ckbWY^WCsV;ZIxPPfz0AurH!)UxMy<FRTmig`L2A
zVJGok*eSdh_6FVy`vu+$`(=5SzrZKh-_Q=e#4y+v`{?*i8hn-Yo1s7MMSu7e>-}l8
zd#1|?T*-KSgx~Nen}&W3d=Ikk1N6o>?u(Or+OL#+1~MPUq8#`i+K52<V>#YSqd)S!
zw1?DpJ_Fw=r|<Ogt`6}0HixVwGk!ro=6!<SPfqDz`d`L}AY(r8v+#Uuq?tP(k#@bX
z=QFfvsE2p%Kc;K5S!;%79ZJ&590oR{Eg5TM9NpX4atwVO?-g-uITB;bp@H-J<(tYV
zFVe{wIZTgnwVaWI`5pTX69fD0xtHf)F_v-s4JhMp$Os@_yNqj$c}N34f0?nDxD%jD
zdfY$$b)?Utb8U+IUmga{jz9lMom3B|ZPysn+cU8<lqtSy*6Ps5NMFV0k>BaY8)+AR
z7cFqn0v9cC(E=AOaM1!6EpX8S7cFqn0v9cC(E=AOaM1$)-&sKR^<zI)JJ$@33~9r2
ztOI-=%C#1|{|f7*>Gjc(&iStCSl_uC>!U;EnN$bYV`NRmK9j;(6MQD&<GLl*C1gDt
z&s%&Q>2GL%^()CIN13&(BToE-Z5_YHx<vne&m})~3I6q$HBHeez~>8)fwd>OZ`XUS
zK|N%iUvLea>m(oN_hkWdxZVQDb(yZL=RCi`Gn^B^p(2m?+CPXjM*p5W`CNx<F<5iq
zT3L|mh2>a-1de<;?)Wx8_DM;a#0T2~coy>aJm*ZGMRsyc6*}-4KlU)oz7X0&a03J9
zf2BA--{V+j);v!x#x?R|8oV2HgIqI>ta<jsckpxYEiHZrpJ$X`%J1M~KXu*>)B*3j
zv|WR99$822+^@;=B6?ZpUIQDOZ>8%x_e)N?9#Mai_VmK@dB_*ns0XaA+H2UEYeIrY
z9dON4uB(Q$alf}*yIL2bb1v3tsk0y7|MKlQ$@M76^jD2EwvLa4t@HLAgibE(_v^hl
z2YuLs8Q*TV`xzlS?Nf{MWSy=P=c&nh9oD<$d+gm0q`t>~oyvrt9ry&+EfeG82jrZQ
z%gmY@%Ryay&RD7Mh2Td$ui=^~>gWL0z^-80>~twxp!{eP+-uRdY}d#x{&Qu=jqF?B
zO?JS@zUI%B-EL&d^R&KfQe|ZO|6JKsM)q~@rgz-PeiL>5XW82|viWWT_X4y1f0)k@
zJ#~dPFME9FVh`UVXOqj}Ge?|&@y7?SkC6Vwwp@lf_R{#R{QfAb#qpkX>+m^ee3-QD
z8l<)N39LU?;$HZn7j^k6&OXC)lD1lWOIq+^3$$I}PT?QdjG5k_kG1oh+&$$y!wT(<
zv5-1FfM>R#AIS-fZySACI<Bx?d=0W~Tyd=Kkk5R(jNBtm``ET?5P!%&-0BuL?UizU
z@p0nkJGkGBey-2?%=-RFd46g0_v7phNuzP?QBVGzNGCLH!%q9Swm*?>b<av0_oVGp
zcjx-HUwdTC%aRfH$cWqW2eQgvb$#2<!6*I!d;4%U*QfE!r=324J`A=xz;e4hXAAUy
zIGWb^nXLSldGbr?tTJG46K^}OZ~LC;jJ=4!As>lPCl*)qcosAa^?~(u>=DQJ%}soJ
z#QS}7o-e!)>9?IIYWw{?{^!1h>u<eS)V9rk<;#D7?EkFEdG0?EKhGhKKJaBc7rlJj
zn^myGw(jz+L(yM8`-$ke6FI~8L@&Yqq@1hqto5oJs_?$ym;6KD9EI|x&g`v8f6tly
z1a%-Z{RsUtzVyz$$*bSF{|EA%>Ye*vkmn{o2TxG(tBW-@5XM5Su}Qp{<<`^%o1>xF
zoR-+i!cx-s14&>_G%8T|ag)t{pCKE0_XXDmqczR-kytjHv#Nfj$f<7(t_n@Eca9Tj
zTIIppJIA>%;>F(=37K2q&DFZ_N)fm++!UK+Zy+faGx-SK-T)t6>y?MQ8(YN?vDTR6
zFXf9g1nZl6s4n#2TI?3YZ*6^TC_JgPurVrEPEB;J;MG3n2AJA#jo^ckNJD*1FjgOK
zn$#Fw7jCW<v=eF#^`M7qVxd@JG}asn8smdw6*@ltymD53qCR4<j#FO~mP=#T)<WDj
z5piGCKyNyWBfT+fR5j&U(^6lvI#%BpavCF3Np^xQwe{gijVZe~MoI*4`0X9!D2K({
zdWzJVdhq5?TvQz}rUmoTW5MP^Ti$g+qo2{k-Z{>?P_>lZl-J%ljx~u_9&uAw8B-bk
zaHp1=f5$SH1rE2E`j0l(OsZ{)7MWUeoI9IBt&tEaq}C;Cb0``KH$_7;#R&K_F6xeB
zRgP<DadBObTWJZnCVxXXyt*agt_;>UgrvsF7i>Vy)~=_paKl=IM{Nh!YZj4)^$rt<
znw!JTHX{Tt^kagLhML!gn%z5>E@FOn+_`8`ky{>YXmA@>RW`0_uB>mWj}=TX2{n(D
z7`=BFFTPzEsE@(bH?4BV72ObZ11Q2oH`dxzU+a#mYcX=DPc+n|UW;}FJB8MUnqq1x
zDSt!@k0j%wMMX3WB~k*;u#{hsUNl#m`{0e{q8#lP(hBF-!@$vcwi97!3c?xjTL}Z&
zYu=Z&#OlJ$^`DRyHPf9JjMmq<zz-Tgs?o157K_-5)cUCjHZ_G~EOGrOLT-Jyx@9Hm
zukhw^wXP&{G`Ta=HIfwVSp61-npVZ?9H(OW@+FgyWXYY&CE=3A%j9B8v1uRU8d^mF
z)73Y%m_`oHa#TH>$tkO;2}O9JzdORNW?>LZg3Yn|U_%Oddl-)5E(tX^2Ag0fc!>Gk
z5^j-7xdWxTJzQJAvfjv?7p!%chSs!%qQ<Z9YznHy4E>gHb9H@fZOB;JahTr9qU2l0
zH@ZPL779kfBH&h3PjeF#T4tPYf%+!X-P#yw2sJ`0h+ce~DyBf}G`VOptPJNEG+<mb
z(~>hm7&O4vn&XTf*U(T~#6P1&LiPGsC_2Y+N{UO|d&WiYb;p^8%Y0X|>{?-_)j{u-
zg?EITLWQ>nV>PHIQ%}r)Dg=0qG-yD!BE?=kmIj+vvC=G)+|P7H9ruPwR4`S)^xF(N
zsfGNL=F7H&mAia>Bm^6vl?)oNAQoJOYg}2X@iyQZ8d_*O(u`p%7L?8B6>v2yJK{~O
zxupp`jHzGxdo&h|6^x5cpp8u`$Dz;ichCG=m);9VEqOoA0LOJ_$C_`R9jm>0cF?VB
z4y~Lsn#zrfj=q`M&z=;#dG;hyW3?{Z;~ZoJN;a;cHieu7c>|o;W;}57O6bVO?M9np
z1+nUhZnOsf!V}%v3GV%CgUu*~JI5_+Ml>vnG>2p17z|VtMc)}JszHoHnxf|LIs~ZV
z2@{1k)?5?~Ls&|3L2#m54QVdL)l7!CU{Ot|p&@!twC3K4Zp{>6sy&z{veZm2S`~_w
z#bV9%)h)45!FU#K{Dg^a6WME~^g)ez#ZS4nFD`GEeQ?b}P>QuQ!!Tj@2Dbo$XS>Dj
z_1C+xDeld4a5>j4ob1lzttCvh1maPOxo(6bI5gFQrYRHLLeK5w31C4PIXqG4Dnd~k
z3nmmbgkjfEdAJdYLj@>lPo4=AX1Sl7FpGY&GTiJI(6IF|OYtm#*{HH21ZRXr+}?QO
z1Q%6=?iZa!d0l-&Z9%O0p89(sp?;-XFbdVYuD+=@yiW3^Clu8MqjeBgFg{u{XS{nO
zJOY2lUmp#dyD&4KrHR5#4PivKIj*hk0_!%_Kw_}f!Z^fgSYSfZy!E%%7L1QokDoA$
zS~r4g67ngyr+D&|dndqi<`hicP&j$Qq#}&OY6^POZGyXDgL_Z$M0d(Wck;a=1}e^R
z8}FG6cS3dXa>~84(%FZbYT&S|K}e|?TAT7nphIhmFvx+HMa?0MylI&l&;`14=D-9K
z#1H16&S#~XinJ71LvpW~MJbVH>4fKpRt8%d(CN?m<R@okw=Bek5D2qTZVt(BW;Lec
z;*{cIckylMkYfUp3}btl7W5XtUHwV;oIPs(;_~GmU9!Ms>YHclUyOGUGU{Uup_^}Q
zstvWeVf4F*D~KC{l-LrDtp`0;HxaSreriw{Y^Yz=G}CPet;9?s60EJoAf>RmepOv;
zraL**I160>V(-deV|~N=nQmjaDIARiYeH}slvbq8o>V7!SBGoYLz~Ij*#k2>7OZXv
zxeO7S#hlT_qk%RlB^=hJ!{M0GXsHdtatC6BMno{gdSRM8`exfJzdPfU(Kj!{kR;8-
zu&JTgtqC`vTupOEPlZ}_z)J)cj!9Na7SOG)oijRCJsR=0mpEQjH2UVEqMi}F5GKe7
z=|D*Lkj`d+GrefK_ziHzl(CiJaP0kQXgDW{nPJD;S`5FUuuIdba5x%r*A_{?qUhO^
zjC`4tq9FQ1HzQXvj)UX4g*T(8^!V}A;>j2QVURRvz#>F6Mi$erPD=Z>?M^*C{UijV
zP-~ISM$kW+dpkYJ9A`oUJJ6gLLbPmlF+K>duE#(ji1A!BS{VzkHbbhKx|XKZ=!%y&
z2b-cRL(PQ?nrbjS(^;<LVA_hgw&Spyfj?p5)hr!1hDm0Ofl+uvtqggj++oC1Z(nYE
zbdD=boS!+sj<uP9<8v9_rpD(OlH6>2d&ij~QVm~2c$FO{JIg{bj8|7-;(~vOEe&og
zOhY4Os~N-199KJ&mN!4wwNNi|Z~yReoDjtP8`s3_^Z@BwP#9F)y{tKN#gxP|h1(cx
zK;P1cL2e@qiNygUcU;7f%Wt30?9tB<WTr=l)+AFjuRIQSb>4+OKU^C!gCLF}Q38yY
z_!s%N&g|`fXB-Bh`oAb5y<}ZjN7Ke`O^Dxip2%|4G{Bv8q}9}d`B+P{tg%ploo}_&
zMr7_te)Q)lLxL_hx5!M9qri!r|24t*BC!nOYD_ud+0j&9ls9QoX_5RlbJ|o<7Jm%>
z9z^%aGfPTuDmH&+mg09W*;qf(ru6)%CfwZI5{bc;YF5)P*EOSgx|n80ksahUVZ0s0
z3{YmC%^^-v<);`-4M|^JAB{4!*J6^x(KqbdQZ$Y&m*rg-tdF@Zm=85@0%oSZMo-Sb
zix3S~HDHt%Zk#!JiY<uf8LnAv4Lut#obp#_x-n-!VWCUeoQJ3W$5>Wyn2*9&G4Vi4
zf-!ODvJEkPebZWWE^w&&DCV8?cuc2hb`tT6BF_+d8Do9NX%4kS(UH_PE2<iCB29H1
zBPWe%47OG_hicYVVuo2MlTA$gYU-?eIN`8a+A;YQq{ir~w^p@V-{fKxyov#{NT$w8
zNM%HR#vW9iS!Bp`8`z=NMWocxy{QNKVme)j6EmmWOpI$}dWx|JOAlwLw+jcVSEN3I
zhJ;ug4K<+2Q4M1vS*u8SD9mZXhU9}8N{!1u=0CCT>`{e<W9l(ZYC+57<R0^kdp<sz
zQxf@^Nr!1?(P+J`eh2N=u%ot3o*0nE!eO{vh%>_sxohj2V=Y1S)oIZjXfOlHvE)8P
zi5_=0t!@ghYjT$@yVW(*GsG~PkIGRR7h|YN14nj}7=I9(WL@LEhE<jy!_uiG({7qx
zIwM$JQyVgiXCM~08jj_QmN6eTN34fn+@kSjT{J3jg=-$XV(cZ1MjHelYe>_HSZ8j9
zkN1;mLu)6sptGtqj%kA*qTr-)wd3qEf#bmoa>}&Q1!cFCO)Fe5V{%Dh$@KYUg)^p=
zmlc*zE1Oq5zr1wXyvdWPd20SU8U6IKb@iB?v(YW#6pzE3K?ClLtZEL{Vls@yJmY`T
zaWk?@U#|2)1D1tq3hxS4FB2avGz%$kM2JAuW)iJ<kWp=%J2RfFOE2#^cP(?V^e29t
z?o^;J)TG+tzu>8ZVWM@x)gj|_Mjq*)Em?fWLg8D8O2K{kqQ%P=kj5WI0pdT*hvCRz
z9cST!<xttRX6e2773goQ>Tsl<reLWuOZ*WNu`xWJnr*4uLKq{{OteF0Dv(q$=-FZ_
z!nF&ZG6u`!w|2$)c2l&n21|HYdgSt8Qxszvio(4#Pg`Ex(={ur*)JQq+)Mva$pBzD
zBhB?qv04m<nqtk=sinCdgR061`V$$lSUD{bP6Q<%8Rj6^GRiVv3|*j$S@z;Rn?hxz
z#jG>R4HO1my6Z{?RHKiER-*^yNY`L)MGlr$S2l-?qM)<;gkqR+gGX+RT)E_sj%#oA
zVW?x|%knAGaVV$4LpHpke+kxFU6|#%=K5I3gP^{~16b13vayUiBe66i_!?I;N>d1a
zxUUam2~Evm%Ml4Tn4t;i2(QAoE-F=+N{4&atohmTVv*jn@-XlyE|ULd-h_dMP@2qR
z2xp8Aspl#`+*jhD8G<7}JYiu_rw2>pO#hJ-cD|7@OBiq`2ZnTFckz<tw=TY8*#Orq
ztZ>(dq8l($D%6mO1&QFwl~@n13$@m^G)AzvWah^+-SOk1<CzAnwrn})t%VZV?dmdm
zycpLxdr5)y|67-u6m-v;Sh#sTJ2`RSUicf_vib9wpwKhM(78`9>}%ac3qG=75!q`)
z)h#;sp6IS@4mV=)2N{)QrxH6AYD6ilForH%rcg(oh595)`*-8hF4o_$K=0m(*_T!%
zm7Td{@zUik`ct_ua$s7yNY{f2Fj!7n%bs*mYWxJ5{IPbB0s-1>#tcz#2G60lv!E4g
z`w0A80mR%M3(6)YT2G^2Fhk#UIkTSX?>N83b;0A^$$hxK8}Ja|cEDEw6M*<WgmVgT
zIN<Upx|79#`A>EyD*z8|?@rbMMn2!2+yr<Ua5vzQFG3Dr=~Law(}24H^Df2M;Y;1g
z0>C(61>pXtksh#N7t#Y3JlCD<03811?&J}`BVXxGUI2XctKG>Fh?2Em>rT!FOmuW7
zSMdJp-N_Ary8)j9eDxdM$>#xw?dwh^04u%){VxL_;BdfJz+%AsZ+9n`0PY5i@P2=H
zatq+AfE|E&2arGDF2J*Zoq%}*q1Si2lP+K}U@72yz$Jip1J(h$e}{4a9tYgb`{!W?
zzyRQBzzAU8AjfG3EC4(PSOJ*(J){Sm2)GIGZou7uV_)b_9_IZ^-N`e6#ed(O95~o<
zo&p>T*zm*d<b1$=fGYqGAA&sq+wrl$rvNwn6YK$a=4I3;;IMy&Jpr8~D97a}FJJ($
z<j38~D!}EhbSGN@JCAiIw*y`P+z%M|Nq6!%V8>6plji_e97lcRL!W;^eE?Rxj`V=T
zx}ZN`-O29cUcil~x|0V1-P7I4Q-GU))t$_}!g0?1x;r@$aNC>EAF%yQcd{0+_CLCl
z8v&02?gHHZ7SaR04R{K0AU;BsI|SwVJ?sa#{131n;O75?{Q!&qi2MPU0PY5?dI$Cc
z+z)sLFuxo28w&ja#{wQpB7eZ)PBK{wxWSi9ZUo%!PbPN(J`Z>h@KwN5fF(J}WbQEN
z4LBCC7BA+{2i$lG(gPj@+yMA?UNZR<VE%w)@_E1j;H!Yg2PKmi0JmSBOpdq`{Q1e`
zY{0|AlF1c>S0<A&z~xsZliL6{0`3EhT$4;51AGebZNNi-!>&R;fF*#P*J9%W;MnVs
z9`FL-cEHmklF9vm9rzgMalkDjlgWI%p?DUs7;qvscvJv7qm#)xz^XCH<R-vF*C&&^
z0hf<YCJzA~1UwD+c0n?kHyrhKLo!(axMCvG1D*k_1Ds!o^nk;PkRC7wcnI(?V1oC{
zV83gSKi~+!4R@mafWz)W`2k}eh5Z1}eGK*kJaiB22RM5L><4%T@B(1uUX=e@xG`V}
z;P8*5{D2*RF+ew%Otu5As7@w30e98l#bm&<fce;PHGdV#54fo=nOp+6<i2Dw4%oUn
znd|_39`FcYRRhuiZfioi5oo7jqyrp*55_JB+z?A9TLI7EqiNd#o%>;Lzyci9b{sG-
zo=lztJo1;xr27Hn^XX(V0JsIP3UEJQE8qpdEr8oUgZc*S1Uv>fe-r8(@DSjz528Gu
zMR@^>A5JD00d@j50A2vx2)N`C*bVSB;PZfEAB7yiO@QYB^V?7kZ0y<i7|H<{*^2T5
z&fkXm1MC2d15SJ#_5<7n*a?`6kFuNsJPVlXLjHEtAK=|Mu)PFu^Hb0Vuy_aB0pRxC
z@B_e!&p{60Q-J$P|1#_XxB~DTU<5FK6!ZZs06YvB0K^`k<lTS;fDyoBfLj0)Uxj@D
zJHCc;0hV;YK7bp)4*TG7X5<^t2e9Ous2{)!fHA<0`_P^Moo^vM;C{fvfM)<t0Y3E|
zlxqy)=zg?oz`GBiT?3x}F6_el?<JF)0pI?9GPxJ96CWTv2za~`=>Zr01KPz{w2MP1
z2cY{;XcvGL|BCd04S;dLlGhMd01pCo0(P80y8<je344x1e+gI&$REO`{CuBS>g2Y5
z(0ARyk%B`ravDB|eoX1)n}~m#fD0(j1?2TU;3@!}vcc|-+?_e|w)*dQ{k2!v1IWwi
zwSdRLlS_pD5T2Y3_;(Qa2ytbD^FPME1DD(IZv;Nh`n=*BfrooLd-1Om`29XylnpN4
zammhp{)X3IV@9MO#=pC_ASMG^dYvH){S43v&|3{Xup@70{}mqkK*%j^Lmz77FWE6*
z=cWGEwET(0Z$%$q(o6n#d(tlgy#jPCkI+Bnp*MiO9rSH}2q+sI*)e$MApf&z`I|u>
z_yqb2kA90i>Gy(O40@?aZ}i)oPJfvBW305#(5rR~+<BS*%Z85Xcg}$R>K9;FRz%t0
zcy8H_z|Ohzw%(j`gYUK1O?}ah!;n6LvC~=bgD>IVF>&XO{!fUY0-#Dj4`58S-{f<|
zx8vHK*OYG^zU}JAukt_l`fERV<(SkxWmSRa@U!R-jV!UbzbvhD9Q6Ghmx0&TS(PD6
zowbAR{x!xMCVe|}p1-r)zv8vm2MfIu^bLQ5{@kP&`IVmZ3D6Uut4+l}y*71n5O@Bz
zJ6U4n8=Kx{1h|mtf<AmVY)<;T!AIP(9S`U3{A{lOL)5_d-F)y&#F$cLbVA39oeK>I
z{kazOz#fccaE&s$3y@I!ANcve^BVa4a^T6cP5HMQy!cVAr%d}m-;Z=k7oENIW1tsf
zY+Gl_lz={qcHZW{%i0X*h&!!&F=jFH#b#?f@`u4c#(o83CqoyT-Rhy2fL;vxQ=ar8
zrL!z}Y~bt#J-fUOz;^(Dx5{0vcGw8~S>T5od_KpTl=GD0z4qbtKH$%Q--~Bnhk-v0
z{2?Q!)3;;z&Z{FvG1AX~z6E3a{e~{(*6<;AAJ`9l0ml9nhAwtr;wkq;(3gPj8oJo!
z77u-q(j{hUeEN`w-T-<P()UH*40;6g5|4a!MbU3B=o{1NC4aB{!=P^ioo$qU##mh8
z$^Q)KPl4WBy}C#;@Dj{bKtBxsK>Bvyj$u28&f7Y~{~sor(}u<1S@KQjh;{`Y6T==c
znUKB&bk2j08{acAC}!xauL$TP@BxbkT+`=2sy@F7_z3XW{7<}Tht279yFqs`KhnC%
zU!v(cfnNgraFb5z%s)S^PXhFc?{+7Tnf!zvHDs}=gZbwL&|ful$+yKrcR}Bec~->8
zkNbAy@4Vb^qB_eP06h=$r~+d%qxT^rzy-Yu^!!fD3yl1;{vAa-3+HW}xK2Ar%Gd~=
z<KR&p+WkAm?i`~^kiHA_ZJ48JyOA<1R~>27gP<P<-8FTR@Bg%kjhtH_!<??c=-z=i
zaLdjG{=01)xB$9~Io@oeoA}G^p0ba~!<ZQK`Gzj}dSmBo(5paK+nBo64$noJ6`*(g
z1LkNZ|IWO!9h-bRKjZV)rDJCtJf)aV9y2_~ep*44(GL0<%rl3h?ZPjP_{(+_>>Qty
zgANNGfH;MJ2f>s05&V|rpEo!$s%*#h+?`M6&fEG#uKz2hXLCV11HO%zi!L{O9pHN+
zcjx1|{x&0ww#>&mz`mo1T}B_*k6_I@;CjOTR}k||J)5$=VT?sO*BMHFmbSI8jE%?G
znmTg*A&&X1)CF`zKe9P@=OfVZ;avZnMn~qq1$+m8o{FvcA@%d!z*qcBsvk9W^7NyJ
znE$_G9&3ES_?iD}q9FA<4f^rdQezXTYwy@359=5Om|veV<u>JmlhVjie$dbSTi?Ed
zZ`C<@iBvl@{k*nA7c%NVcQ9{fe~fxe$CiER*s>Ws&tpzs2Nv*%zj?=3dqK~|TwnTP
z8zUB_bvz9Eh&M2&H+k58_;0Mgp8>u7m%Ybt7g-L(8Vu?Arj9!=E8DT(xAQwb{|jk<
zEe6kKtSe|+lycg(NINY7{a_z-)^7y#3!pE;HOiR(VXfayz!zhkqSe^n*iQ$il)D@B
zO<2FswkY-IZHtFM-^=w4Z#%jxZJX1epZ!hBuf?|h1!;QTK-BNQW4*%YCGr;<vZ;U2
z&w}oH=-$4sLg~H5DC%Dadcl8S{l=62BOdviK(7N`<9~;5$5lJ8^qUSq$`AT*tk1Zn
ze70^Eux4o2L!|#!=O(c09ctGE@B!e9jZc_%^KiP{4%WMtyq&U(vAf4EF6fJ}4y1jy
z*u~rD20&i{`gU(zIF*)P1^Tgb-N{aGy)>oianNIbM4#-fcO7i8-0h&p|Ah6tT->P7
z=QutQz;btjUWfH1$D}X*3oZ9?;Fn;%X%l#mPRivSSDyoYKj?jpMTSGpA<)klyJ^37
zK=P$trJ!?tYNC-ZcJYo8?*_g7UFfZ#?|m2gcF^~Oe%Q!2{-A?Y=D#2G+FYyy7`l{C
z-Q974I}ZA8(2pB>s^5i2$wY@TxJJ1GYinl=kLh>Ur|V_})*uTm!P=6cOH9<^q*DUi
zY|xK@o-nrWK+GSq^NIyq^S538_~0i7JvnguWuG75kG%H!&wqCOCqFflBIX-Iy4F0b
z%^11T7HwN#oo)ktKj^a!-Mt-pGTmO_Uj<(KN)w~CuO$62=vxLruGg1TFzIJNKXMt?
z3cS90JYC*_`DjCzV-3ROD|!VDS@NF<`bN+r9=f*=Sp@nq(2La<Wqz)Wh50vtehO=m
zIvy}>tv;RqX3!%;u%_hIzcEeU3;MueSferdOZsY$euqKd0J_E?Y3ttDd<OJ=pdaz1
z*CD2qZy?rwYp+bzi}<v+UbvRL3v`vA&-sfBS@VHE1^jLX&$7W=d~}0(Tk~_Szf`=9
zby^3Wx|vva#5Lpoy;`Sn;12`8*;{5cI&Ibtdg*Me`+4a)*(1FZ^o}{u*&E-UNZTv{
z`q{ZyxAUgg2{O~;tHaLnvXo84r@S_CLC>9s^)2#h9J$A1^8n~~gWh52;xqRto#n0q
z{WRzs4c)EOa<?+y^4@Jty|#nC4fG04$GMDmF18=^=Rx0Y=u+2e7JP0V?H}}#`S4X^
z7t^-Ow~pR6>T%cqWab)0F4o*zZ$W!AHZpS>9SAeNjRk$%Lg?b5&)+(5+hvarc;eD0
z^ZXcs{LI_FmxF(A1=cD(x_{VXvl!^dL0@j#p~>%+be(Mjec&Rj4SMqPYiCb=_JLk}
zJK~au?$rl#+LS)z=QD*vcVNx14}J{OQv9_2FjQRUV&w19-#gYQ0sR!{y9{0Ge3hqs
z%R#SOf;CcOdlRQTbHo_v8<zGSM_kC<2Kr&pha3B(+LQl96THc@A3U9RX8QfSt$F@!
zp7_pZAs4XbuWLuzhutfhvYdQIayOm@<Y8XScAK+f%Ff9-0qI;x=d+Ul*8076^Xr6~
zbUst5s6_lXdM+vBf};QTGFW6N;Io#z8q^cz&l}t^1M`jkJ0I^qZ|k=HISppXjdC`E
zZ+9KmZgFkf*vCEg+(kL{ShF^Cu{Rc2(UQzM$wANyK&Rg$y;}haisrlud@1m@9v1`e
z0?%hVwZK1xYw%0kf$eJ4bP@}P<2lZ&9+}x|38kQ)0)3;AA+gxI?shlm75DW`Zv}lX
z=-WK$p+Krk+d+3%qpvgc;wUJzRR{2|0>8zR&h`N;^AXS&HKh8^eD<Bhp9Vex{Bn~n
zf0@d2@Vsd+@ES)X=G!>JbS~&)8zE2Y*#D!!V#8A4D<YZWk9pfJdA#49ufKNeCuU5#
z0z8|*v&po(CHR)BlpzNExiyHX25;Jj233}E8|aIosc}h%f5-JZ$LY9)I_(2}cr0a`
z0BuA3Vc?Ge-+*h>Yie!f6z~NtslG@2$Fu@t)7;_kLC{-GI;l&$F75(17W7v^uQK|k
z+ao$x4yLGc1$c(9>s#kK&`*JW&g9{4P@UtzA8bV|FtUsNcnH9<YzKbCCsHwFiT@FU
z?*P6O&%HGE1Xe+g3w}QTI|zIo<~b;P!nb3@&g<rFy*B5keo>M#&wwXyQ_ANeHL3%j
z6>bDR0v_6p&mmZ*5x~Dne$`FJGwP(I&jx+T!@ZAzncoV~SAfoI%H{eluVcX9-3xv*
z@XLX>eID1i$iEBtjlJNX2Yz3c9O`up_zvLr;u`siPwOyCZ1pzivmZ$&2YSc$^R^E5
ze=1#{!|@z*?B`PB0uwuRV8A>|K|cn%wtw;AjP?(D>0jZwpRt|k<CdBR&h)LI*FBo@
z7bD*@_TCP9$re2SGG#FIa60{d(2s+D$k4@S?bw|1kAoh^bI47GE<T?z{{j6p=o>tA
z+a_r9;dmZ9|1msIRC<HfMKSQFfG;ul{M*!5Du8$JoU_A}*R*LJ2vMIp(6?+upXRj(
zI$k6fU)u!wrpHr$ozbVd;MooOz$Xy*OnTE-&D&b+N1@mT$#WPytxu-LJYw^CTL=2L
z8y3lj&zTQ?9<krZG4o+vyl1)j{5kN&)V!;Bjh3$f__u*q{Y^U6pLth+eg@BHW7?Mv
zEZgy-Z|4iXoR686I@+KCe`Y^}7_4KmOUias?+p4Mv+FaPL67W0KWKF8^mD1tZ+b$e
z--|y-{yNnk8yjnXOx+KIe*D{bwu)=Ew}on#Q^21BUdKyYpj)SJ=MQ}TuvynZSa9<2
z{Cg9g%WA(;T*eL$c*+_J+6B<~`~dxUJJt=i<?h^?n={?6LSj4y(jxG6;u-D+TqA$+
z$$48Z+19W8@!ThJ7Ch<S?pubTR%$Mo54Jec48-$Zisp~FZNNFe@%rNLq6IEm;GzXC
zTHvAuE?VHC1uk0Pq6IEm;GzZoUt3^5_UZB$QOGG9f7!505d#ewd&tcN9zV*@#o>ee
zVM#)M9e>Bkq2pkhD!)91nhbk!3>{Ot3_2dchKbm2$PTBW{PDdI{;&;5ezIo~SJ(<5
zzmF<EmyP)2T#!F3k!Jij7v!(=dnSP<b2e#4oPY9%Ej9APlAHWWRglH!sUd8+im@+)
zKLx4$v5i`OmhVqVQ$AQrP~CdZ=l=X9_1@}rR`2I2{k-0<Fzo-={wB2IE<$7S|6lCT
zsqHXN+wc2zs7<l~3i}XO*+`L@GOyEkaH-0*>mmWYx9zh^?`^xxrq^ZBBYJP!<tDwi
z?PZJJ+jiHHm43h8+je>=i+&`Fp2(t~)_WUw&gs1^UpC!oGWN0bJiWL157&EJepl~p
zyeQ71m+HNZyA@gVC3<h;a3qV~s`uDJAiqsn^euXC^KZ|h@78-fmX%*;7X6Uk+xk7N
z_qKk{>b+eP%L^O(*z)J=z3pdQy|?x&(0iLckd?kd?``?+&Z1Z8y{*4U7QI#PZT)Q0
zdz=53tn}?!>38eB&40h%+kPzDzdN(iAJThk-$WMuwBB3&&gs3?&xsg&+VbV=y|wRf
zy|?-mWYLSW(rY!R!0EZ>G9EDSbeVzs<{6k!xS`zKZ&!F$VcvX$AEB^V;W>pJ3k?07
z!r`}=`wE4v3im2}RblQz!&mxAQ~tWo7#LC5s&I?K?Ftu`m(O$y?ySaVP+Hs>MI}YW
zg_B$4Zt`DD!MoHYMfg;k;Enuu`-}Ztj=a;6#gyaV1Jt$wcxX9Jj?>yJJ~uV~@vwut
zpJT^8nfOam<D*P`f5(m+GVyti9dBgfFLms=CKErvvE!di{AH<eU?zT`WBbQU{2-^p
z24)W-#~JLn8b>{7l=pI{xL16>bNsWWelz*6a9Z1X!w+%ncr=rLXlfjqi67?JelZh&
zWoq1*iN`}}?e8-2S34cDk=KiLP%axC(|Br~>%5grW6YIl20i_xLdZSsY505E?Y2JT
zTREq*>gBJ%?{@|{7H`MJhQDXM8+^}t{NlUjdzo|CP6(ttc>W}Cuv3s#@2|hB9Q1}d
ze^D{cuW&*Av+-{#p6@eyf5vWCId<G)Y2CP>96LX<_+h9pA2uD>`n6tX<n;8bF~Z*y
z{~_Qh-_FCVd?Tl)-+n~o^u!zfE1b<){%`PUJ+1r}$m!ePE_dv>&GK76c|OZ-e8xxp
zEk2?N9#;HB*C3u(JfFdnfA=_ps8f8q;^WsF#5RqK`xQTIg28Jy;rx^0=NB2gybFiR
z9|P}0+=%}rF7UJSwSQCovn7H~#nCg0ccvQrS(D5;2S_=aRE`~QT>`y`->!Ju4-W&L
z<ytb=$k}dyGg|Ss-?aE5#m57Nu}<@yY5B_x{;<lqMe(+uov8R_insmlQ;M%tyzPhW
zJi9^hwqL$m`PmOqf7?&n2=!^j+kV@|0oD)sZ9i`D#^0`T5-)+l^LtwPZGV4AX}c9~
z`~Url|C-|Mc)<9d<9yrln~WS+`M<AtJ6<SO{NF3yjvp-kM~b)O33UtSnBwjD!t%eS
zcst%GQ2D=5yd8hodii(Y=_k9@Pw)s^eixKKZ?U;=P&_&XvFH2`8-y)yKgI7_YVgOD
ze}LkbFE<Dsw#j>rtd}!dv1gS3CgmS^k3qQ5gTFfzzy0IpezpP5M-*SM(IDhq3S53%
z@xv<(-sa1_$jo<BmBGv2U|d>%$nVq)4cWP0`Aez|;+XpXM&N0;{c1OCd6eH{%J0^h
zdwE9)m+i`bB+JfURsJ*g8UE#({kIh#Xf*f{n(sd<enpeP%lkpN{He-MsC*j-aHh7D
z_uLx8uhU^1_-*h<Vk*Y~C#m?^>kY!j$;)yL|Ka-$UiM|+a)jbfZ7}$R>OWrb2R~)-
zY7S=_@U+`m)zgme%a#B1XAJ)$1DxBG-}$sLK)&KXD)_6MxQ<)$6knxswrw^DSMedm
z?^C>uC-<rRe3h@uS5B+)uh?P)1XRwa6n}cFLD+Wph{|zQ&Oqh=yz=kbsR*sdy;gp^
z!OMFOxa7O0v`?|hvE_PE`RkrD{8a`xFDw3#;%&P)ruf`FhSB=%Yl=VqWtF4){7Uhq
zUom*uvyaQ)0#AKPRUaE4xZp{AMV8$LEB<c9+xguH#n&m`+UEw~*&Y{ZK(+NUN%6ZB
zFMHjgPnpVT&C+MFm2=YQFZ<7Nd6)8UQhsaCkm9!}-uhKk<qZ3Uk<(#-vtIEB6~9sO
z4=VobFAZY5;y<VOO{Wb)_J!keEAX^iyXJd|@;|No=YDMvvNs%;Use9yS^7V({2P8_
z_!p_1pD2Ha@?$%`{7x$Wh_}qW?DfXwS;bfV*5GB&5-$I!at^5+TaS5AnDtfgw&5>O
z{}~EA%XM7&Z9AF;1<1eT_lAGI0nR9uvrX~46kn)vPOF?@il3$Y4d)CZqWE&fzp8lI
z!wuSEmE-9A+4|eP%K!GCjDRYQSF4pjU-@l$*DL>#q~Vvn+qis4`Q0r3HswE_YYb!U
zvs3wtv-H`k{E15qzwF(H{BJ6MK>6+X@CD`H&VfCCw!Qz8;*Tj_yIbcK#aCTp_%|8g
z{EOm8e9#~oM4IFLTJg2l8@#QT-zk3YO$IM}Ig#dq;<wB-_!5<q1BF@d2NmC8$j%_e
z7nd8v7R6ty_)c|9+g`?5{)L87_7NhF8x?=J!r%{UzBd6caY^lF{cyhWcW@$upX?h1
zyj}V4R(?B9ULagoIA^owDffW?-R2{9Jx7w`kCAhgvngwST`l>h@is0+6u%{_U%OxN
z+q3YGD!x4n->&%GS@^FC{%U8R;&W9|qh}g#^{<eNL5>^Jic-S2A&2#A@naPq((%K5
z<v*m!{$BFE+&QG{Az+i=D=KH;D#N%%@jqAoBg&6(BtKg(fv;xj^GopeRxeh6`y4>U
zXuVwFbY{u<-FwK%&zkRBee%ARsZU?)0G5A57XP25yjM8cc<S3*x&8o$q5Z8sw*R_R
z9BD|8^`dKm_hH>8d%b9k@@KC*-6Z&)>sPm`oQ@x8;8cTd!~ocjkJ5Gax=sQ=xiix~
z6_T#!`dcOB+cjksEudNOgPc6IzxCS(6~FhhhI_sy+R}%dU47ucqjL6r%m}z!<-Dx;
z*|Rd`|4i{KrkQe8DE~>tSBx=;R>i+fyuW9C{Ym(h$pZ!>5Dh{7&VJM&T{Yj8g7+}$
z<@L&cVV6N1SNvqfpHV$+e;QEy_FIi$JD$Hy@y9=E1iY$pssyh$9uQUj$mb1mqU!l6
z;9U=&y_}DUiR<)Shy0?-X@A3T#x%i~6+c_oE3E$C0zTifu4U!Fr2GSC8by|<KL0Fu
z%aw*FlwXeta0V*>S;ZeYWq6O+Bp4X5UN+4zj2jhynd0*l;VS-G#Sh<R5c1wOE(-*&
zOdc>p`OhQ_vPzrTLdEZ&Y4A4RrHViH*9L#a0Egd^q@EMMZV-07bf4gr$piSk$<dyB
zd-<f5({3=uO4!qfobM}tLB6q1K>2^z2Y(mvc8sd50{Gnm*6)7pr!4Jl@aMyS?0Tlf
z|4H*L`L@AqQ9?h+p&dG&G>A^E-zyY9F>dgsioag*4WBdkBZ@Cke8H6lvE7iJfZ~hC
z8hnYZFU9ZGdGslj^Kr!=(s8@IlL=WHBtG<9mkxu!H#^)fa#RTq_$!qk*=&$wmG)F0
z{9o$>-`NNLXdn1r34V~X{1KC(U9b3q;!D&qb-3nqE53b*F^o13d9K6yYTak#Jg;^e
zGSJlHeyu3m9zUq~vD(n>`pHDaZ~m~6W8>R=#V`LigWs<5mkQqCynk0J|B9Opqb_qe
z;Xe2`_JMz<5B$D9@IMqh)}N;vZERdRs`xw|=UYF2Rq-WRasD@b$cKs1E_(ik3Vx8&
zuEAipvW!uD=ieB_A;lN<A!i=&Y^T}Jn-;5_5nAsyj@_g9)7Kh1$FyGf{n+00T(A6x
zpEZgcR((F(2mj7K@ZanMe?;ZyjW>$Odw$4chxn~#<^iuMf9o=XwEgB;#qa*5!B=RS
z94w^tR<5fBkLNg7n0yPAe{>)GQ<cASwBe7a-DUyrYFaP&5b(Xl+dAU?J)bMJsQi68
z(X?^$A;ni@`P-v{_vUD>pH}`0A2RngPJT`Cd9?;F-(AAxi;6$DOzoiM!t1cmKmFV=
z*CccJ9bm={=Mux1&<VzA#kVds__)gXgW@ONYXsPJ(OfJ@Qcmpy2ER+=`B25Lm}LZ<
z(R@cLzP-aBHY<L-;$u?{|2EBcn&J<QGKh1^f3xCqM;g2xH!c*sGI_wqlz-FT8e~G{
zS1Z2a0|s$S)6^^8(fRvc#joo_{=-(j8pg)GFDU-0FBk#xofus1R(z-SkMjO9@LyN_
z1}#^W>iK=as}dgYW98qaer4OsYklyaRsJoXF+%QESxLpO(2mH~*Jb&=x4RDrevlI@
zGYZ=NqEPY2HU95c`8O#(GR5%Q{%gLKv)C}&@xxNZZ=PrPcd48!^Lp>!R|vl{c|e86
zlkEKojVk}CErwaXKZMIx#TPF$c=^^IE+18VZPehc|39txx_qOjjX!%7U-}2bZ`<$p
z6@T{xgSY!i{+Hs<e8=Fc3~>Gh_}<1dCzOASK3~vq<Gd|+P3!^v5X5?mpVt82+q__0
zAN-|)ALKmsbtAmk6x+E)@p<Zp6E*LpmS5K^<Q+}W?o#|QeLgi``D+y)(|*dzStEF5
z@_>zf;Ga}EojR{Pt$OZO{MpYMA+?JCRv&VH2>cc3my2~=y+reVr4RmJ^npJw_(4vt
z#<z&d>5ocb{5&(qAWBr9s}$e5*5K{1eyrk;%`uFdR8FDb^~M9{EB_YtPiyDf`{1uq
z{_WbIZd6(Pt~&KRc&9<g_Y`rtR`C_HjXnpJ|3TnsH~YNU+U-%{S0)d5M&;})HAq{o
zJ&Mo2-r%j>o>%;?FJ<!oNby^4H28hmAN`BsPrC-cU+w&+;$L+Q!p6P-6ujZ}{^fV$
zLF(}<5d0wL&})XYS>;bx{OlP9zd`W<#UK8L!S7Z4ZNPI}kv(6#OZgA#e9gw~TE$mn
zw-?2a(0Fo0HU6aH7pb1MpL!U0S9!c(m+~*~Hdw3wR|W6oG}kXH|KZ2Xy>=(gzxBcY
zyFT#!hZ%nx_&Fn|$^d7G;!CsouhELH_+=*lO@i0N9&m^9m#Cw)s{KE%_<`EK4r!V?
z#qYk{Fvb=C3B|W(+5dBb_hhJ-U+M$@O_ftJ)W|=k{NGc2@$Ck2T=o2s;$2<m8KL|?
zQ~dT_22rc{UnqW)KEJT_epc~uU9Yq8=N-i#)41`J%DEKpOE3;x&<@|qcP6z&n<q8Y
zS5I11Q!^<TY_6%hsid$0M{>6ou4-zTG-Faxk^bM4xU8l*Hn}M5jIDLXw*HqSK~Oye
z)!+o<%5|aO>dKW(|5bTSl-C@K##&ac#7R1}q2|yk9>&sK8EfR(Mol=mrLwX%T)C<t
zTpetvti_2n(aK;;tAi8va9}qMiY}TlxpYSFOgNIMslGDEbC@g5SxhUNaa3g`&eLgJ
zk0hQuId49L6$i1((VkEX=L=QeR8n8ts#iF#mRCGBO3qT!YdJ=#l80ed*5WL?I?I#B
z+moh{HI9(3tSp*-Q|VN)rH`FbS#r)&nr-^zQtGRTrca&j)JH3Egij^T&RtpG>d1+Q
zwUs<9+g|gO9DB{vn(Vcl7-esGVw1g=)0*r}G!$BGuW^nQ%9Orq#0jPLu5mTAa3Y$s
zoCt+Glb<=93b!VgO3eU;rEFl0SX>y1IP{6a(&d~n?Ix7775~Dko#^WN2u&p?ZW)vE
zY+Ib<lftf*gSS>z%DJT}ERE8FW1w(+Ce&=kDOFK;QOF3Ysdh-Oui-IKt8m&C8Re9x
zN*>zn;CN%4Cx@f(Qd*Txo?h%^p77<N&6qByD6$-;Sa9AJoNxyai)J1KmQFPV_31ey
zjGCi*aqwnkG`KPZ1##r@niigbMSV>1DshS^POEm-1shgNdBqG!W)E#mi=R6ECg&3&
zoWT@o^c16HO0k2(vLc}x2d8_<AGS61u~MAh=QPz<Lv^Y{cdTrge3OS^+SHp!k+aB}
zaLzGKIE&Pyt?-~S*fK3?+Kg#r490NowY?Cb#FP-Twxp3~ZP!|=H=F6j9?vhGo}t3@
zDJ7nKrcaydR5z?HrW71=H@T8E7v*`Z9;VXb8L4B=(khn17T&uOCl+pr2JyFX6_2~Z
zNs%!gp2|ye7@CKB`gF+=C;6G9$2_DN+PGttP2r}>YKT~kbE7I7;fkL8W)vGXO5kyu
zo^#aFvSy&Hp7Yc^gsGFM9#0z#N8n=~O38Gm*_^AHam1R3<0i4cIjK+%%Jk4mC$n67
z@LCE#qqulFg0Gz8XHIPMkfs`O(fYI&Gm58auv%4*ljP`eINX|&n+#}a!U<=UP4$iH
zYBk}=dbSjtW6e|P>Z3eL7~uvtl{l;xhdx%O4l?8ojuz#q#ZKeuI@Av20@oOfuJ))f
zZTb`?cpY=bv{InW5pD>kJg^Ln3a165S@6^^##daL)5chBdhi)==G4kcJ(`WpC|b|s
z{dnve?{Fws*fB?giLwniBQIs9>C>i9cHmv!pfY`0=}k_kVPzpYtXNTanFJ-m%F0`o
zmfgOfa={(*D=TqFda9eMbt>n7^p3LIZ!OQHAfh$LfLeIRos|nJR6@o4rB3C-MT_T^
zEvj66%Pq?mEU#Q%HgC~_N(XVFCbB*dSh(ocdF7Q;iY8A-T8uUj6QeEChZ;xVDX`3+
z2^g_6QZPcq!Wk&kg#>GLTOKA&K`RlXc*roXaiXVjd0bZqqoJEhU|U9NXds;#Vjlus
zwpboV7{VcJ*?8>$tYq|ha#}Tn!zrXo#ii*$ctoS^DNGe-3zJ9|Z9yozb@}b^4?8qj
zetS6wCd+wnDRVNXCYlz(`<5o@dMhid(V0k9pyr52JdcD?F{We4&W>a)yA^8BU)03t
zA}B}nr*T>&<cpdx2#%cNdA`|VJqJ7@Eo?7+GcHYENr4#8g;Cc$Lvm#d2gqlLsI07M
z4blm4((orTs~kzw(Z8jMrlN2(n+yqHLoHTD9n?A^9C|RGl$^m5jlsN`sVYOY!B~*$
zt!oZOR!ZL>x$zK8V8sfxIKY=DOj_518SIG2<SJb!*&A?puua82)C?Ue*9IkIQ0??-
zmZs*|<5g-S&QKO&%xRr6_FE~woWX#8tv&;>lJYY!>42SqPKidrsIGNc6r;99MnA??
zNu$5WS>CvYcWX$_D5UxihYBK%oubqvhZIdUjgjokn_}U*DEzZ#Est!>plU=g{>-SE
zL0t)()?{E1BT&dp)GD-fIrdYui8VtDUNH!yL%Qj(G7@se5zZ2yiWjCpG#2`McF-Jc
zX8R!K5b!3`8kyzV8Uz~{fY+Ew;M{hOmU(h;M#i9u&spP2U1!Vw-<@4Os3b)Y9ykv*
zGm=9QE-<}85DqST9wsJdBBsN<{dv3G?9Q?~`_3~qHZm|UFcB_%;lUxi!0>_#4K*<o
zObm?f`>N{eneKgp*s!mrd%CLnr@FejdtMj#nwQuN)6^HFeYV0f3GUFdmn^_xI}SjT
z<xwiFbvRVWmQ99P4@|J?%ZCWd9@Su%l`MuHvwPEAU?G##(6m?=$9A7r7p-*YW5Qw~
z=utGRcEs3CCi3k$v{=c_>fnxXk=Jz;9jzM?5`&C#Btx5ij^aQsH*iMo!x}zm&6lg^
z3fH~FF*5F`U9s?)izo*GNSFxGlq3Q*%Sa4HoEtc1W7s@*qs*I{!DLPfq)IF005f3N
zmt$lyFZxUv0^+s`&^IldLX*yAdx#DOnV~-s0Jf$L?<JQ*H&2}7U{BJ54rudE124E_
zhqSDBO*=ESG272RhH0bbP)S*}`NC#bmUP{Le#IU==}UJxOA6KlX5Md(-LOVIG5u%#
zODhQ}sAXea5MxC{-FlcSWw+q=mU)97w^B8j@~CD-(wYx_u!c!njK!dvm31=5T5sJj
zKxk?B+y)+ObZ-rMXcf~1e4;br(+igUP$68JW~`QG#bil937chXRi7E4fU4zeJDl`7
z=HFd^z=GXP?u;D8tuVt_WRqwccZk`DEEEUa-Q(Z{FR8sdt`K7_kWt6`u7ASO0&DNI
zoi0NeT7M^Lro`-88rNnz_$~vwri1I?k~)<%^M#6sYJ!1pDWj1<69HM0I4}}Tc-%ol
z`?6322cnKez_7|V!30M29z4JZ1&3w!4%BSnH_~$V-AI=PZyK0yVNE01TbJF1i1$A%
zeT&FZwurjC(iHqRLoj?+L#FrpZI9-jVPm1sCrYuQc!v>E?T*kHZLZs!<|~?bW%X#_
za5?}P>nT->h2)I!q(63ZUua4YP9zz5OK;<x`1(zv>i*2>Qd`BHuMde8H)*nREnOh9
zG#1FzXClh^EzGUsmXef+k7~~Jv<*xXblW!qrLCqpJaZ$^m26cXo^FQr91t4T;7U(0
z?ic%ARd2CrQe%s>K0mIz`Mvc#l0JF(**%VWd$(#2tE!$q-GZJ&*d_Mn()~ndkp}Pf
zi>@U?Jng!ns!cxX0Xrd8&3#9_>&=9%7pvH5<N`It9K+Xgj-h7|Za3IUsV{oaavE4m
zR5dLX>|@4m@&5<!1C?9daeR~h|6b>%d_N7bEuNBi?Dr;q!v7*31V2nU{o#!wejo8E
zKL3xBLGZ4{#y=(gr+D=@?(`A=@8dyG`}Mbj#9JdNdwPVw_;e<f|9RjG($5<M!7coR
ze}{<(U*gAf@z*^|g1T3Uc^S&~<FPF7EE2x%8xZ`)uqysrlLh4ye2i4yfuy+ZB@jGw
zG%G*zsQi&!eT@gUsql4wfuQbX5`W>V{wyEyAL7TLdkzG3FBI`{q>=aw|68Q7O`@68
zciQ@18^<GAAg^iQ@$wX3_a+FwV&_c4JMk>|9pY1beZL^MdzAN>>MxS~++>Qcdl&@8
zNBPV0{}}jcf8Ez0_>%-U2$cMv75KW>LGT9-u1P5Q^O%$67k}OVAo%Qq2{Il_{?|yu
zCrdU40Mb1XS1-KX%KVB8z61_FiAngn*X;R!#Qznz8k=}b_fA{~zA7g95?}Sp@4#V6
zB__Jp?D}Uf|Ct(w#1Vuq_y^La`02aCYsbGT8eDir41ahI&NT7YdGysUj$h_4$W?y<
zmpMPeZyJOj$MflxQ*|6BGG0{C^8Ob5&*J-;_mIk?Y?Vjj_id!9?1mVB?*8eV-sPa5
X1o2lAKG(Pr|Nbp6)j!G@u*822X=0r}

diff --git a/mongoose-server/Makefile b/mongoose-server/Makefile
new file mode 100644
index 0000000..0c4a317
--- /dev/null
+++ b/mongoose-server/Makefile
@@ -0,0 +1,163 @@
+SRCS = mongoose.c test/unit_test.c test/packed_fs.c
+HDRS = $(wildcard src/*.h) $(wildcard mip/*.h)
+DEFS ?= -DMG_MAX_HTTP_HEADERS=7 -DMG_ENABLE_LINES -DMG_ENABLE_PACKED_FS=1 -DMG_ENABLE_SSI=1
+C_WARN ?= -Wmissing-prototypes -Wstrict-prototypes
+WARN ?= -pedantic -W -Wall -Werror -Wshadow -Wdouble-promotion -fno-common -Wconversion -Wundef $(C_WARN)
+OPTS ?= -O3 -g3
+VALGRIND_OPTS ?= -O0 -g3
+INCS ?= -Isrc -I.
+SSL ?= MBEDTLS
+CWD ?= $(realpath $(CURDIR))
+ENV ?=  -e Tmp=. -e WINEDEBUG=-all 
+DOCKER ?= docker run --rm $(ENV) -v $(CWD):$(CWD) -w $(CWD)
+VCFLAGS = /nologo /W3 /O2 /MD /I. $(DEFS) $(TFLAGS)
+IPV6 ?= 1
+ASAN ?= -fsanitize=address,undefined -fno-sanitize-recover=all
+ASAN_OPTIONS ?= detect_leaks=1
+EXAMPLES := $(dir $(wildcard examples/*/Makefile)) examples/stm32/nucleo-f746zg-baremetal
+PREFIX ?= /usr/local
+VERSION ?= $(shell cut -d'"' -f2 src/version.h)
+COMMON_CFLAGS ?= $(WARN) $(INCS) $(DEFS) -DMG_ENABLE_IPV6=$(IPV6) $(TFLAGS)
+CFLAGS ?= $(OPTS) $(ASAN) $(COMMON_CFLAGS)
+VALGRIND_CFLAGS ?= $(VALGRIND_OPTS) $(COMMON_CFLAGS)
+VALGRIND_RUN ?= valgrind --tool=memcheck --gen-suppressions=all --leak-check=full --show-leak-kinds=all --leak-resolution=high --track-origins=yes --error-exitcode=1 --exit-on-first-error=yes
+.PHONY: examples test valgrind
+
+ifeq "$(SSL)" "MBEDTLS"
+MBEDTLS ?= /usr/local
+CFLAGS  += -DMG_ENABLE_MBEDTLS=1 -I$(MBEDTLS)/include -I/usr/include
+LDFLAGS ?= -L$(MBEDTLS)/lib -lmbedtls -lmbedcrypto -lmbedx509
+endif
+ifeq "$(SSL)" "OPENSSL"
+OPENSSL ?= /usr/local
+CFLAGS  += -DMG_ENABLE_OPENSSL=1 -I$(OPENSSL)/include
+LDFLAGS ?= -L$(OPENSSL)/lib -lssl -lcrypto
+endif
+
+all: mg_prefix unamalgamated unpacked test test++ valgrind arm examples vc98 vc2017 vc22 mingw mingw++ linux linux++ fuzz
+
+examples:
+	@for X in $(EXAMPLES); do test -f $$X/Makefile || continue; $(MAKE) -C $$X example || exit 1; done
+
+test/packed_fs.c: Makefile src/ssi.h test/fuzz.c test/data/a.txt
+	$(CC) $(CFLAGS) test/pack.c -o pack
+	./pack Makefile src/ssi.h test/fuzz.c test/data/a.txt test/data/range.txt > $@
+
+DIR ?= test/data/
+OUT ?= fs_packed.c
+mkfs:
+	$(CC) $(CFLAGS) test/pack.c -o pack
+	./pack -s $(DIR) `find $(DIR) -type f` > $(OUT)
+#	find $(DIR) -type f | sed -e s,^$(DIR),,g -e s,^/,,g
+
+# Check that all external (exported) symbols have "mg_" prefix
+mg_prefix: mongoose.c mongoose.h
+	$(CC) mongoose.c $(CFLAGS) -c -o /tmp/x.o && nm /tmp/x.o | grep ' T' | grep -v 'mg_' ; test $$? = 1
+
+# C++ build
+test++: CC = g++
+test++: C_WARN = -std=c++2a -Wno-vla -Wno-shadow -Wno-missing-field-initializers -Wno-deprecated
+test++: test
+
+musl: test
+musl: ASAN =
+musl: WARN += -Wno-sign-conversion
+musl: CC = $(DOCKER) mdashnet/cc1 gcc
+
+# Make sure we can build from an unamalgamated sources
+unamalgamated: $(HDRS) Makefile test/packed_fs.c
+	$(CC) src/*.c test/packed_fs.c test/unit_test.c $(CFLAGS) $(LDFLAGS) -g -o unit_test
+
+unpacked:
+	$(CC) -I. mongoose.c test/unit_test.c -o $@
+
+fuzzer: mongoose.c mongoose.h Makefile test/fuzz.c
+	clang++ mongoose.c test/fuzz.c $(WARN) $(INCS) $(TFLAGS) -DMG_ENABLE_LINES -fsanitize=fuzzer,signed-integer-overflow,address -Wno-deprecated -Wno-vla-extension -o $@
+
+fuzz: fuzzer
+	$(RUN) ./fuzzer
+
+unit_test: Makefile mongoose.h $(SRCS)
+	$(CC) $(SRCS) $(CFLAGS) $(LDFLAGS) -g -o unit_test
+
+# make CC=/usr/local/opt/llvm\@8/bin/clang ASAN_OPTIONS=detect_leaks=1
+test: unit_test
+	ASAN_OPTIONS=$(ASAN_OPTIONS) $(RUN) ./unit_test
+
+coverage: CFLAGS += -coverage
+coverage: test
+	gcov -l -n *.gcno | sed '/^$$/d' | sed 'N;s/\n/ /'
+	gcov -t mongoose.c > mongoose.gcov
+
+upload-coverage: coverage
+	curl -s https://codecov.io/bash | /bin/bash
+
+valgrind_unit_test: Makefile mongoose.h $(SRCS)
+	$(CC) $(SRCS) $(VALGRIND_CFLAGS) $(LDFLAGS) -g -o valgrind_unit_test
+
+valgrind: valgrind_unit_test
+	$(VALGRIND_RUN) ./valgrind_unit_test
+
+infer:
+	infer run -- cc test/unit_test.c -c -W -Wall -Werror -Isrc -I. -O2 -DMG_ENABLE_MBEDTLS=1 -DMG_ENABLE_LINES -I/usr/local/Cellar/mbedtls/2.23.0/include  -DMG_ENABLE_IPV6=1 -g -o /dev/null
+
+arm: DEFS += -DMG_ENABLE_FILE=0 -DMG_ENABLE_MIP=1 -DMG_ARCH=MG_ARCH_NEWLIB 
+arm: mongoose.h $(SRCS)
+	$(DOCKER) mdashnet/armgcc arm-none-eabi-gcc -mcpu=cortex-m3 -mthumb $(SRCS) $(OPTS) $(WARN) $(INCS) $(DEFS) $(TFLAGS) -o unit_test -nostartfiles --specs nosys.specs -e 0
+
+riscv: DEFS += -DMG_ENABLE_FILE=0 -DMG_ENABLE_MIP=1 -DMG_ARCH=MG_ARCH_NEWLIB 
+riscv: mongoose.h $(SRCS)
+	$(DOCKER) mdashnet/riscv riscv-none-elf-gcc -march=rv32imc -mabi=ilp32 $(SRCS) $(OPTS) $(WARN) $(INCS) $(DEFS) $(TFLAGS) -o unit_test
+
+vc98: Makefile mongoose.h $(SRCS)
+	$(DOCKER) mdashnet/vc98 wine cl $(SRCS) $(VCFLAGS) ws2_32.lib /Fe$@.exe
+	$(DOCKER) mdashnet/vc98 wine $@.exe
+
+# vc2017: DEFS += -DMG_ENABLE_IPV6=1
+vc2017: Makefile mongoose.h $(SRCS)
+	$(DOCKER) mdashnet/vc2017 wine64 cl $(SRCS) $(VCFLAGS) ws2_32.lib /Fe$@.exe
+	$(DOCKER) mdashnet/vc2017 wine64 $@.exe
+
+# vc22: DEFS += -DMG_ENABLE_IPV6=$(IPV6)
+vc22: Makefile mongoose.h $(SRCS)
+	$(DOCKER) mdashnet/vc22 wine64 cl $(SRCS) $(VCFLAGS) ws2_32.lib /Fe$@.exe
+	$(DOCKER) mdashnet/vc22 wine64 $@.exe
+
+mingw: Makefile mongoose.h $(SRCS)
+	$(DOCKER) mdashnet/mingw x86_64-w64-mingw32-gcc $(SRCS) -W -Wall -Werror -I. $(DEFS) -lwsock32 -o $@.exe
+	$(DOCKER) mdashnet/mingw wine64 $@.exe
+
+mingw++: Makefile mongoose.h $(SRCS)
+	$(DOCKER) mdashnet/mingw x86_64-w64-mingw32-g++ $(SRCS) -W -Wall -Werror -I. $(DEFS) -lwsock32 -o $@.exe
+
+linux: IPV6=0
+linux: Makefile mongoose.h $(SRCS)
+	$(DOCKER) mdashnet/cc2 gcc $(SRCS) $(CFLAGS) $(LDFLAGS) -o unit_test_gcc
+	$(DOCKER) mdashnet/cc2 ./unit_test_gcc
+
+linux++: CC = g++
+linux++: WARN += -Wno-missing-field-initializers
+linux++: linux
+
+linux-libs: CFLAGS += -fPIC
+linux-libs: mongoose.o
+	$(CC) mongoose.o $(LDFLAGS) -shared -o libmongoose.so.$(VERSION)
+	$(AR) rcs libmongoose.a mongoose.o
+
+install: linux-libs
+	install -Dm644 libmongoose.a libmongoose.so.$(VERSION) $(DESTDIR)$(PREFIX)/lib
+	ln -s libmongoose.so.$(VERSION) $(DESTDIR)$(PREFIX)/lib/libmongoose.so
+	install -Dm644 mongoose.h $(DESTDIR)$(PREFIX)/include/mongoose.h
+
+uninstall:
+	rm -rf $(DESTDIR)$(PREFIX)/lib/libmongoose.a $(DESTDIR)$(PREFIX)/lib/libmongoose.so.$(VERSION) $(DESTDIR)$(PREFIX)/include/mongoose.h $(DESTDIR)$(PREFIX)/lib/libmongoose.so
+
+mongoose.c: Makefile $(wildcard src/*) $(wildcard mip/*.c)
+	(cat src/license.h; echo; echo '#include "mongoose.h"' ; (for F in src/*.c mip/*.c ; do echo; echo '#ifdef MG_ENABLE_LINES'; echo "#line 1 \"$$F\""; echo '#endif'; cat $$F | sed -e 's,#include ".*,,'; done))> $@
+
+mongoose.h: $(HDRS) Makefile
+	(cat src/license.h; echo; echo '#ifndef MONGOOSE_H'; echo '#define MONGOOSE_H'; echo; cat src/version.h ; echo; echo '#ifdef __cplusplus'; echo 'extern "C" {'; echo '#endif'; cat src/arch.h src/arch_*.h src/config.h src/str.h src/log.h src/timer.h src/fs.h src/util.h src/url.h src/iobuf.h src/base64.h src/md5.h src/sha1.h src/event.h src/net.h src/http.h src/ssi.h src/tls.h src/tls_mbed.h src/tls_openssl.h src/ws.h src/sntp.h src/mqtt.h src/dns.h src/json.h mip/mip.h | sed -e 's,#include ".*,,' -e 's,^#pragma once,,'; echo; echo '#ifdef __cplusplus'; echo '}'; echo '#endif'; echo '#endif  // MONGOOSE_H')> $@
+
+clean:
+	rm -rf $(PROG) *.exe *.o *.dSYM unit_test* valgrind_unit_test* ut fuzzer *.gcov *.gcno *.gcda *.obj *.exe *.ilk *.pdb slow-unit* _CL_* infer-out data.txt crash-* test/packed_fs.c pack unpacked
+	@for X in $(EXAMPLES); do $(MAKE) -C $$X clean; done
diff --git a/mongoose-server/examples/.DS_Store b/mongoose-server/examples/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..f4a3074a4fb5636b0c981be4c200811f75f6fc2e
GIT binary patch
literal 6148
zcmeHKJ5Iw;5S)b+k<z40`7S`g4W6QKf?R+i2nrOCfz+;YE{?|RM@W{1NJE2Wt=)NV
zz4I(j;q?Nr?Z@F3SOZwn9dY(BH^1*bv#ZJ&k<K%2@P-ErI5A#k&RyXN@4Q|o{Nc18
zj?XX0$2|SA<5VRDq<|EV0#ZN<{Gx#OUfOb%s3--bfE4&vz`qZT?$`^*#Q1bD#0WrK
zFdfEq%o4=r31TlC6Pck|Qi(~m8Zj*C%(trRg=1pUVKsbMJ=tnPv3NSqZ&42GiHcG{
z3QQHa&h6U!{~i5@`F~2%P6|kYf2DvecKh9yuT;Ht_Hy298~vW{HJ@}hu7ko5?U)$t
hm>X}$n<&b<=4;;Xg=1pSnGZTqKLf6dObYz90$<i670Cbq

literal 0
HcmV?d00001

diff --git a/mongoose-server/examples/http-server/.DS_Store b/mongoose-server/examples/http-server/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..3e4ad1b8837744a817fd530863930fd069044617
GIT binary patch
literal 6148
zcmeHKJ5Izf5PbtH6hyNn4U$i=5;q8|q@bXI3&4Jm5LvdOPtRdEBE0#4NJtApXh!n9
zi9Iv6pA_2zK$g#&b6^gjVp9|~CPcd@hYrH|kSLa8f%Rp#U$46TY9i5J?9#O#VTU_B
z;0eR^D=DvRi#HQneuXRgK4Ob|Ms(PI*)RR&Y~+88YqYpP!?>3Dci4;~UPci%O{!!d
z8At|_fn?yv7~q|)Qk^)aP6m>JWZ;tlJs%32Vjb8!+R;H}B>-{8ZWG%2Y}S|(SO@lw
z9HEGZ5<OI+#1Ic>e+j=juy^!uNE9CuGk+8>VzV=UF?UGqm^v9q28Il1?Ms>K{onGJ
znJn_nB~>zz4E$FHWY*j?OYSc2)^GdNySA|1vZ<(FuLgzo;1R$NJx5M$(8r6~^s57V
VN6n)B7Ea8EfDw`^8TbVT-T?*-GnfDX

literal 0
HcmV?d00001

diff --git a/mongoose-server/examples/http-server/Makefile b/mongoose-server/examples/http-server/Makefile
new file mode 100644
index 0000000..528fc62
--- /dev/null
+++ b/mongoose-server/examples/http-server/Makefile
@@ -0,0 +1,26 @@
+PROG ?= example
+ROOT ?= $(realpath $(CURDIR)/../..)
+DEFS ?= -DMG_ENABLE_LINES=1 -DMG_ENABLE_IPV6=1 -DMG_ENABLE_SSI=1
+CFLAGS ?= -I../.. -W -Wall $(DEFS) $(EXTRA)
+VCFLAGS = /nologo /W3 /O2 /I../.. $(DEFS) $(EXTRA) /link /incremental:no /machine:IX86
+VC98 = docker run -it --rm -e Tmp=. -v $(ROOT):$(ROOT) -w $(CURDIR) mdashnet/vc98
+LIN = docker run -it --rm -v $(ROOT):$(ROOT) -w $(CURDIR) mdashnet/cc2
+
+all: $(PROG)
+	$(RUN) ./$(PROG) $(ARGS)
+
+$(PROG): main.c Makefile
+	$(CC) ../../mongoose.c main.c -I../.. $(CFLAGS) -o $@
+
+mongoose.exe: main.c
+	$(VC98) wine cl ../../mongoose.c main.c $(VCFLAGS) ws2_32.lib /out:$@
+
+mingw:
+	gcc ../../mongoose.c main.c -I../.. -W -Wall -DMG_ENABLE_IPV6=1 -DMG_ENABLE_LINES=1 -D_POSIX_C_SOURCE=200000L -lws2_32 -o mongoose.exe
+
+linux: example
+#linux: CFLAGS += -O2 -fsanitize=address,undefined,shift,null,return,bounds,alignment,object-size,bool,enum -static-libasan
+linux: CC = $(LIN) cc
+
+clean:
+	rm -rf $(PROG) *.o *.dSYM *.gcov *.gcno *.gcda *.obj *.exe *.ilk *.pdb mongoose mongoose_* mongoose.*
diff --git a/mongoose-server/examples/http-server/README.md b/mongoose-server/examples/http-server/README.md
new file mode 100644
index 0000000..27450ef
--- /dev/null
+++ b/mongoose-server/examples/http-server/README.md
@@ -0,0 +1 @@
+See detailed tutorial at https://mongoose.ws/tutorials/http-server/
diff --git a/mongoose-server/examples/http-server/example b/mongoose-server/examples/http-server/example
new file mode 100755
index 0000000000000000000000000000000000000000..f1edb203678ffca21b1cc128d0d88ae1c06e774e
GIT binary patch
literal 162096
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
WlczmYz&Xhtqf;HCpkO(Ep8a2Hy*DKQ

literal 0
HcmV?d00001

diff --git a/mongoose-server/examples/http-server/main.c b/mongoose-server/examples/http-server/main.c
new file mode 100644
index 0000000..19d948e
--- /dev/null
+++ b/mongoose-server/examples/http-server/main.c
@@ -0,0 +1,103 @@
+// Copyright (c) 2020 Cesanta Software Limited
+// All rights reserved
+
+#include <signal.h>
+#include "mongoose.h"
+
+static const char *s_debug_level = "2";
+static const char *s_root_dir = ".";
+static const char *s_listening_address = "http://0.0.0.0:6201";
+static const char *s_enable_hexdump = "no";
+static const char *s_ssi_pattern = "#.html";
+
+// Handle interrupts, like Ctrl-C
+static int s_signo;
+static void signal_handler(int signo) {
+  s_signo = signo;
+}
+
+// Event handler for the listening connection.
+// Simply serve static files from `s_root_dir`
+static void cb(struct mg_connection *c, int ev, void *ev_data, void *fn_data) {
+  if (ev == MG_EV_HTTP_MSG) {
+    struct mg_http_message *hm = ev_data, tmp = {0};
+    struct mg_str unknown = mg_str_n("?", 1), *cl;
+    struct mg_http_serve_opts opts = {0};
+    opts.root_dir = s_root_dir;
+    opts.ssi_pattern = s_ssi_pattern;
+    mg_http_serve_dir(c, hm, &opts);
+    mg_http_parse((char *) c->send.buf, c->send.len, &tmp);
+    cl = mg_http_get_header(&tmp, "Content-Length");
+    if (cl == NULL) cl = &unknown;
+    MG_INFO(("%.*s %.*s %.*s %.*s", (int) hm->method.len, hm->method.ptr,
+             (int) hm->uri.len, hm->uri.ptr, (int) tmp.uri.len, tmp.uri.ptr,
+             (int) cl->len, cl->ptr));
+  }
+  (void) fn_data;
+}
+
+static void usage(const char *prog) {
+  fprintf(stderr,
+          "Mongoose v.%s\n"
+          "Usage: %s OPTIONS\n"
+          "  -H yes|no - enable traffic hexdump, default: '%s'\n"
+          "  -S PAT    - SSI filename pattern, default: '%s'\n"
+          "  -d DIR    - directory to serve, default: '%s'\n"
+          "  -l ADDR   - listening address, default: '%s'\n"
+          "  -v LEVEL  - debug level, from 0 to 4, default: '%s'\n",
+          MG_VERSION, prog, s_enable_hexdump, s_ssi_pattern, s_root_dir,
+          s_listening_address, s_debug_level);
+  exit(EXIT_FAILURE);
+}
+
+int main(int argc, char *argv[]) {
+  char path[MG_PATH_MAX] = ".";
+  struct mg_mgr mgr;
+  struct mg_connection *c;
+  int i;
+
+  // Parse command-line flags
+  for (i = 1; i < argc; i++) {
+    if (strcmp(argv[i], "-d") == 0) {
+      s_root_dir = argv[++i];
+    } else if (strcmp(argv[i], "-H") == 0) {
+      s_enable_hexdump = argv[++i];
+    } else if (strcmp(argv[i], "-S") == 0) {
+      s_ssi_pattern = argv[++i];
+    } else if (strcmp(argv[i], "-l") == 0) {
+      s_listening_address = argv[++i];
+    } else if (strcmp(argv[i], "-v") == 0) {
+      s_debug_level = argv[++i];
+    } else {
+      usage(argv[0]);
+    }
+  }
+
+  // Root directory must not contain double dots. Make it absolute
+  // Do the conversion only if the root dir spec does not contain overrides
+  if (strchr(s_root_dir, ',') == NULL) {
+    realpath(s_root_dir, path);
+    s_root_dir = path;
+  }
+
+  // Initialise stuff
+  signal(SIGINT, signal_handler);
+  signal(SIGTERM, signal_handler);
+  mg_log_set(s_debug_level);
+  mg_mgr_init(&mgr);
+  if ((c = mg_http_listen(&mgr, s_listening_address, cb, &mgr)) == NULL) {
+    MG_ERROR(("Cannot listen on %s. Use http://ADDR:PORT or :PORT",
+              s_listening_address));
+    exit(EXIT_FAILURE);
+  }
+  if (mg_casecmp(s_enable_hexdump, "yes") == 0) c->is_hexdumping = 1;
+
+  // Start infinite event loop
+  MG_INFO(("Mongoose version : v%s", MG_VERSION));
+  MG_INFO(("Listening on     : %s", s_listening_address));
+  MG_INFO(("Web root         : [%s]", s_root_dir));
+  while (s_signo == 0) mg_mgr_poll(&mgr, 1000);
+  mg_mgr_free(&mgr);
+  MG_INFO(("Exiting on signal %d", s_signo));
+  return 0;
+}
diff --git a/mongoose-server/mongoose.c b/mongoose-server/mongoose.c
new file mode 100644
index 0000000..6c69d38
--- /dev/null
+++ b/mongoose-server/mongoose.c
@@ -0,0 +1,6776 @@
+// Copyright (c) 2004-2013 Sergey Lyubka
+// Copyright (c) 2013-2022 Cesanta Software Limited
+// All rights reserved
+//
+// This software is dual-licensed: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License version 2 as
+// published by the Free Software Foundation. For the terms of this
+// license, see http://www.gnu.org/licenses/
+//
+// You are free to use this software under the terms of the GNU General
+// Public License, but WITHOUT ANY WARRANTY; without even the implied
+// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+//
+// Alternatively, you can license this software under a commercial
+// license, as set out in https://www.mongoose.ws/licensing/
+//
+// SPDX-License-Identifier: GPL-2.0 or commercial
+
+#include "mongoose.h"
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/base64.c"
+#endif
+
+
+
+static int mg_b64idx(int c) {
+  if (c < 26) {
+    return c + 'A';
+  } else if (c < 52) {
+    return c - 26 + 'a';
+  } else if (c < 62) {
+    return c - 52 + '0';
+  } else {
+    return c == 62 ? '+' : '/';
+  }
+}
+
+static int mg_b64rev(int c) {
+  if (c >= 'A' && c <= 'Z') {
+    return c - 'A';
+  } else if (c >= 'a' && c <= 'z') {
+    return c + 26 - 'a';
+  } else if (c >= '0' && c <= '9') {
+    return c + 52 - '0';
+  } else if (c == '+') {
+    return 62;
+  } else if (c == '/') {
+    return 63;
+  } else if (c == '=') {
+    return 64;
+  } else {
+    return -1;
+  }
+}
+
+int mg_base64_update(unsigned char ch, char *to, int n) {
+  int rem = (n & 3) % 3;
+  if (rem == 0) {
+    to[n] = (char) mg_b64idx(ch >> 2);
+    to[++n] = (char) ((ch & 3) << 4);
+  } else if (rem == 1) {
+    to[n] = (char) mg_b64idx(to[n] | (ch >> 4));
+    to[++n] = (char) ((ch & 15) << 2);
+  } else {
+    to[n] = (char) mg_b64idx(to[n] | (ch >> 6));
+    to[++n] = (char) mg_b64idx(ch & 63);
+    n++;
+  }
+  return n;
+}
+
+int mg_base64_final(char *to, int n) {
+  int saved = n;
+  // printf("---[%.*s]\n", n, to);
+  if (n & 3) n = mg_base64_update(0, to, n);
+  if ((saved & 3) == 2) n--;
+  // printf("    %d[%.*s]\n", n, n, to);
+  while (n & 3) to[n++] = '=';
+  to[n] = '\0';
+  return n;
+}
+
+int mg_base64_encode(const unsigned char *p, int n, char *to) {
+  int i, len = 0;
+  for (i = 0; i < n; i++) len = mg_base64_update(p[i], to, len);
+  len = mg_base64_final(to, len);
+  return len;
+}
+
+int mg_base64_decode(const char *src, int n, char *dst) {
+  const char *end = src + n;
+  int len = 0;
+  while (src + 3 < end) {
+    int a = mg_b64rev(src[0]), b = mg_b64rev(src[1]), c = mg_b64rev(src[2]),
+        d = mg_b64rev(src[3]);
+    if (a == 64 || a < 0 || b == 64 || b < 0 || c < 0 || d < 0) return 0;
+    dst[len++] = (char) ((a << 2) | (b >> 4));
+    if (src[2] != '=') {
+      dst[len++] = (char) ((b << 4) | (c >> 2));
+      if (src[3] != '=') dst[len++] = (char) ((c << 6) | d);
+    }
+    src += 4;
+  }
+  dst[len] = '\0';
+  return len;
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/dbl.c"
+#endif
+
+
+double mg_atod(const char *p, int len, int *numlen) {
+  double d = 0.0;
+  int i = 0, sign = 1;
+
+  // Sign
+  if (i < len && *p == '-') {
+    sign = -1, i++;
+  } else if (i < len && *p == '+') {
+    i++;
+  }
+
+  // Decimal
+  for (; i < len && p[i] >= '0' && p[i] <= '9'; i++) {
+    d *= 10.0;
+    d += p[i] - '0';
+  }
+  d *= sign;
+
+  // Fractional
+  if (i < len && p[i] == '.') {
+    double frac = 0.0, base = 0.1;
+    i++;
+    for (; i < len && p[i] >= '0' && p[i] <= '9'; i++) {
+      frac += base * (p[i] - '0');
+      base /= 10.0;
+    }
+    d += frac * sign;
+  }
+
+  // Exponential
+  if (i < len && (p[i] == 'e' || p[i] == 'E')) {
+    int j, exp = 0, minus = 0;
+    i++;
+    if (i < len && p[i] == '-') minus = 1, i++;
+    if (i < len && p[i] == '+') i++;
+    while (i < len && p[i] >= '0' && p[i] <= '9' && exp < 308)
+      exp = exp * 10 + (p[i++] - '0');
+    if (minus) exp = -exp;
+    for (j = 0; j < exp; j++) d *= 10.0;
+    for (j = 0; j < -exp; j++) d /= 10.0;
+  }
+
+  if (numlen != NULL) *numlen = i;
+  return d;
+}
+
+static int addexp(char *buf, int e, int sign) {
+  int n = 0;
+  buf[n++] = 'e';
+  buf[n++] = (char) sign;
+  if (e > 400) return 0;
+  if (e < 10) buf[n++] = '0';
+  if (e >= 100) buf[n++] = (char) (e / 100 + '0'), e -= 100 * (e / 100);
+  if (e >= 10) buf[n++] = (char) (e / 10 + '0'), e -= 10 * (e / 10);
+  buf[n++] = (char) (e + '0');
+  return n;
+}
+
+static int xisinf(double x) {
+  union {
+    double f;
+    uint64_t u;
+  } ieee754 = {x};
+  return ((unsigned) (ieee754.u >> 32) & 0x7fffffff) == 0x7ff00000 &&
+         ((unsigned) ieee754.u == 0);
+}
+
+static int xisnan(double x) {
+  union {
+    double f;
+    uint64_t u;
+  } ieee754 = {x};
+  return ((unsigned) (ieee754.u >> 32) & 0x7fffffff) +
+             ((unsigned) ieee754.u != 0) >
+         0x7ff00000;
+}
+
+size_t mg_dtoa(char *dst, size_t dstlen, double d, int width) {
+  char buf[40];
+  int i, s = 0, n = 0, e = 0;
+  double t, mul, saved;
+  if (d == 0.0) return mg_snprintf(dst, dstlen, "%s", "0");
+  if (xisinf(d)) return mg_snprintf(dst, dstlen, "%s", d > 0 ? "inf" : "-inf");
+  if (xisnan(d)) return mg_snprintf(dst, dstlen, "%s", "nan");
+  if (d < 0.0) d = -d, buf[s++] = '-';
+
+  // Round
+  saved = d;
+  mul = 1.0;
+  while (d >= 10.0 && d / mul >= 10.0) mul *= 10.0;
+  while (d <= 1.0 && d / mul <= 1.0) mul /= 10.0;
+  for (i = 0, t = mul * 5; i < width; i++) t /= 10.0;
+  d += t;
+  // Calculate exponent, and 'mul' for scientific representation
+  mul = 1.0;
+  while (d >= 10.0 && d / mul >= 10.0) mul *= 10.0, e++;
+  while (d < 1.0 && d / mul < 1.0) mul /= 10.0, e--;
+  // printf(" --> %g %d %g %g\n", saved, e, t, mul);
+
+  if (e >= width) {
+    n = (int) mg_dtoa(buf, sizeof(buf), saved / mul, width);
+    // printf(" --> %.*g %d [%.*s]\n", 10, d / t, e, n, buf);
+    n += addexp(buf + s + n, e, '+');
+    return mg_snprintf(dst, dstlen, "%.*s", n, buf);
+  } else if (e <= -width) {
+    n = (int) mg_dtoa(buf, sizeof(buf), saved / mul, width);
+    // printf(" --> %.*g %d [%.*s]\n", 10, d / mul, e, n, buf);
+    n += addexp(buf + s + n, -e, '-');
+    return mg_snprintf(dst, dstlen, "%.*s", n, buf);
+  } else {
+    for (i = 0, t = mul; t >= 1.0 && s + n < (int) sizeof(buf); i++) {
+      int ch = (int) (d / t);
+      if (n > 0 || ch > 0) buf[s + n++] = (char) (ch + '0');
+      d -= ch * t;
+      t /= 10.0;
+    }
+    // printf(" --> [%g] -> %g %g (%d) [%.*s]\n", saved, d, t, n, s + n, buf);
+    if (n == 0) buf[s++] = '0';
+    while (t >= 1.0 && n + s < (int) sizeof(buf)) buf[n++] = '0', t /= 10.0;
+    if (s + n < (int) sizeof(buf)) buf[n + s++] = '.';
+    // printf(" 1--> [%g] -> [%.*s]\n", saved, s + n, buf);
+    for (i = 0, t = 0.1; s + n < (int) sizeof(buf) && n < width; i++) {
+      int ch = (int) (d / t);
+      buf[s + n++] = (char) (ch + '0');
+      d -= ch * t;
+      t /= 10.0;
+    }
+  }
+  while (n > 0 && buf[s + n - 1] == '0') n--;  // Trim trailing zeros
+  if (n > 0 && buf[s + n - 1] == '.') n--;     // Trim trailing dot
+  buf[s + n] = '\0';
+  return mg_snprintf(dst, dstlen, "%s", buf);
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/dns.c"
+#endif
+
+
+
+
+
+
+
+struct dns_data {
+  struct dns_data *next;
+  struct mg_connection *c;
+  uint64_t expire;
+  uint16_t txnid;
+};
+
+static void mg_sendnsreq(struct mg_connection *, struct mg_str *, int,
+                         struct mg_dns *, bool);
+
+static void mg_dns_free(struct mg_connection *c, struct dns_data *d) {
+  LIST_DELETE(struct dns_data,
+              (struct dns_data **) &c->mgr->active_dns_requests, d);
+  free(d);
+}
+
+void mg_resolve_cancel(struct mg_connection *c) {
+  struct dns_data *tmp, *d = (struct dns_data *) c->mgr->active_dns_requests;
+  for (; d != NULL; d = tmp) {
+    tmp = d->next;
+    if (d->c == c) mg_dns_free(c, d);
+  }
+}
+
+static size_t mg_dns_parse_name_depth(const uint8_t *s, size_t len, size_t ofs,
+                                      char *to, size_t tolen, size_t j,
+                                      int depth) {
+  size_t i = 0;
+  if (tolen > 0 && depth == 0) to[0] = '\0';
+  if (depth > 5) return 0;
+  // MG_INFO(("ofs %lx %x %x", (unsigned long) ofs, s[ofs], s[ofs + 1]));
+  while (ofs + i + 1 < len) {
+    size_t n = s[ofs + i];
+    if (n == 0) {
+      i++;
+      break;
+    }
+    if (n & 0xc0) {
+      size_t ptr = (((n & 0x3f) << 8) | s[ofs + i + 1]);  // 12 is hdr len
+      // MG_INFO(("PTR %lx", (unsigned long) ptr));
+      if (ptr + 1 < len && (s[ptr] & 0xc0) == 0 &&
+          mg_dns_parse_name_depth(s, len, ptr, to, tolen, j, depth + 1) == 0)
+        return 0;
+      i += 2;
+      break;
+    }
+    if (ofs + i + n + 1 >= len) return 0;
+    if (j > 0) {
+      if (j < tolen) to[j] = '.';
+      j++;
+    }
+    if (j + n < tolen) memcpy(&to[j], &s[ofs + i + 1], n);
+    j += n;
+    i += n + 1;
+    if (j < tolen) to[j] = '\0';  // Zero-terminate this chunk
+    // MG_INFO(("--> [%s]", to));
+  }
+  if (tolen > 0) to[tolen - 1] = '\0';  // Make sure make sure it is nul-term
+  return i;
+}
+
+static size_t mg_dns_parse_name(const uint8_t *s, size_t n, size_t ofs,
+                                char *dst, size_t dstlen) {
+  return mg_dns_parse_name_depth(s, n, ofs, dst, dstlen, 0, 0);
+}
+
+size_t mg_dns_parse_rr(const uint8_t *buf, size_t len, size_t ofs,
+                       bool is_question, struct mg_dns_rr *rr) {
+  const uint8_t *s = buf + ofs, *e = &buf[len];
+
+  memset(rr, 0, sizeof(*rr));
+  if (len < sizeof(struct mg_dns_header)) return 0;  // Too small
+  if (len > 512) return 0;  //  Too large, we don't expect that
+  if (s >= e) return 0;     //  Overflow
+
+  if ((rr->nlen = (uint16_t) mg_dns_parse_name(buf, len, ofs, NULL, 0)) == 0)
+    return 0;
+  s += rr->nlen + 4;
+  if (s > e) return 0;
+  rr->atype = (uint16_t) (((uint16_t) s[-4] << 8) | s[-3]);
+  rr->aclass = (uint16_t) (((uint16_t) s[-2] << 8) | s[-1]);
+  if (is_question) return (size_t) (rr->nlen + 4);
+
+  s += 6;
+  if (s > e) return 0;
+  rr->alen = (uint16_t) (((uint16_t) s[-2] << 8) | s[-1]);
+  if (s + rr->alen > e) return 0;
+  return (size_t) (rr->nlen + rr->alen + 10);
+}
+
+bool mg_dns_parse(const uint8_t *buf, size_t len, struct mg_dns_message *dm) {
+  const struct mg_dns_header *h = (struct mg_dns_header *) buf;
+  struct mg_dns_rr rr;
+  size_t i, n, ofs = sizeof(*h);
+  memset(dm, 0, sizeof(*dm));
+
+  if (len < sizeof(*h)) return 0;                // Too small, headers dont fit
+  if (mg_ntohs(h->num_questions) > 1) return 0;  // Sanity
+  if (mg_ntohs(h->num_answers) > 10) return 0;   // Sanity
+  dm->txnid = mg_ntohs(h->txnid);
+
+  for (i = 0; i < mg_ntohs(h->num_questions); i++) {
+    if ((n = mg_dns_parse_rr(buf, len, ofs, true, &rr)) == 0) return false;
+    // MG_INFO(("Q %lu %lu %hu/%hu", ofs, n, rr.atype, rr.aclass));
+    ofs += n;
+  }
+  for (i = 0; i < mg_ntohs(h->num_answers); i++) {
+    if ((n = mg_dns_parse_rr(buf, len, ofs, false, &rr)) == 0) return false;
+    // MG_INFO(("A -- %lu %lu %hu/%hu %s", ofs, n, rr.atype, rr.aclass,
+    // dm->name));
+    mg_dns_parse_name(buf, len, ofs, dm->name, sizeof(dm->name));
+    ofs += n;
+
+    if (rr.alen == 4 && rr.atype == 1 && rr.aclass == 1) {
+      dm->addr.is_ip6 = false;
+      memcpy(&dm->addr.ip, &buf[ofs - 4], 4);
+      dm->resolved = true;
+      break;  // Return success
+    } else if (rr.alen == 16 && rr.atype == 28 && rr.aclass == 1) {
+      dm->addr.is_ip6 = true;
+      memcpy(&dm->addr.ip6, &buf[ofs - 16], 16);
+      dm->resolved = true;
+      break;  // Return success
+    }
+  }
+  return true;
+}
+
+static void dns_cb(struct mg_connection *c, int ev, void *ev_data,
+                   void *fn_data) {
+  struct dns_data *d, *tmp;
+  if (ev == MG_EV_POLL) {
+    uint64_t now = *(uint64_t *) ev_data;
+    for (d = (struct dns_data *) c->mgr->active_dns_requests; d != NULL;
+         d = tmp) {
+      tmp = d->next;
+      // MG_DEBUG ("%lu %lu dns poll", d->expire, now));
+      if (now > d->expire) mg_error(d->c, "DNS timeout");
+    }
+  } else if (ev == MG_EV_READ) {
+    struct mg_dns_message dm;
+    int resolved = 0;
+    if (mg_dns_parse(c->recv.buf, c->recv.len, &dm) == false) {
+      MG_ERROR(("Unexpected DNS response:"));
+      mg_hexdump(c->recv.buf, c->recv.len);
+    } else {
+      MG_VERBOSE(("%s %d", dm.name, dm.resolved));
+      for (d = (struct dns_data *) c->mgr->active_dns_requests; d != NULL;
+           d = tmp) {
+        tmp = d->next;
+        // MG_INFO(("d %p %hu %hu", d, d->txnid, dm.txnid));
+        if (dm.txnid != d->txnid) continue;
+        if (d->c->is_resolving) {
+          if (dm.resolved) {
+            char buf[100];
+            dm.addr.port = d->c->rem.port;  // Save port
+            d->c->rem = dm.addr;            // Copy resolved address
+            MG_DEBUG(("%lu %s is %s", d->c->id, dm.name,
+                      mg_ntoa(&d->c->rem, buf, sizeof(buf))));
+            mg_connect_resolved(d->c);
+#if MG_ENABLE_IPV6
+          } else if (dm.addr.is_ip6 == false && dm.name[0] != '\0' &&
+                     c->mgr->use_dns6 == false) {
+            struct mg_str x = mg_str(dm.name);
+            mg_sendnsreq(d->c, &x, c->mgr->dnstimeout, &c->mgr->dns6, true);
+#endif
+          } else {
+            mg_error(d->c, "%s DNS lookup failed", dm.name);
+          }
+        } else {
+          MG_ERROR(("%lu already resolved", d->c->id));
+        }
+        mg_dns_free(c, d);
+        resolved = 1;
+      }
+    }
+    if (!resolved) MG_ERROR(("stray DNS reply"));
+    c->recv.len = 0;
+  } else if (ev == MG_EV_CLOSE) {
+    for (d = (struct dns_data *) c->mgr->active_dns_requests; d != NULL;
+         d = tmp) {
+      tmp = d->next;
+      mg_error(d->c, "DNS error");
+      mg_dns_free(c, d);
+    }
+  }
+  (void) fn_data;
+}
+
+static bool mg_dns_send(struct mg_connection *c, const struct mg_str *name,
+                        uint16_t txnid, bool ipv6) {
+  struct {
+    struct mg_dns_header header;
+    uint8_t data[256];
+  } pkt;
+  size_t i, n;
+  memset(&pkt, 0, sizeof(pkt));
+  pkt.header.txnid = mg_htons(txnid);
+  pkt.header.flags = mg_htons(0x100);
+  pkt.header.num_questions = mg_htons(1);
+  for (i = n = 0; i < sizeof(pkt.data) - 5; i++) {
+    if (name->ptr[i] == '.' || i >= name->len) {
+      pkt.data[n] = (uint8_t) (i - n);
+      memcpy(&pkt.data[n + 1], name->ptr + n, i - n);
+      n = i + 1;
+    }
+    if (i >= name->len) break;
+  }
+  memcpy(&pkt.data[n], "\x00\x00\x01\x00\x01", 5);  // A query
+  n += 5;
+  if (ipv6) pkt.data[n - 3] = 0x1c;  // AAAA query
+  // memcpy(&pkt.data[n], "\xc0\x0c\x00\x1c\x00\x01", 6);  // AAAA query
+  // n += 6;
+  return mg_send(c, &pkt, sizeof(pkt.header) + n);
+}
+
+static void mg_sendnsreq(struct mg_connection *c, struct mg_str *name, int ms,
+                         struct mg_dns *dnsc, bool ipv6) {
+  struct dns_data *d = NULL;
+  if (dnsc->url == NULL) {
+    mg_error(c, "DNS server URL is NULL. Call mg_mgr_init()");
+  } else if (dnsc->c == NULL) {
+    dnsc->c = mg_connect(c->mgr, dnsc->url, NULL, NULL);
+    if (dnsc->c != NULL) {
+      dnsc->c->pfn = dns_cb;
+      // dnsc->c->is_hexdumping = 1;
+    }
+  }
+  if (dnsc->c == NULL) {
+    mg_error(c, "resolver");
+  } else if ((d = (struct dns_data *) calloc(1, sizeof(*d))) == NULL) {
+    mg_error(c, "resolve OOM");
+  } else {
+    struct dns_data *reqs = (struct dns_data *) c->mgr->active_dns_requests;
+    char buf[100];
+    d->txnid = reqs ? (uint16_t) (reqs->txnid + 1) : 1;
+    d->next = (struct dns_data *) c->mgr->active_dns_requests;
+    c->mgr->active_dns_requests = d;
+    d->expire = mg_millis() + (uint64_t) ms;
+    d->c = c;
+    c->is_resolving = 1;
+    MG_VERBOSE(("%lu resolving %.*s @ %s, txnid %hu", c->id, (int) name->len,
+                name->ptr, mg_ntoa(&dnsc->c->rem, buf, sizeof(buf)), d->txnid));
+    if (!mg_dns_send(dnsc->c, name, d->txnid, ipv6)) {
+      mg_error(dnsc->c, "DNS send");
+    }
+  }
+}
+
+void mg_resolve(struct mg_connection *c, const char *url) {
+  struct mg_str host = mg_url_host(url);
+  c->rem.port = mg_htons(mg_url_port(url));
+  if (mg_aton(host, &c->rem)) {
+    // host is an IP address, do not fire name resolution
+    mg_connect_resolved(c);
+  } else {
+    // host is not an IP, send DNS resolution request
+    struct mg_dns *dns = c->mgr->use_dns6 ? &c->mgr->dns6 : &c->mgr->dns4;
+    mg_sendnsreq(c, &host, c->mgr->dnstimeout, dns, c->mgr->use_dns6);
+  }
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/event.c"
+#endif
+
+
+
+
+
+void mg_call(struct mg_connection *c, int ev, void *ev_data) {
+  // Run user-defined handler first, in order to give it an ability
+  // to intercept processing (e.g. clean input buffer) before the
+  // protocol handler kicks in
+  if (c->fn != NULL) c->fn(c, ev, ev_data, c->fn_data);
+  if (c->pfn != NULL) c->pfn(c, ev, ev_data, c->pfn_data);
+}
+
+void mg_error(struct mg_connection *c, const char *fmt, ...) {
+  char mem[256], *buf = mem;
+  va_list ap;
+  va_start(ap, fmt);
+  mg_vasprintf(&buf, sizeof(mem), fmt, ap);
+  va_end(ap);
+  MG_ERROR(("%lu %p %s", c->id, c->fd, buf));
+  c->is_closing = 1;             // Set is_closing before sending MG_EV_CALL
+  mg_call(c, MG_EV_ERROR, buf);  // Let user handler to override it
+  if (buf != mem) free(buf);
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/fmt.c"
+#endif
+
+
+
+size_t mg_vasprintf(char **buf, size_t size, const char *fmt, va_list ap) {
+  va_list ap_copy;
+  size_t len;
+
+  va_copy(ap_copy, ap);
+  len = mg_vsnprintf(*buf, size, fmt, &ap_copy);
+  va_end(ap_copy);
+
+  if (len >= size) {
+    //  Allocate a buffer that is large enough
+    if ((*buf = (char *) calloc(1, len + 1)) == NULL) {
+      len = 0;
+    } else {
+      va_copy(ap_copy, ap);
+      len = mg_vsnprintf(*buf, len + 1, fmt, &ap_copy);
+      va_end(ap_copy);
+    }
+  }
+
+  return len;
+}
+
+size_t mg_asprintf(char **buf, size_t size, const char *fmt, ...) {
+  size_t ret;
+  va_list ap;
+  va_start(ap, fmt);
+  ret = mg_vasprintf(buf, size, fmt, ap);
+  va_end(ap);
+  return ret;
+}
+
+char *mg_vmprintf(const char *fmt, va_list ap) {
+  char *s = NULL;
+  mg_vasprintf(&s, 0, fmt, ap);
+  return s;
+}
+
+char *mg_mprintf(const char *fmt, ...) {
+  char *s = NULL;
+  va_list ap;
+  va_start(ap, fmt);
+  mg_vasprintf(&s, 0, fmt, ap);
+  va_end(ap);
+  return s;
+}
+
+size_t mg_rprintf(void (*out)(char, void *), void *ptr, const char *fmt, ...) {
+  size_t len = 0;
+  va_list ap;
+  va_start(ap, fmt);
+  len = mg_vrprintf(out, ptr, fmt, &ap);
+  va_end(ap);
+  return len;
+}
+
+static void mg_putchar_iobuf_static(char ch, void *param) {
+  struct mg_iobuf *io = (struct mg_iobuf *) param;
+  if (io->len + 2 <= io->size) {
+    io->buf[io->len++] = (uint8_t) ch;
+    io->buf[io->len] = 0;
+  }
+}
+
+void mg_putchar_iobuf(char ch, void *param) {
+  struct mg_iobuf *io = (struct mg_iobuf *) param;
+  if (io->len + 2 > io->size) mg_iobuf_resize(io, io->size + 64);
+  if (io->len + 2 <= io->size) {
+    io->buf[io->len++] = (uint8_t) ch;
+    io->buf[io->len] = 0;
+  }
+}
+
+// We don't use realloc() in mongoose, so resort to inefficient calloc
+// Every new character reallocates the whole string
+void mg_putchar_realloc(char ch, void *param) {
+  char *s, *buf = *(char **) param;
+  size_t len = buf == NULL ? 0 : strlen(buf);
+  if ((s = (char *) calloc(1, len + 2)) != NULL) {
+    if (buf != NULL) memcpy(s, buf, len);
+    s[len] = ch;
+    s[len + 1] = '\0';
+    free(buf);
+    *(char **) param = s;
+  }
+}
+
+size_t mg_vsnprintf(char *buf, size_t len, const char *fmt, va_list *ap) {
+  struct mg_iobuf io = {(uint8_t *) buf, len, 0};
+  size_t n = mg_vrprintf(mg_putchar_iobuf_static, &io, fmt, ap);
+  if (n < len) buf[n] = '\0';
+  return n;
+}
+
+static bool is_digit(int c) {
+  return c >= '0' && c <= '9';
+}
+
+size_t mg_lld(char *buf, int64_t val, bool is_signed, bool is_hex) {
+  const char *letters = "0123456789abcdef";
+  uint64_t v = (uint64_t) val;
+  size_t s = 0, n, i;
+  if (is_signed && val < 0) buf[s++] = '-', v = (uint64_t) (-val);
+  // This loop prints a number in reverse order. I guess this is because we
+  // write numbers from right to left: least significant digit comes last.
+  // Maybe because we use Arabic numbers, and Arabs write RTL?
+  if (is_hex) {
+    for (n = 0; v; v >>= 4) buf[s + n++] = letters[v & 15];
+  } else {
+    for (n = 0; v; v /= 10) buf[s + n++] = letters[v % 10];
+  }
+  // Reverse a string
+  for (i = 0; i < n / 2; i++) {
+    char t = buf[s + i];
+    buf[s + i] = buf[s + n - i - 1], buf[s + n - i - 1] = t;
+  }
+  if (val == 0) buf[n++] = '0';  // Handle special case
+  return n + s;
+}
+
+static size_t scpy(void (*out)(char, void *), void *ptr, char *buf,
+                   size_t len) {
+  size_t i = 0;
+  while (i < len && buf[i] != '\0') out(buf[i++], ptr);
+  return i;
+}
+
+static char mg_esc(int c, bool esc) {
+  const char *p, *esc1 = "\b\f\n\r\t\\\"", *esc2 = "bfnrt\\\"";
+  for (p = esc ? esc1 : esc2; *p != '\0'; p++) {
+    if (*p == c) return esc ? esc2[p - esc1] : esc1[p - esc2];
+  }
+  return 0;
+}
+
+static char mg_escape(int c) {
+  return mg_esc(c, true);
+}
+
+static size_t qcpy(void (*out)(char, void *), void *ptr, char *buf,
+                   size_t len) {
+  size_t i = 0, extra = 2;
+  out('"', ptr);
+  for (i = 0; i < len && buf[i] != '\0'; i++) {
+    char c = mg_escape(buf[i]);
+    if (c) {
+      out('\\', ptr), out(c, ptr), extra++;
+    } else {
+      out(buf[i], ptr);
+    }
+  }
+  out('"', ptr);
+  return i + extra;
+}
+
+static size_t bcpy(void (*out)(char, void *), void *ptr, uint8_t *buf,
+                   size_t len) {
+  size_t i, n = 0;
+  const char *t =
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  out('"', ptr), n++;
+  for (i = 0; i < len; i += 3) {
+    uint8_t c1 = buf[i], c2 = i + 1 < len ? buf[i + 1] : 0,
+            c3 = i + 2 < len ? buf[i + 2] : 0;
+    char tmp[4] = {t[c1 >> 2], t[(c1 & 3) << 4 | (c2 >> 4)], '=', '='};
+    if (i + 1 < len) tmp[2] = t[(c2 & 15) << 2 | (c3 >> 6)];
+    if (i + 2 < len) tmp[3] = t[c3 & 63];
+    n += scpy(out, ptr, tmp, sizeof(tmp));
+  }
+  out('"', ptr), n++;
+  return n;
+}
+
+size_t mg_vrprintf(void (*out)(char, void *), void *param, const char *fmt,
+                   va_list *ap) {
+  size_t i = 0, n = 0;
+  while (fmt[i] != '\0') {
+    if (fmt[i] == '%') {
+      size_t j, k, x = 0, is_long = 0, w = 0 /* width */, pr = ~0U /* prec */;
+      char pad = ' ', minus = 0, c = fmt[++i];
+      if (c == '#') x++, c = fmt[++i];
+      if (c == '-') minus++, c = fmt[++i];
+      if (c == '0') pad = '0', c = fmt[++i];
+      while (is_digit(c)) w *= 10, w += (size_t) (c - '0'), c = fmt[++i];
+      if (c == '.') {
+        c = fmt[++i];
+        if (c == '*') {
+          pr = (size_t) va_arg(*ap, int);
+          c = fmt[++i];
+        } else {
+          pr = 0;
+          while (is_digit(c)) pr *= 10, pr += (size_t) (c - '0'), c = fmt[++i];
+        }
+      }
+      while (c == 'h') c = fmt[++i];  // Treat h and hh as int
+      if (c == 'l') {
+        is_long++, c = fmt[++i];
+        if (c == 'l') is_long++, c = fmt[++i];
+      }
+      if (c == 'p') x = 1, is_long = 1;
+      if (c == 'd' || c == 'u' || c == 'x' || c == 'X' || c == 'p' ||
+          c == 'g') {
+        bool s = (c == 'd'), h = (c == 'x' || c == 'X' || c == 'p');
+        char tmp[40];
+        size_t xl = x ? 2 : 0;
+        if (c == 'g' || c == 'f') {
+          double v = va_arg(*ap, double);
+          if (pr == ~0U) pr = 6;
+          k = mg_dtoa(tmp, sizeof(tmp), v, (int) pr);
+        } else if (is_long == 2) {
+          int64_t v = va_arg(*ap, int64_t);
+          k = mg_lld(tmp, v, s, h);
+        } else if (is_long == 1) {
+          long v = va_arg(*ap, long);
+          k = mg_lld(tmp, s ? (int64_t) v : (int64_t) (unsigned long) v, s, h);
+        } else {
+          int v = va_arg(*ap, int);
+          k = mg_lld(tmp, s ? (int64_t) v : (int64_t) (unsigned) v, s, h);
+        }
+        for (j = 0; j < xl && w > 0; j++) w--;
+        for (j = 0; pad == ' ' && !minus && k < w && j + k < w; j++)
+          n += scpy(out, param, &pad, 1);
+        n += scpy(out, param, (char *) "0x", xl);
+        for (j = 0; pad == '0' && k < w && j + k < w; j++)
+          n += scpy(out, param, &pad, 1);
+        n += scpy(out, param, tmp, k);
+        for (j = 0; pad == ' ' && minus && k < w && j + k < w; j++)
+          n += scpy(out, param, &pad, 1);
+      } else if (c == 'M') {
+        mg_pm_t f = va_arg(*ap, mg_pm_t);
+        n += f(out, param, ap);
+      } else if (c == 'c') {
+        int ch = va_arg(*ap, int);
+        out((char) ch, param);
+        n++;
+      } else if (c == 'H') {
+        // Print hex-encoded double-quoted string
+        size_t bl = (size_t) va_arg(*ap, int);
+        uint8_t *p = va_arg(*ap, uint8_t *), dquote = '"';
+        const char *hex = "0123456789abcdef";
+        n += scpy(out, param, (char *) &dquote, 1);
+        for (j = 0; j < bl; j++) {
+          n += scpy(out, param, (char *) &hex[(p[j] >> 4) & 15], 1);
+          n += scpy(out, param, (char *) &hex[p[j] & 15], 1);
+        }
+        n += scpy(out, param, (char *) &dquote, 1);
+      } else if (c == 'V') {
+        // Print base64-encoded double-quoted string
+        size_t len = (size_t) va_arg(*ap, int);
+        uint8_t *buf = va_arg(*ap, uint8_t *);
+        n += bcpy(out, param, buf, len);
+      } else if (c == 's' || c == 'Q') {
+        char *p = va_arg(*ap, char *);
+        size_t (*f)(void (*)(char, void *), void *, char *, size_t) =
+            c == 's' ? scpy : qcpy;
+        if (pr == ~0U) pr = p == NULL ? 0 : strlen(p);
+        for (j = 0; !minus && pr < w && j + pr < w; j++)
+          n += f(out, param, &pad, 1);
+        n += f(out, param, p, pr);
+        for (j = 0; minus && pr < w && j + pr < w; j++)
+          n += f(out, param, &pad, 1);
+      } else if (c == '%') {
+        out('%', param);
+        n++;
+      } else {
+        out('%', param);
+        out(c, param);
+        n += 2;
+      }
+      i++;
+    } else {
+      out(fmt[i], param), n++, i++;
+    }
+  }
+  return n;
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/fs.c"
+#endif
+
+
+
+struct mg_fd *mg_fs_open(struct mg_fs *fs, const char *path, int flags) {
+  struct mg_fd *fd = (struct mg_fd *) calloc(1, sizeof(*fd));
+  if (fd != NULL) {
+    fd->fd = fs->op(path, flags);
+    fd->fs = fs;
+    if (fd->fd == NULL) {
+      free(fd);
+      fd = NULL;
+    }
+  }
+  return fd;
+}
+
+void mg_fs_close(struct mg_fd *fd) {
+  if (fd != NULL) {
+    fd->fs->cl(fd->fd);
+    free(fd);
+  }
+}
+
+char *mg_file_read(struct mg_fs *fs, const char *path, size_t *sizep) {
+  struct mg_fd *fd;
+  char *data = NULL;
+  size_t size = 0;
+  fs->st(path, &size, NULL);
+  if ((fd = mg_fs_open(fs, path, MG_FS_READ)) != NULL) {
+    data = (char *) calloc(1, size + 1);
+    if (data != NULL) {
+      if (fs->rd(fd->fd, data, size) != size) {
+        free(data);
+        data = NULL;
+      } else {
+        data[size] = '\0';
+        if (sizep != NULL) *sizep = size;
+      }
+    }
+    mg_fs_close(fd);
+  }
+  return data;
+}
+
+bool mg_file_write(struct mg_fs *fs, const char *path, const void *buf,
+                   size_t len) {
+  bool result = false;
+  struct mg_fd *fd;
+  char tmp[MG_PATH_MAX];
+  mg_snprintf(tmp, sizeof(tmp), "%s..%d", path, rand());
+  if ((fd = mg_fs_open(fs, tmp, MG_FS_WRITE)) != NULL) {
+    result = fs->wr(fd->fd, buf, len) == len;
+    mg_fs_close(fd);
+    if (result) {
+      fs->rm(path);
+      fs->mv(tmp, path);
+    } else {
+      fs->rm(tmp);
+    }
+  }
+  return result;
+}
+
+bool mg_file_printf(struct mg_fs *fs, const char *path, const char *fmt, ...) {
+  char tmp[256], *buf = tmp;
+  bool result;
+  size_t len;
+  va_list ap;
+  va_start(ap, fmt);
+  len = mg_vasprintf(&buf, sizeof(tmp), fmt, ap);
+  va_end(ap);
+  result = mg_file_write(fs, path, buf, len > 0 ? (size_t) len : 0);
+  if (buf != tmp) free(buf);
+  return result;
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/fs_fat.c"
+#endif
+
+
+
+#if MG_ENABLE_FATFS
+#include <ff.h>
+
+static int mg_days_from_epoch(int y, int m, int d) {
+  y -= m <= 2;
+  int era = y / 400;
+  int yoe = y - era * 400;
+  int doy = (153 * (m + (m > 2 ? -3 : 9)) + 2) / 5 + d - 1;
+  int doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
+  return era * 146097 + doe - 719468;
+}
+
+static time_t mg_timegm(const struct tm *t) {
+  int year = t->tm_year + 1900;
+  int month = t->tm_mon;  // 0-11
+  if (month > 11) {
+    year += month / 12;
+    month %= 12;
+  } else if (month < 0) {
+    int years_diff = (11 - month) / 12;
+    year -= years_diff;
+    month += 12 * years_diff;
+  }
+  int x = mg_days_from_epoch(year, month + 1, t->tm_mday);
+  return 60 * (60 * (24L * x + t->tm_hour) + t->tm_min) + t->tm_sec;
+}
+
+static time_t ff_time_to_epoch(uint16_t fdate, uint16_t ftime) {
+  struct tm tm;
+  memset(&tm, 0, sizeof(struct tm));
+  tm.tm_sec = (ftime << 1) & 0x3e;
+  tm.tm_min = ((ftime >> 5) & 0x3f);
+  tm.tm_hour = ((ftime >> 11) & 0x1f);
+  tm.tm_mday = (fdate & 0x1f);
+  tm.tm_mon = ((fdate >> 5) & 0x0f) - 1;
+  tm.tm_year = ((fdate >> 9) & 0x7f) + 80;
+  return mg_timegm(&tm);
+}
+
+static int ff_stat(const char *path, size_t *size, time_t *mtime) {
+  FILINFO fi;
+  if (path[0] == '\0') {
+    if (size) *size = 0;
+    if (mtime) *mtime = 0;
+    return MG_FS_DIR;
+  } else if (f_stat(path, &fi) == 0) {
+    if (size) *size = (size_t) fi.fsize;
+    if (mtime) *mtime = ff_time_to_epoch(fi.fdate, fi.ftime);
+    return MG_FS_READ | MG_FS_WRITE | ((fi.fattrib & AM_DIR) ? MG_FS_DIR : 0);
+  } else {
+    return 0;
+  }
+}
+
+static void ff_list(const char *dir, void (*fn)(const char *, void *),
+                    void *userdata) {
+  DIR d;
+  FILINFO fi;
+  if (f_opendir(&d, dir) == FR_OK) {
+    while (f_readdir(&d, &fi) == FR_OK && fi.fname[0] != '\0') {
+      if (!strcmp(fi.fname, ".") || !strcmp(fi.fname, "..")) continue;
+      fn(fi.fname, userdata);
+    }
+    f_closedir(&d);
+  }
+}
+
+static void *ff_open(const char *path, int flags) {
+  FIL f;
+  unsigned char mode = FA_READ;
+  if (flags & MG_FS_WRITE) mode |= FA_WRITE | FA_OPEN_ALWAYS | FA_OPEN_APPEND;
+  if (f_open(&f, path, mode) == 0) {
+    FIL *fp = calloc(1, sizeof(*fp));
+    memcpy(fp, &f, sizeof(*fp));
+    return fp;
+  } else {
+    return NULL;
+  }
+}
+
+static void ff_close(void *fp) {
+  if (fp != NULL) {
+    f_close((FIL *) fp);
+    free(fp);
+  }
+}
+
+static size_t ff_read(void *fp, void *buf, size_t len) {
+  UINT n = 0, misalign = ((size_t) buf) & 3;
+  if (misalign) {
+    char aligned[4];
+    f_read((FIL *) fp, aligned, len > misalign ? misalign : len, &n);
+    memcpy(buf, aligned, n);
+  } else {
+    f_read((FIL *) fp, buf, len, &n);
+  }
+  return n;
+}
+
+static size_t ff_write(void *fp, const void *buf, size_t len) {
+  UINT n = 0;
+  return f_write((FIL *) fp, (char *) buf, len, &n) == FR_OK ? n : 0;
+}
+
+static size_t ff_seek(void *fp, size_t offset) {
+  f_lseek((FIL *) fp, offset);
+  return offset;
+}
+
+static bool ff_rename(const char *from, const char *to) {
+  return f_rename(from, to) == FR_OK;
+}
+
+static bool ff_remove(const char *path) {
+  return f_unlink(path) == FR_OK;
+}
+
+static bool ff_mkdir(const char *path) {
+  return f_mkdir(path) == FR_OK;
+}
+
+struct mg_fs mg_fs_fat = {ff_stat,  ff_list, ff_open,   ff_close,  ff_read,
+                          ff_write, ff_seek, ff_rename, ff_remove, ff_mkdir};
+#endif
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/fs_packed.c"
+#endif
+
+
+
+struct packed_file {
+  const char *data;
+  size_t size;
+  size_t pos;
+};
+
+const char *mg_unpack(const char *path, size_t *size, time_t *mtime);
+const char *mg_unlist(size_t no);
+
+#if MG_ENABLE_PACKED_FS
+#else
+const char *mg_unpack(const char *path, size_t *size, time_t *mtime) {
+  (void) path, (void) size, (void) mtime;
+  return NULL;
+}
+const char *mg_unlist(size_t no) {
+  (void) no;
+  return NULL;
+}
+#endif
+
+static int is_dir_prefix(const char *prefix, size_t n, const char *path) {
+  // MG_INFO(("[%.*s] [%s] %c", (int) n, prefix, path, path[n]));
+  return n < strlen(path) && strncmp(prefix, path, n) == 0 &&
+         (n == 0 || path[n] == '/' || path[n - 1] == '/');
+}
+
+static int packed_stat(const char *path, size_t *size, time_t *mtime) {
+  const char *p;
+  size_t i, n = strlen(path);
+  if (mg_unpack(path, size, mtime)) return MG_FS_READ;  // Regular file
+  // Scan all files. If `path` is a dir prefix for any of them, it's a dir
+  for (i = 0; (p = mg_unlist(i)) != NULL; i++) {
+    if (is_dir_prefix(path, n, p)) return MG_FS_DIR;
+  }
+  return 0;
+}
+
+static void packed_list(const char *dir, void (*fn)(const char *, void *),
+                        void *userdata) {
+  char buf[256], tmp[sizeof(buf)];
+  const char *path, *begin, *end;
+  size_t i, n = strlen(dir);
+  tmp[0] = '\0';  // Previously listed entry
+  for (i = 0; (path = mg_unlist(i)) != NULL; i++) {
+    if (!is_dir_prefix(dir, n, path)) continue;
+    begin = &path[n + 1];
+    end = strchr(begin, '/');
+    if (end == NULL) end = begin + strlen(begin);
+    mg_snprintf(buf, sizeof(buf), "%.*s", (int) (end - begin), begin);
+    buf[sizeof(buf) - 1] = '\0';
+    // If this entry has been already listed, skip
+    // NOTE: we're assuming that file list is sorted alphabetically
+    if (strcmp(buf, tmp) == 0) continue;
+    fn(buf, userdata);  // Not yet listed, call user function
+    strcpy(tmp, buf);   // And save this entry as listed
+  }
+}
+
+static void *packed_open(const char *path, int flags) {
+  size_t size = 0;
+  const char *data = mg_unpack(path, &size, NULL);
+  struct packed_file *fp = NULL;
+  if (data == NULL) return NULL;
+  if (flags & MG_FS_WRITE) return NULL;
+  fp = (struct packed_file *) calloc(1, sizeof(*fp));
+  fp->size = size;
+  fp->data = data;
+  return (void *) fp;
+}
+
+static void packed_close(void *fp) {
+  if (fp != NULL) free(fp);
+}
+
+static size_t packed_read(void *fd, void *buf, size_t len) {
+  struct packed_file *fp = (struct packed_file *) fd;
+  if (fp->pos + len > fp->size) len = fp->size - fp->pos;
+  memcpy(buf, &fp->data[fp->pos], len);
+  fp->pos += len;
+  return len;
+}
+
+static size_t packed_write(void *fd, const void *buf, size_t len) {
+  (void) fd, (void) buf, (void) len;
+  return 0;
+}
+
+static size_t packed_seek(void *fd, size_t offset) {
+  struct packed_file *fp = (struct packed_file *) fd;
+  fp->pos = offset;
+  if (fp->pos > fp->size) fp->pos = fp->size;
+  return fp->pos;
+}
+
+static bool packed_rename(const char *from, const char *to) {
+  (void) from, (void) to;
+  return false;
+}
+
+static bool packed_remove(const char *path) {
+  (void) path;
+  return false;
+}
+
+static bool packed_mkdir(const char *path) {
+  (void) path;
+  return false;
+}
+
+struct mg_fs mg_fs_packed = {
+    packed_stat,  packed_list, packed_open,   packed_close,  packed_read,
+    packed_write, packed_seek, packed_rename, packed_remove, packed_mkdir};
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/fs_posix.c"
+#endif
+
+
+#if MG_ENABLE_FILE
+
+#ifndef MG_STAT_STRUCT
+#define MG_STAT_STRUCT stat
+#endif
+
+#ifndef MG_STAT_FUNC
+#define MG_STAT_FUNC stat
+#endif
+
+static int p_stat(const char *path, size_t *size, time_t *mtime) {
+#if !defined(S_ISDIR)
+  MG_ERROR(("stat() API is not supported. %p %p %p", path, size, mtime));
+  return 0;
+#else
+#if MG_ARCH == MG_ARCH_WIN32
+  struct _stati64 st;
+  wchar_t tmp[PATH_MAX];
+  MultiByteToWideChar(CP_UTF8, 0, path, -1, tmp, sizeof(tmp) / sizeof(tmp[0]));
+  if (_wstati64(tmp, &st) != 0) return 0;
+#else
+  struct MG_STAT_STRUCT st;
+  if (MG_STAT_FUNC(path, &st) != 0) return 0;
+#endif
+  if (size) *size = (size_t) st.st_size;
+  if (mtime) *mtime = st.st_mtime;
+  return MG_FS_READ | MG_FS_WRITE | (S_ISDIR(st.st_mode) ? MG_FS_DIR : 0);
+#endif
+}
+
+#if MG_ARCH == MG_ARCH_WIN32
+struct dirent {
+  char d_name[MAX_PATH];
+};
+
+typedef struct win32_dir {
+  HANDLE handle;
+  WIN32_FIND_DATAW info;
+  struct dirent result;
+} DIR;
+
+int gettimeofday(struct timeval *tv, void *tz) {
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+
+  if (tv != NULL) {
+    GetSystemTimeAsFileTime(&ft);
+    tmpres |= ft.dwHighDateTime;
+    tmpres <<= 32;
+    tmpres |= ft.dwLowDateTime;
+    tmpres /= 10;  // convert into microseconds
+    tmpres -= (int64_t) 11644473600000000;
+    tv->tv_sec = (long) (tmpres / 1000000UL);
+    tv->tv_usec = (long) (tmpres % 1000000UL);
+  }
+  (void) tz;
+  return 0;
+}
+
+static int to_wchar(const char *path, wchar_t *wbuf, size_t wbuf_len) {
+  int ret;
+  char buf[MAX_PATH * 2], buf2[MAX_PATH * 2], *p;
+  strncpy(buf, path, sizeof(buf));
+  buf[sizeof(buf) - 1] = '\0';
+  // Trim trailing slashes. Leave backslash for paths like "X:\"
+  p = buf + strlen(buf) - 1;
+  while (p > buf && p[-1] != ':' && (p[0] == '\\' || p[0] == '/')) *p-- = '\0';
+  memset(wbuf, 0, wbuf_len * sizeof(wchar_t));
+  ret = MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, (int) wbuf_len);
+  // Convert back to Unicode. If doubly-converted string does not match the
+  // original, something is fishy, reject.
+  WideCharToMultiByte(CP_UTF8, 0, wbuf, (int) wbuf_len, buf2, sizeof(buf2),
+                      NULL, NULL);
+  if (strcmp(buf, buf2) != 0) {
+    wbuf[0] = L'\0';
+    ret = 0;
+  }
+  return ret;
+}
+
+DIR *opendir(const char *name) {
+  DIR *d = NULL;
+  wchar_t wpath[MAX_PATH];
+  DWORD attrs;
+
+  if (name == NULL) {
+    SetLastError(ERROR_BAD_ARGUMENTS);
+  } else if ((d = (DIR *) calloc(1, sizeof(*d))) == NULL) {
+    SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+  } else {
+    to_wchar(name, wpath, sizeof(wpath) / sizeof(wpath[0]));
+    attrs = GetFileAttributesW(wpath);
+    if (attrs != 0Xffffffff && (attrs & FILE_ATTRIBUTE_DIRECTORY)) {
+      (void) wcscat(wpath, L"\\*");
+      d->handle = FindFirstFileW(wpath, &d->info);
+      d->result.d_name[0] = '\0';
+    } else {
+      free(d);
+      d = NULL;
+    }
+  }
+  return d;
+}
+
+int closedir(DIR *d) {
+  int result = 0;
+  if (d != NULL) {
+    if (d->handle != INVALID_HANDLE_VALUE)
+      result = FindClose(d->handle) ? 0 : -1;
+    free(d);
+  } else {
+    result = -1;
+    SetLastError(ERROR_BAD_ARGUMENTS);
+  }
+  return result;
+}
+
+struct dirent *readdir(DIR *d) {
+  struct dirent *result = NULL;
+  if (d != NULL) {
+    memset(&d->result, 0, sizeof(d->result));
+    if (d->handle != INVALID_HANDLE_VALUE) {
+      result = &d->result;
+      WideCharToMultiByte(CP_UTF8, 0, d->info.cFileName, -1, result->d_name,
+                          sizeof(result->d_name), NULL, NULL);
+      if (!FindNextFileW(d->handle, &d->info)) {
+        FindClose(d->handle);
+        d->handle = INVALID_HANDLE_VALUE;
+      }
+    } else {
+      SetLastError(ERROR_FILE_NOT_FOUND);
+    }
+  } else {
+    SetLastError(ERROR_BAD_ARGUMENTS);
+  }
+  return result;
+}
+#endif
+
+static void p_list(const char *dir, void (*fn)(const char *, void *),
+                   void *userdata) {
+#if MG_ENABLE_DIRLIST
+  struct dirent *dp;
+  DIR *dirp;
+  if ((dirp = (opendir(dir))) == NULL) return;
+  while ((dp = readdir(dirp)) != NULL) {
+    if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) continue;
+    fn(dp->d_name, userdata);
+  }
+  closedir(dirp);
+#else
+  (void) dir, (void) fn, (void) userdata;
+#endif
+}
+
+static void *p_open(const char *path, int flags) {
+  const char *mode = flags == MG_FS_READ ? "rb" : "a+b";
+#if MG_ARCH == MG_ARCH_WIN32
+  wchar_t b1[PATH_MAX], b2[10];
+  MultiByteToWideChar(CP_UTF8, 0, path, -1, b1, sizeof(b1) / sizeof(b1[0]));
+  MultiByteToWideChar(CP_UTF8, 0, mode, -1, b2, sizeof(b2) / sizeof(b2[0]));
+  return (void *) _wfopen(b1, b2);
+#else
+  return (void *) fopen(path, mode);
+#endif
+}
+
+static void p_close(void *fp) {
+  fclose((FILE *) fp);
+}
+
+static size_t p_read(void *fp, void *buf, size_t len) {
+  return fread(buf, 1, len, (FILE *) fp);
+}
+
+static size_t p_write(void *fp, const void *buf, size_t len) {
+  return fwrite(buf, 1, len, (FILE *) fp);
+}
+
+static size_t p_seek(void *fp, size_t offset) {
+#if (defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64) ||  \
+    (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || \
+    (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600)
+  if (fseeko((FILE *) fp, (off_t) offset, SEEK_SET) != 0) (void) 0;
+#else
+  if (fseek((FILE *) fp, (long) offset, SEEK_SET) != 0) (void) 0;
+#endif
+  return (size_t) ftell((FILE *) fp);
+}
+
+static bool p_rename(const char *from, const char *to) {
+  return rename(from, to) == 0;
+}
+
+static bool p_remove(const char *path) {
+  return remove(path) == 0;
+}
+
+static bool p_mkdir(const char *path) {
+  return mkdir(path, 0775) == 0;
+}
+
+#else
+
+static int p_stat(const char *path, size_t *size, time_t *mtime) {
+  (void) path, (void) size, (void) mtime;
+  return 0;
+}
+static void p_list(const char *path, void (*fn)(const char *, void *),
+                   void *userdata) {
+  (void) path, (void) fn, (void) userdata;
+}
+static void *p_open(const char *path, int flags) {
+  (void) path, (void) flags;
+  return NULL;
+}
+static void p_close(void *fp) {
+  (void) fp;
+}
+static size_t p_read(void *fd, void *buf, size_t len) {
+  (void) fd, (void) buf, (void) len;
+  return 0;
+}
+static size_t p_write(void *fd, const void *buf, size_t len) {
+  (void) fd, (void) buf, (void) len;
+  return 0;
+}
+static size_t p_seek(void *fd, size_t offset) {
+  (void) fd, (void) offset;
+  return (size_t) ~0;
+}
+static bool p_rename(const char *from, const char *to) {
+  (void) from, (void) to;
+  return false;
+}
+static bool p_remove(const char *path) {
+  (void) path;
+  return false;
+}
+static bool p_mkdir(const char *path) {
+  (void) path;
+  return false;
+}
+#endif
+
+struct mg_fs mg_fs_posix = {p_stat,  p_list, p_open,   p_close,  p_read,
+                            p_write, p_seek, p_rename, p_remove, p_mkdir};
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/http.c"
+#endif
+
+
+
+
+
+
+
+
+
+
+// Multipart POST example:
+// --xyz
+// Content-Disposition: form-data; name="val"
+//
+// abcdef
+// --xyz
+// Content-Disposition: form-data; name="foo"; filename="a.txt"
+// Content-Type: text/plain
+//
+// hello world
+//
+// --xyz--
+size_t mg_http_next_multipart(struct mg_str body, size_t ofs,
+                              struct mg_http_part *part) {
+  struct mg_str cd = mg_str_n("Content-Disposition", 19);
+  const char *s = body.ptr;
+  size_t b = ofs, h1, h2, b1, b2, max = body.len;
+
+  // Init part params
+  if (part != NULL) part->name = part->filename = part->body = mg_str_n(0, 0);
+
+  // Skip boundary
+  while (b + 2 < max && s[b] != '\r' && s[b + 1] != '\n') b++;
+  if (b <= ofs || b + 2 >= max) return 0;
+  // MG_INFO(("B: %zu %zu [%.*s]", ofs, b - ofs, (int) (b - ofs), s));
+
+  // Skip headers
+  h1 = h2 = b + 2;
+  for (;;) {
+    while (h2 + 2 < max && s[h2] != '\r' && s[h2 + 1] != '\n') h2++;
+    if (h2 == h1) break;
+    if (h2 + 2 >= max) return 0;
+    // MG_INFO(("Header: [%.*s]", (int) (h2 - h1), &s[h1]));
+    if (part != NULL && h1 + cd.len + 2 < h2 && s[h1 + cd.len] == ':' &&
+        mg_ncasecmp(&s[h1], cd.ptr, cd.len) == 0) {
+      struct mg_str v = mg_str_n(&s[h1 + cd.len + 2], h2 - (h1 + cd.len + 2));
+      part->name = mg_http_get_header_var(v, mg_str_n("name", 4));
+      part->filename = mg_http_get_header_var(v, mg_str_n("filename", 8));
+    }
+    h1 = h2 = h2 + 2;
+  }
+  b1 = b2 = h2 + 2;
+  while (b2 + 2 + (b - ofs) + 2 < max && !(s[b2] == '\r' && s[b2 + 1] == '\n' &&
+                                           memcmp(&s[b2 + 2], s, b - ofs) == 0))
+    b2++;
+
+  if (b2 + 2 >= max) return 0;
+  if (part != NULL) part->body = mg_str_n(&s[b1], b2 - b1);
+  // MG_INFO(("Body: [%.*s]", (int) (b2 - b1), &s[b1]));
+  return b2 + 2;
+}
+
+void mg_http_bauth(struct mg_connection *c, const char *user,
+                   const char *pass) {
+  struct mg_str u = mg_str(user), p = mg_str(pass);
+  size_t need = c->send.len + 36 + (u.len + p.len) * 2;
+  if (c->send.size < need) mg_iobuf_resize(&c->send, need);
+  if (c->send.size >= need) {
+    int i, n = 0;
+    char *buf = (char *) &c->send.buf[c->send.len + 21];
+    memcpy(&buf[-21], "Authorization: Basic ", 21);  // DON'T use mg_send!
+    for (i = 0; i < (int) u.len; i++) {
+      n = mg_base64_update(((unsigned char *) u.ptr)[i], buf, n);
+    }
+    if (p.len > 0) {
+      n = mg_base64_update(':', buf, n);
+      for (i = 0; i < (int) p.len; i++) {
+        n = mg_base64_update(((unsigned char *) p.ptr)[i], buf, n);
+      }
+    }
+    n = mg_base64_final(buf, n);
+    c->send.len += 21 + (size_t) n + 2;
+    memcpy(&c->send.buf[c->send.len - 2], "\r\n", 2);
+  } else {
+    MG_ERROR(("%lu %s cannot resize iobuf %d->%d ", c->id, c->label,
+              (int) c->send.size, (int) need));
+  }
+}
+
+struct mg_str mg_http_var(struct mg_str buf, struct mg_str name) {
+  struct mg_str k, v, result = mg_str_n(NULL, 0);
+  while (mg_split(&buf, &k, &v, '&')) {
+    if (name.len == k.len && mg_ncasecmp(name.ptr, k.ptr, k.len) == 0) {
+      result = v;
+      break;
+    }
+  }
+  return result;
+}
+
+int mg_http_get_var(const struct mg_str *buf, const char *name, char *dst,
+                    size_t dst_len) {
+  int len;
+  if (dst == NULL || dst_len == 0) {
+    len = -2;  // Bad destination
+  } else if (buf->ptr == NULL || name == NULL || buf->len == 0) {
+    len = -1;  // Bad source
+    dst[0] = '\0';
+  } else {
+    struct mg_str v = mg_http_var(*buf, mg_str(name));
+    if (v.ptr == NULL) {
+      len = -4;  // Name does not exist
+    } else {
+      len = mg_url_decode(v.ptr, v.len, dst, dst_len, 1);
+      if (len < 0) len = -3;  // Failed to decode
+    }
+  }
+  return len;
+}
+
+static bool isx(int c) {
+  return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
+         (c >= 'A' && c <= 'F');
+}
+
+int mg_url_decode(const char *src, size_t src_len, char *dst, size_t dst_len,
+                  int is_form_url_encoded) {
+  size_t i, j;
+  for (i = j = 0; i < src_len && j + 1 < dst_len; i++, j++) {
+    if (src[i] == '%') {
+      // Use `i + 2 < src_len`, not `i < src_len - 2`, note small src_len
+      if (i + 2 < src_len && isx(src[i + 1]) && isx(src[i + 2])) {
+        mg_unhex(src + i + 1, 2, (uint8_t *) &dst[j]);
+        i += 2;
+      } else {
+        return -1;
+      }
+    } else if (is_form_url_encoded && src[i] == '+') {
+      dst[j] = ' ';
+    } else {
+      dst[j] = src[i];
+    }
+  }
+  if (j < dst_len) dst[j] = '\0';  // Null-terminate the destination
+  return i >= src_len && j < dst_len ? (int) j : -1;
+}
+
+static bool isok(uint8_t c) {
+  return c == '\n' || c == '\r' || c >= ' ';
+}
+
+int mg_http_get_request_len(const unsigned char *buf, size_t buf_len) {
+  size_t i;
+  for (i = 0; i < buf_len; i++) {
+    if (!isok(buf[i])) return -1;
+    if ((i > 0 && buf[i] == '\n' && buf[i - 1] == '\n') ||
+        (i > 3 && buf[i] == '\n' && buf[i - 1] == '\r' && buf[i - 2] == '\n'))
+      return (int) i + 1;
+  }
+  return 0;
+}
+
+static const char *skip(const char *s, const char *e, const char *d,
+                        struct mg_str *v) {
+  v->ptr = s;
+  while (s < e && *s != '\n' && strchr(d, *s) == NULL) s++;
+  v->len = (size_t) (s - v->ptr);
+  while (s < e && strchr(d, *s) != NULL) s++;
+  return s;
+}
+
+struct mg_str *mg_http_get_header(struct mg_http_message *h, const char *name) {
+  size_t i, n = strlen(name), max = sizeof(h->headers) / sizeof(h->headers[0]);
+  for (i = 0; i < max && h->headers[i].name.len > 0; i++) {
+    struct mg_str *k = &h->headers[i].name, *v = &h->headers[i].value;
+    if (n == k->len && mg_ncasecmp(k->ptr, name, n) == 0) return v;
+  }
+  return NULL;
+}
+
+static void mg_http_parse_headers(const char *s, const char *end,
+                                  struct mg_http_header *h, int max_headers) {
+  int i;
+  for (i = 0; i < max_headers; i++) {
+    struct mg_str k, v, tmp;
+    const char *he = skip(s, end, "\n", &tmp);
+    s = skip(s, he, ": \r\n", &k);
+    s = skip(s, he, "\r\n", &v);
+    if (k.len == tmp.len) continue;
+    while (v.len > 0 && v.ptr[v.len - 1] == ' ') v.len--;  // Trim spaces
+    if (k.len == 0) break;
+    // MG_INFO(("--HH [%.*s] [%.*s] [%.*s]", (int) tmp.len - 1, tmp.ptr,
+    //(int) k.len, k.ptr, (int) v.len, v.ptr));
+    h[i].name = k;
+    h[i].value = v;
+  }
+}
+
+int mg_http_parse(const char *s, size_t len, struct mg_http_message *hm) {
+  int is_response, req_len = mg_http_get_request_len((unsigned char *) s, len);
+  const char *end = s + req_len, *qs;
+  struct mg_str *cl;
+
+  memset(hm, 0, sizeof(*hm));
+  if (req_len <= 0) return req_len;
+
+  hm->message.ptr = hm->head.ptr = s;
+  hm->body.ptr = end;
+  hm->head.len = (size_t) req_len;
+  hm->chunk.ptr = end;
+  hm->message.len = hm->body.len = (size_t) ~0;  // Set body length to infinite
+
+  // Parse request line
+  s = skip(s, end, " ", &hm->method);
+  s = skip(s, end, " ", &hm->uri);
+  s = skip(s, end, "\r\n", &hm->proto);
+
+  // Sanity check. Allow protocol/reason to be empty
+  if (hm->method.len == 0 || hm->uri.len == 0) return -1;
+
+  // If URI contains '?' character, setup query string
+  if ((qs = (const char *) memchr(hm->uri.ptr, '?', hm->uri.len)) != NULL) {
+    hm->query.ptr = qs + 1;
+    hm->query.len = (size_t) (&hm->uri.ptr[hm->uri.len] - (qs + 1));
+    hm->uri.len = (size_t) (qs - hm->uri.ptr);
+  }
+
+  mg_http_parse_headers(s, end, hm->headers,
+                        sizeof(hm->headers) / sizeof(hm->headers[0]));
+  if ((cl = mg_http_get_header(hm, "Content-Length")) != NULL) {
+    hm->body.len = (size_t) mg_to64(*cl);
+    hm->message.len = (size_t) req_len + hm->body.len;
+  }
+
+  // mg_http_parse() is used to parse both HTTP requests and HTTP
+  // responses. If HTTP response does not have Content-Length set, then
+  // body is read until socket is closed, i.e. body.len is infinite (~0).
+  //
+  // For HTTP requests though, according to
+  // http://tools.ietf.org/html/rfc7231#section-8.1.3,
+  // only POST and PUT methods have defined body semantics.
+  // Therefore, if Content-Length is not specified and methods are
+  // not one of PUT or POST, set body length to 0.
+  //
+  // So, if it is HTTP request, and Content-Length is not set,
+  // and method is not (PUT or POST) then reset body length to zero.
+  is_response = mg_ncasecmp(hm->method.ptr, "HTTP/", 5) == 0;
+  if (hm->body.len == (size_t) ~0 && !is_response &&
+      mg_vcasecmp(&hm->method, "PUT") != 0 &&
+      mg_vcasecmp(&hm->method, "POST") != 0) {
+    hm->body.len = 0;
+    hm->message.len = (size_t) req_len;
+  }
+
+  // The 204 (No content) responses also have 0 body length
+  if (hm->body.len == (size_t) ~0 && is_response &&
+      mg_vcasecmp(&hm->uri, "204") == 0) {
+    hm->body.len = 0;
+    hm->message.len = (size_t) req_len;
+  }
+
+  return req_len;
+}
+
+static void mg_http_vprintf_chunk(struct mg_connection *c, const char *fmt,
+                                  va_list ap) {
+  char mem[256], *buf = mem;
+  size_t len = mg_vasprintf(&buf, sizeof(mem), fmt, ap);
+  mg_printf(c, "%lx\r\n", (unsigned long) len);
+  mg_send(c, buf, len > 0 ? (size_t) len : 0);
+  mg_send(c, "\r\n", 2);
+  if (buf != mem) free(buf);
+}
+
+void mg_http_printf_chunk(struct mg_connection *c, const char *fmt, ...) {
+  va_list ap;
+  va_start(ap, fmt);
+  mg_http_vprintf_chunk(c, fmt, ap);
+  va_end(ap);
+}
+
+void mg_http_write_chunk(struct mg_connection *c, const char *buf, size_t len) {
+  mg_printf(c, "%lx\r\n", (unsigned long) len);
+  mg_send(c, buf, len);
+  mg_send(c, "\r\n", 2);
+}
+
+// clang-format off
+static const char *mg_http_status_code_str(int status_code) {
+  switch (status_code) {
+    case 100: return "Continue";
+    case 201: return "Created";
+    case 202: return "Accepted";
+    case 204: return "No Content";
+    case 206: return "Partial Content";
+    case 301: return "Moved Permanently";
+    case 302: return "Found";
+    case 304: return "Not Modified";
+    case 400: return "Bad Request";
+    case 401: return "Unauthorized";
+    case 403: return "Forbidden";
+    case 404: return "Not Found";
+    case 418: return "I'm a teapot";
+    case 500: return "Internal Server Error";
+    case 501: return "Not Implemented";
+    default: return "OK";
+  }
+}
+// clang-format on
+
+void mg_http_reply(struct mg_connection *c, int code, const char *headers,
+                   const char *fmt, ...) {
+  char mem[256], *buf = mem;
+  va_list ap;
+  size_t len;
+  va_start(ap, fmt);
+  len = mg_vasprintf(&buf, sizeof(mem), fmt, ap);
+  va_end(ap);
+  mg_printf(c, "HTTP/1.1 %d %s\r\n%sContent-Length: %d\r\n\r\n", code,
+            mg_http_status_code_str(code), headers == NULL ? "" : headers, len);
+  mg_send(c, buf, len > 0 ? len : 0);
+  if (buf != mem) free(buf);
+}
+
+static void http_cb(struct mg_connection *, int, void *, void *);
+static void restore_http_cb(struct mg_connection *c) {
+  mg_fs_close((struct mg_fd *) c->pfn_data);
+  c->pfn_data = NULL;
+  c->pfn = http_cb;
+}
+
+char *mg_http_etag(char *buf, size_t len, size_t size, time_t mtime);
+char *mg_http_etag(char *buf, size_t len, size_t size, time_t mtime) {
+  mg_snprintf(buf, len, "\"%lld.%lld\"", (int64_t) mtime, (int64_t) size);
+  return buf;
+}
+
+static void static_cb(struct mg_connection *c, int ev, void *ev_data,
+                      void *fn_data) {
+  if (ev == MG_EV_WRITE || ev == MG_EV_POLL) {
+    struct mg_fd *fd = (struct mg_fd *) fn_data;
+    // Read to send IO buffer directly, avoid extra on-stack buffer
+    size_t n, max = MG_IO_SIZE, space, *cl = (size_t *) c->label;
+    if (c->send.size < max) mg_iobuf_resize(&c->send, max);
+    if (c->send.len >= c->send.size) return;  // Rate limit
+    if ((space = c->send.size - c->send.len) > *cl) space = *cl;
+    n = fd->fs->rd(fd->fd, c->send.buf + c->send.len, space);
+    c->send.len += n;
+    *cl -= n;
+    if (n == 0) restore_http_cb(c);
+  } else if (ev == MG_EV_CLOSE) {
+    restore_http_cb(c);
+  }
+  (void) ev_data;
+}
+
+// Known mime types. Keep it outside guess_content_type() function, since
+// some environments don't like it defined there.
+// clang-format off
+static struct mg_str s_known_types[] = {
+    MG_C_STR("html"), MG_C_STR("text/html; charset=utf-8"),
+    MG_C_STR("htm"), MG_C_STR("text/html; charset=utf-8"),
+    MG_C_STR("css"), MG_C_STR("text/css; charset=utf-8"),
+    MG_C_STR("js"), MG_C_STR("text/javascript; charset=utf-8"),
+    MG_C_STR("gif"), MG_C_STR("image/gif"),
+    MG_C_STR("png"), MG_C_STR("image/png"),
+    MG_C_STR("jpg"), MG_C_STR("image/jpeg"),
+    MG_C_STR("jpeg"), MG_C_STR("image/jpeg"),
+    MG_C_STR("woff"), MG_C_STR("font/woff"),
+    MG_C_STR("ttf"), MG_C_STR("font/ttf"),
+    MG_C_STR("svg"), MG_C_STR("image/svg+xml"),
+    MG_C_STR("txt"), MG_C_STR("text/plain; charset=utf-8"),
+    MG_C_STR("avi"), MG_C_STR("video/x-msvideo"),
+    MG_C_STR("csv"), MG_C_STR("text/csv"),
+    MG_C_STR("doc"), MG_C_STR("application/msword"),
+    MG_C_STR("exe"), MG_C_STR("application/octet-stream"),
+    MG_C_STR("gz"), MG_C_STR("application/gzip"),
+    MG_C_STR("ico"), MG_C_STR("image/x-icon"),
+    MG_C_STR("json"), MG_C_STR("application/json"),
+    MG_C_STR("mov"), MG_C_STR("video/quicktime"),
+    MG_C_STR("mp3"), MG_C_STR("audio/mpeg"),
+    MG_C_STR("mp4"), MG_C_STR("video/mp4"),
+    MG_C_STR("mpeg"), MG_C_STR("video/mpeg"),
+    MG_C_STR("pdf"), MG_C_STR("application/pdf"),
+    MG_C_STR("shtml"), MG_C_STR("text/html; charset=utf-8"),
+    MG_C_STR("tgz"), MG_C_STR("application/tar-gz"),
+    MG_C_STR("wav"), MG_C_STR("audio/wav"),
+    MG_C_STR("webp"), MG_C_STR("image/webp"),
+    MG_C_STR("zip"), MG_C_STR("application/zip"),
+    MG_C_STR("3gp"), MG_C_STR("video/3gpp"),
+    {0, 0},
+};
+// clang-format on
+
+static struct mg_str guess_content_type(struct mg_str path, const char *extra) {
+  struct mg_str k, v, s = mg_str(extra);
+  size_t i = 0;
+
+  // Shrink path to its extension only
+  while (i < path.len && path.ptr[path.len - i - 1] != '.') i++;
+  path.ptr += path.len - i;
+  path.len = i;
+
+  // Process user-provided mime type overrides, if any
+  while (mg_commalist(&s, &k, &v)) {
+    if (mg_strcmp(path, k) == 0) return v;
+  }
+
+  // Process built-in mime types
+  for (i = 0; s_known_types[i].ptr != NULL; i += 2) {
+    if (mg_strcmp(path, s_known_types[i]) == 0) return s_known_types[i + 1];
+  }
+
+  return mg_str("text/plain; charset=utf-8");
+}
+
+static int getrange(struct mg_str *s, int64_t *a, int64_t *b) {
+  size_t i, numparsed = 0;
+  // MG_INFO(("%.*s", (int) s->len, s->ptr));
+  for (i = 0; i + 6 < s->len; i++) {
+    if (memcmp(&s->ptr[i], "bytes=", 6) == 0) {
+      struct mg_str p = mg_str_n(s->ptr + i + 6, s->len - i - 6);
+      if (p.len > 0 && p.ptr[0] >= '0' && p.ptr[0] <= '9') numparsed++;
+      *a = mg_to64(p);
+      // MG_INFO(("PPP [%.*s] %d", (int) p.len, p.ptr, numparsed));
+      while (p.len && p.ptr[0] >= '0' && p.ptr[0] <= '9') p.ptr++, p.len--;
+      if (p.len && p.ptr[0] == '-') p.ptr++, p.len--;
+      *b = mg_to64(p);
+      if (p.len > 0 && p.ptr[0] >= '0' && p.ptr[0] <= '9') numparsed++;
+      // MG_INFO(("PPP [%.*s] %d", (int) p.len, p.ptr, numparsed));
+      break;
+    }
+  }
+  return (int) numparsed;
+}
+
+void mg_http_serve_file(struct mg_connection *c, struct mg_http_message *hm,
+                        const char *path,
+                        const struct mg_http_serve_opts *opts) {
+  char etag[64], tmp[MG_PATH_MAX];
+  struct mg_fs *fs = opts->fs == NULL ? &mg_fs_posix : opts->fs;
+  struct mg_fd *fd = path == NULL ? NULL : mg_fs_open(fs, path, MG_FS_READ);
+  size_t size = 0;
+  time_t mtime = 0;
+  struct mg_str *inm = NULL;
+  struct mg_str mime = guess_content_type(mg_str(path), opts->mime_types);
+  bool gzip = false;
+
+  // If file does not exist, we try to open file PATH.gz - and if such
+  // pre-compressed .gz file exists, serve it with the Content-Encoding: gzip
+  // Note - we ignore Accept-Encoding, cause we don't have a choice
+  if (fd == NULL) {
+    MG_DEBUG(("NULL [%s]", path));
+    mg_snprintf(tmp, sizeof(tmp), "%s.gz", path);
+    if ((fd = mg_fs_open(fs, tmp, MG_FS_READ)) != NULL) {
+      gzip = true;
+      path = tmp;
+    } else if (opts->page404 != NULL) {
+      // No precompressed file, serve 404
+      fd = mg_fs_open(fs, opts->page404, MG_FS_READ);
+      mime = guess_content_type(mg_str(path), opts->mime_types);
+      path = opts->page404;
+    }
+  }
+
+  if (fd == NULL || fs->st(path, &size, &mtime) == 0) {
+    mg_http_reply(c, 404, opts->extra_headers, "Not found\n");
+    mg_fs_close(fd);
+    // NOTE: mg_http_etag() call should go first!
+  } else if (mg_http_etag(etag, sizeof(etag), size, mtime) != NULL &&
+             (inm = mg_http_get_header(hm, "If-None-Match")) != NULL &&
+             mg_vcasecmp(inm, etag) == 0) {
+    mg_fs_close(fd);
+    mg_printf(c, "HTTP/1.1 304 Not Modified\r\n%sContent-Length: 0\r\n\r\n",
+              opts->extra_headers ? opts->extra_headers : "");
+  } else {
+    int n, status = 200;
+    char range[100];
+    int64_t r1 = 0, r2 = 0, cl = (int64_t) size;
+
+    // Handle Range header
+    struct mg_str *rh = mg_http_get_header(hm, "Range");
+    range[0] = '\0';
+    if (rh != NULL && (n = getrange(rh, &r1, &r2)) > 0 && r1 >= 0 && r2 >= 0) {
+      // If range is specified like "400-", set second limit to content len
+      if (n == 1) r2 = cl - 1;
+      if (r1 > r2 || r2 >= cl) {
+        status = 416;
+        cl = 0;
+        mg_snprintf(range, sizeof(range), "Content-Range: bytes */%lld\r\n",
+                    (int64_t) size);
+      } else {
+        status = 206;
+        cl = r2 - r1 + 1;
+        mg_snprintf(range, sizeof(range),
+                    "Content-Range: bytes %lld-%lld/%lld\r\n", r1, r1 + cl - 1,
+                    (int64_t) size);
+        fs->sk(fd->fd, (size_t) r1);
+      }
+    }
+    mg_printf(c,
+              "HTTP/1.1 %d %s\r\n"
+              "Content-Type: %.*s\r\n"
+              "Etag: %s\r\n"
+              "Content-Length: %llu\r\n"
+              "%s%s%s\r\n",
+              status, mg_http_status_code_str(status), (int) mime.len, mime.ptr,
+              etag, cl, gzip ? "Content-Encoding: gzip\r\n" : "", range,
+              opts->extra_headers ? opts->extra_headers : "");
+    if (mg_vcasecmp(&hm->method, "HEAD") == 0) {
+      c->is_draining = 1;
+      mg_fs_close(fd);
+    } else {
+      c->pfn = static_cb;
+      c->pfn_data = fd;
+      *(size_t *) c->label = (size_t) cl;  // Track to-be-sent content length
+    }
+  }
+}
+
+struct printdirentrydata {
+  struct mg_connection *c;
+  struct mg_http_message *hm;
+  const struct mg_http_serve_opts *opts;
+  const char *dir;
+};
+
+static void printdirentry(const char *name, void *userdata) {
+  struct printdirentrydata *d = (struct printdirentrydata *) userdata;
+  struct mg_fs *fs = d->opts->fs == NULL ? &mg_fs_posix : d->opts->fs;
+  size_t size = 0;
+  time_t t = 0;
+  char path[MG_PATH_MAX], sz[40], mod[40];
+  int flags, n = 0;
+
+  // MG_DEBUG(("[%s] [%s]", d->dir, name));
+  if (mg_snprintf(path, sizeof(path), "%s%c%s", d->dir, '/', name) >
+      sizeof(path)) {
+    MG_ERROR(("%s truncated", name));
+  } else if ((flags = fs->st(path, &size, &t)) == 0) {
+    MG_ERROR(("%lu stat(%s): %d", d->c->id, path, errno));
+  } else {
+    const char *slash = flags & MG_FS_DIR ? "/" : "";
+    if (flags & MG_FS_DIR) {
+      mg_snprintf(sz, sizeof(sz), "%s", "[DIR]");
+    } else {
+      mg_snprintf(sz, sizeof(sz), "%lld", (uint64_t) size);
+    }
+    mg_snprintf(mod, sizeof(mod), "%ld", (unsigned long) t);
+    n = (int) mg_url_encode(name, strlen(name), path, sizeof(path));
+    mg_printf(d->c,
+              "  <tr><td><a href=\"%.*s%s\">%s%s</a></td>"
+              "<td name=%lu>%s</td><td name=%lld>%s</td></tr>\n",
+              n, path, slash, name, slash, (unsigned long) t, mod,
+              flags & MG_FS_DIR ? (int64_t) -1 : (int64_t) size, sz);
+  }
+}
+
+static void listdir(struct mg_connection *c, struct mg_http_message *hm,
+                    const struct mg_http_serve_opts *opts, char *dir) {
+  const char *sort_js_code =
+      "<script>function srt(tb, sc, so, d) {"
+      "var tr = Array.prototype.slice.call(tb.rows, 0),"
+      "tr = tr.sort(function (a, b) { var c1 = a.cells[sc], c2 = b.cells[sc],"
+      "n1 = c1.getAttribute('name'), n2 = c2.getAttribute('name'), "
+      "t1 = a.cells[2].getAttribute('name'), "
+      "t2 = b.cells[2].getAttribute('name'); "
+      "return so * (t1 < 0 && t2 >= 0 ? -1 : t2 < 0 && t1 >= 0 ? 1 : "
+      "n1 ? parseInt(n2) - parseInt(n1) : "
+      "c1.textContent.trim().localeCompare(c2.textContent.trim())); });";
+  const char *sort_js_code2 =
+      "for (var i = 0; i < tr.length; i++) tb.appendChild(tr[i]); "
+      "if (!d) window.location.hash = ('sc=' + sc + '&so=' + so); "
+      "};"
+      "window.onload = function() {"
+      "var tb = document.getElementById('tb');"
+      "var m = /sc=([012]).so=(1|-1)/.exec(window.location.hash) || [0, 2, 1];"
+      "var sc = m[1], so = m[2]; document.onclick = function(ev) { "
+      "var c = ev.target.rel; if (c) {if (c == sc) so *= -1; srt(tb, c, so); "
+      "sc = c; ev.preventDefault();}};"
+      "srt(tb, sc, so, true);"
+      "}"
+      "</script>";
+  struct mg_fs *fs = opts->fs == NULL ? &mg_fs_posix : opts->fs;
+  struct printdirentrydata d = {c, hm, opts, dir};
+  char tmp[10], buf[MG_PATH_MAX];
+  size_t off, n;
+  int len = mg_url_decode(hm->uri.ptr, hm->uri.len, buf, sizeof(buf), 0);
+  struct mg_str uri = len > 0 ? mg_str_n(buf, (size_t) len) : hm->uri;
+
+  mg_printf(c,
+            "HTTP/1.1 200 OK\r\n"
+            "Content-Type: text/html; charset=utf-8\r\n"
+            "%s"
+            "Content-Length:         \r\n\r\n",
+            opts->extra_headers == NULL ? "" : opts->extra_headers);
+  off = c->send.len;  // Start of body
+  mg_printf(c,
+            "<!DOCTYPE html><html><head><title>Index of %.*s</title>%s%s"
+            "<style>th,td {text-align: left; padding-right: 1em; "
+            "font-family: monospace; }</style></head>"
+            "<body><h1>Index of %.*s</h1><table cellpadding=\"0\"><thead>"
+            "<tr><th><a href=\"#\" rel=\"0\">Name</a></th><th>"
+            "<a href=\"#\" rel=\"1\">Modified</a></th>"
+            "<th><a href=\"#\" rel=\"2\">Size</a></th></tr>"
+            "<tr><td colspan=\"3\"><hr></td></tr>"
+            "</thead>"
+            "<tbody id=\"tb\">\n",
+            (int) uri.len, uri.ptr, sort_js_code, sort_js_code2, (int) uri.len,
+            uri.ptr);
+  mg_printf(c, "%s",
+            "  <tr><td><a href=\"..\">..</a></td>"
+            "<td name=-1></td><td name=-1>[DIR]</td></tr>\n");
+
+  fs->ls(dir, printdirentry, &d);
+  mg_printf(c,
+            "</tbody><tfoot><tr><td colspan=\"3\"><hr></td></tr></tfoot>"
+            "</table><address>Mongoose v.%s</address></body></html>\n",
+            MG_VERSION);
+  n = mg_snprintf(tmp, sizeof(tmp), "%lu", (unsigned long) (c->send.len - off));
+  if (n > sizeof(tmp)) n = 0;
+  memcpy(c->send.buf + off - 12, tmp, n);  // Set content length
+}
+
+// Resolve requested file into `path` and return its fs->st() result
+static int uri_to_path2(struct mg_connection *c, struct mg_http_message *hm,
+                        struct mg_fs *fs, struct mg_str url, struct mg_str dir,
+                        char *path, size_t path_size) {
+  int flags, tmp;
+  // Append URI to the root_dir, and sanitize it
+  size_t n = mg_snprintf(path, path_size, "%.*s", (int) dir.len, dir.ptr);
+  if (n > path_size) n = path_size;
+  path[path_size - 1] = '\0';
+  if (n + 2 < path_size) path[n++] = '/', path[n] = '\0';
+  mg_url_decode(hm->uri.ptr + url.len, hm->uri.len - url.len, path + n,
+                path_size - n, 0);
+  path[path_size - 1] = '\0';  // Double-check
+  mg_remove_double_dots(path);
+  n = strlen(path);
+  while (n > 1 && path[n - 1] == '/') path[--n] = 0;  // Trim trailing slashes
+  flags = mg_vcmp(&hm->uri, "/") == 0 ? MG_FS_DIR : fs->st(path, NULL, NULL);
+  MG_VERBOSE(("%lu %.*s -> %s %d", c->id, (int) hm->uri.len, hm->uri.ptr, path,
+              flags));
+  if (flags == 0) {
+    // Do nothing - let's caller decide
+  } else if ((flags & MG_FS_DIR) && hm->uri.len > 0 &&
+             hm->uri.ptr[hm->uri.len - 1] != '/') {
+    mg_printf(c,
+              "HTTP/1.1 301 Moved\r\n"
+              "Location: %.*s/\r\n"
+              "Content-Length: 0\r\n"
+              "\r\n",
+              (int) hm->uri.len, hm->uri.ptr);
+    flags = -1;
+  } else if (flags & MG_FS_DIR) {
+    if (((mg_snprintf(path + n, path_size - n, "/" MG_HTTP_INDEX) > 0 &&
+          (tmp = fs->st(path, NULL, NULL)) != 0) ||
+         (mg_snprintf(path + n, path_size - n, "/index.shtml") > 0 &&
+          (tmp = fs->st(path, NULL, NULL)) != 0))) {
+      flags = tmp;
+    } else {
+      path[n] = '\0';  // Remove appended index file name
+    }
+  }
+  return flags;
+}
+
+static int uri_to_path(struct mg_connection *c, struct mg_http_message *hm,
+                       const struct mg_http_serve_opts *opts, char *path,
+                       size_t path_size) {
+  struct mg_fs *fs = opts->fs == NULL ? &mg_fs_posix : opts->fs;
+  struct mg_str k, v, s = mg_str(opts->root_dir), u = {0, 0}, p = {0, 0};
+  while (mg_commalist(&s, &k, &v)) {
+    if (v.len == 0) v = k, k = mg_str("/");
+    if (hm->uri.len < k.len) continue;
+    if (mg_strcmp(k, mg_str_n(hm->uri.ptr, k.len)) != 0) continue;
+    u = k, p = v;
+  }
+  return uri_to_path2(c, hm, fs, u, p, path, path_size);
+}
+
+void mg_http_serve_dir(struct mg_connection *c, struct mg_http_message *hm,
+                       const struct mg_http_serve_opts *opts) {
+  char path[MG_PATH_MAX];
+  const char *sp = opts->ssi_pattern;
+  int flags = uri_to_path(c, hm, opts, path, sizeof(path));
+  if (flags < 0) {
+    // Do nothing: the response has already been sent by uri_to_path()
+  } else if (flags & MG_FS_DIR) {
+    listdir(c, hm, opts, path);
+  } else if (flags && sp != NULL &&
+             mg_globmatch(sp, strlen(sp), path, strlen(path))) {
+    mg_http_serve_ssi(c, opts->root_dir, path);
+  } else {
+    mg_http_serve_file(c, hm, path, opts);
+  }
+}
+
+static bool mg_is_url_safe(int c) {
+  return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') ||
+         (c >= 'A' && c <= 'Z') || c == '.' || c == '_' || c == '-' || c == '~';
+}
+
+size_t mg_url_encode(const char *s, size_t sl, char *buf, size_t len) {
+  size_t i, n = 0;
+  for (i = 0; i < sl; i++) {
+    int c = *(unsigned char *) &s[i];
+    if (n + 4 >= len) return 0;
+    if (mg_is_url_safe(c)) {
+      buf[n++] = s[i];
+    } else {
+      buf[n++] = '%';
+      mg_hex(&s[i], 1, &buf[n]);
+      n += 2;
+    }
+  }
+  return n;
+}
+
+void mg_http_creds(struct mg_http_message *hm, char *user, size_t userlen,
+                   char *pass, size_t passlen) {
+  struct mg_str *v = mg_http_get_header(hm, "Authorization");
+  user[0] = pass[0] = '\0';
+  if (v != NULL && v->len > 6 && memcmp(v->ptr, "Basic ", 6) == 0) {
+    char buf[256];
+    int n = mg_base64_decode(v->ptr + 6, (int) v->len - 6, buf);
+    const char *p = (const char *) memchr(buf, ':', n > 0 ? (size_t) n : 0);
+    if (p != NULL) {
+      mg_snprintf(user, userlen, "%.*s", (int) (p - buf), buf);
+      mg_snprintf(pass, passlen, "%.*s", n - (int) (p - buf) - 1, p + 1);
+    }
+  } else if (v != NULL && v->len > 7 && memcmp(v->ptr, "Bearer ", 7) == 0) {
+    mg_snprintf(pass, passlen, "%.*s", (int) v->len - 7, v->ptr + 7);
+  } else if ((v = mg_http_get_header(hm, "Cookie")) != NULL) {
+    struct mg_str t = mg_http_get_header_var(*v, mg_str_n("access_token", 12));
+    if (t.len > 0) mg_snprintf(pass, passlen, "%.*s", (int) t.len, t.ptr);
+  } else {
+    mg_http_get_var(&hm->query, "access_token", pass, passlen);
+  }
+}
+
+static struct mg_str stripquotes(struct mg_str s) {
+  return s.len > 1 && s.ptr[0] == '"' && s.ptr[s.len - 1] == '"'
+             ? mg_str_n(s.ptr + 1, s.len - 2)
+             : s;
+}
+
+struct mg_str mg_http_get_header_var(struct mg_str s, struct mg_str v) {
+  size_t i;
+  for (i = 0; v.len > 0 && i + v.len + 2 < s.len; i++) {
+    if (s.ptr[i + v.len] == '=' && memcmp(&s.ptr[i], v.ptr, v.len) == 0) {
+      const char *p = &s.ptr[i + v.len + 1], *b = p, *x = &s.ptr[s.len];
+      int q = p < x && *p == '"' ? 1 : 0;
+      while (p < x &&
+             (q ? p == b || *p != '"' : *p != ';' && *p != ' ' && *p != ','))
+        p++;
+      // MG_INFO(("[%.*s] [%.*s] [%.*s]", (int) s.len, s.ptr, (int) v.len,
+      // v.ptr, (int) (p - b), b));
+      return stripquotes(mg_str_n(b, (size_t) (p - b + q)));
+    }
+  }
+  return mg_str_n(NULL, 0);
+}
+
+bool mg_http_match_uri(const struct mg_http_message *hm, const char *glob) {
+  return mg_match(hm->uri, mg_str(glob), NULL);
+}
+
+static size_t get_chunk_length(const char *buf, size_t len, size_t *ll) {
+  size_t i = 0, n;
+  while (i < len && buf[i] != '\r' && i != '\n') i++;
+  n = mg_unhexn((char *) buf, i);
+  while (i < len && (buf[i] == '\r' || i == '\n')) i++;
+  // MG_INFO(("len %zu i %zu n %zu ", len, i, n));
+  if (ll != NULL) *ll = i + 1;
+  if (i < len && i + n + 2 < len) return i + n + 3;
+  return 0;
+}
+
+// Walk through all chunks in the chunked body. For each chunk, fire
+// an MG_EV_HTTP_CHUNK event.
+static bool walkchunks(struct mg_connection *c, struct mg_http_message *hm,
+                       size_t reqlen) {
+  size_t off = 0, bl, ll;
+  while (off + reqlen < c->recv.len) {
+    char *buf = (char *) &c->recv.buf[reqlen];
+    size_t memo = c->recv.len;
+    size_t cl = get_chunk_length(&buf[off], memo - reqlen - off, &ll);
+    // MG_INFO(("len %zu off %zu cl %zu ll %zu", len, off, cl, ll));
+    if (cl == 0) break;
+    hm->chunk = mg_str_n(&buf[off + ll], cl < ll + 2 ? 0 : cl - ll - 2);
+    mg_call(c, MG_EV_HTTP_CHUNK, hm);
+    // Increase offset only if user has not deleted this chunk
+    if (memo == c->recv.len) off += cl;
+    if (cl <= 5) {
+      // Zero chunk - last one. Prepare body - cut off chunk lengths
+      if (memo != c->recv.len) return true;  // Tell caller to cleanup
+      off = bl = 0;
+      while (off + reqlen < c->recv.len) {
+        char *buf2 = (char *) &c->recv.buf[reqlen];
+        size_t memo2 = c->recv.len;
+        size_t cl2 = get_chunk_length(&buf2[off], memo2 - reqlen - off, &ll);
+        size_t n = cl2 < ll + 2 ? 0 : cl2 - ll - 2;
+        memmove(buf2 + bl, buf2 + off + ll, n);
+        bl += n;
+        off += cl2;
+        if (cl2 <= 5) break;
+      }
+      // MG_INFO(("BL->%d del %d off %d", (int) bl, (int) del, (int) off));
+      c->recv.len -= off - bl;
+      // Set message length to indicate we've received
+      // everything, to fire MG_EV_HTTP_MSG
+      hm->message.len = bl + reqlen;
+      hm->body.len = bl;
+      // If user was deleting chunks, send nothing
+      break;
+    }
+  }
+  return false;
+}
+
+static bool mg_is_chunked(struct mg_http_message *hm) {
+  const char *needle = "chunked";
+  struct mg_str *te = mg_http_get_header(hm, "Transfer-Encoding");
+  return te != NULL && mg_vcasecmp(te, needle) == 0;
+}
+
+void mg_http_delete_chunk(struct mg_connection *c, struct mg_http_message *hm) {
+  struct mg_str ch = hm->chunk;
+  const char *end = (char *) &c->recv.buf[c->recv.len], *ce;
+  bool chunked = mg_is_chunked(hm);
+  if (chunked) {
+    ch.len += 4, ch.ptr -= 2;  // \r\n before and after the chunk
+    while (ch.ptr > hm->body.ptr && *ch.ptr != '\n') ch.ptr--, ch.len++;
+  }
+  ce = &ch.ptr[ch.len];
+  if (ce < end) memmove((void *) ch.ptr, ce, (size_t) (end - ce));
+  c->recv.len -= ch.len;
+  if (c->pfn_data != NULL) c->pfn_data = (char *) c->pfn_data - ch.len;
+}
+
+long mg_http_upload(struct mg_connection *c, struct mg_http_message *hm,
+                    struct mg_fs *fs, const char *path, size_t max_size) {
+  char buf[20] = "0";
+  long res = 0, offset;
+  mg_http_get_var(&hm->query, "offset", buf, sizeof(buf));
+  offset = strtol(buf, NULL, 0);
+  if (hm->body.len == 0) {
+    mg_http_reply(c, 200, "", "%ld", res);  // Nothing to write
+  } else {
+    struct mg_fd *fd;
+    size_t current_size = 0;
+    MG_DEBUG(("%s -> %d bytes @ %ld", path, (int) hm->body.len, offset));
+    if (offset == 0) fs->rm(path);  // If offset if 0, truncate file
+    fs->st(path, &current_size, NULL);
+    if (offset < 0) {
+      mg_http_reply(c, 400, "", "offset required");
+      res = -1;
+    } else if (offset > 0 && current_size != (size_t) offset) {
+      mg_http_reply(c, 400, "", "%s: offset mismatch", path);
+      res = -2;
+    } else if ((size_t) offset + hm->body.len > max_size) {
+      mg_http_reply(c, 400, "", "%s: over max size of %lu", path,
+                    (unsigned long) max_size);
+      res = -3;
+    } else if ((fd = mg_fs_open(fs, path, MG_FS_WRITE)) == NULL) {
+      mg_http_reply(c, 400, "", "open(%s): %d", path, errno);
+      res = -4;
+    } else {
+      res = offset + (long) fs->wr(fd->fd, hm->body.ptr, hm->body.len);
+      mg_fs_close(fd);
+      mg_http_reply(c, 200, "", "%ld", res);
+    }
+  }
+  return res;
+}
+
+int mg_http_status(const struct mg_http_message *hm) {
+  return atoi(hm->uri.ptr);
+}
+
+static void http_cb(struct mg_connection *c, int ev, void *evd, void *fnd) {
+  if (ev == MG_EV_READ || ev == MG_EV_CLOSE) {
+    struct mg_http_message hm;
+    while (c->recv.buf != NULL && c->recv.len > 0) {
+      int n = mg_http_parse((char *) c->recv.buf, c->recv.len, &hm);
+      bool is_chunked = n > 0 && mg_is_chunked(&hm);
+      if (ev == MG_EV_CLOSE) {
+        hm.message.len = c->recv.len;
+        hm.body.len = hm.message.len - (size_t) (hm.body.ptr - hm.message.ptr);
+      } else if (is_chunked && n > 0 && walkchunks(c, &hm, (size_t) n)) {
+        // walkchunks told us to cleanup the request
+        if (n > (int) c->recv.len) n = (int) c->recv.len;
+        mg_iobuf_del(&c->recv, 0, (size_t) n);
+        break;
+      }
+      // MG_INFO(("---->%d %d\n%.*s", n, is_chunked, (int) c->recv.len,
+      // c->recv.buf));
+      if (n < 0 && ev == MG_EV_READ) {
+        mg_error(c, "HTTP parse:\n%.*s", (int) c->recv.len, c->recv.buf);
+        break;
+      } else if (n > 0 && (size_t) c->recv.len >= hm.message.len) {
+        mg_call(c, MG_EV_HTTP_MSG, &hm);
+        mg_iobuf_del(&c->recv, 0, hm.message.len);
+      } else {
+        if (n > 0 && !is_chunked) {
+          hm.chunk =
+              mg_str_n((char *) &c->recv.buf[n], c->recv.len - (size_t) n);
+          // Store remaining body length in c->pfn_data
+          if (c->pfn_data == NULL)
+            c->pfn_data = (void *) (hm.message.len - (size_t) n);
+          mg_call(c, MG_EV_HTTP_CHUNK, &hm);
+          if (c->pfn_data == NULL) {
+            hm.chunk.len = 0;                   // Last chunk!
+            mg_call(c, MG_EV_HTTP_CHUNK, &hm);  // Lest user know
+            memmove(c->recv.buf, c->recv.buf + n, c->recv.len - (size_t) n);
+            c->recv.len -= (size_t) n;
+          }
+        }
+        break;
+      }
+    }
+  }
+  (void) fnd;
+  (void) evd;
+}
+
+struct mg_connection *mg_http_connect(struct mg_mgr *mgr, const char *url,
+                                      mg_event_handler_t fn, void *fn_data) {
+  struct mg_connection *c = mg_connect(mgr, url, fn, fn_data);
+  if (c != NULL) c->pfn = http_cb;
+  return c;
+}
+
+struct mg_connection *mg_http_listen(struct mg_mgr *mgr, const char *url,
+                                     mg_event_handler_t fn, void *fn_data) {
+  struct mg_connection *c = mg_listen(mgr, url, fn, fn_data);
+  if (c != NULL) c->pfn = http_cb;
+  return c;
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/iobuf.c"
+#endif
+
+
+
+
+// Not using memset for zeroing memory, cause it can be dropped by compiler
+// See https://github.com/cesanta/mongoose/pull/1265
+static void zeromem(volatile unsigned char *buf, size_t len) {
+  if (buf != NULL) {
+    while (len--) *buf++ = 0;
+  }
+}
+
+int mg_iobuf_resize(struct mg_iobuf *io, size_t new_size) {
+  int ok = 1;
+  if (new_size == 0) {
+    zeromem(io->buf, io->size);
+    free(io->buf);
+    io->buf = NULL;
+    io->len = io->size = 0;
+  } else if (new_size != io->size) {
+    // NOTE(lsm): do not use realloc here. Use calloc/free only, to ease the
+    // porting to some obscure platforms like FreeRTOS
+    void *p = calloc(1, new_size);
+    if (p != NULL) {
+      size_t len = new_size < io->len ? new_size : io->len;
+      if (len > 0) memmove(p, io->buf, len);
+      zeromem(io->buf, io->size);
+      free(io->buf);
+      io->buf = (unsigned char *) p;
+      io->size = new_size;
+    } else {
+      ok = 0;
+      MG_ERROR(("%lld->%lld", (uint64_t) io->size, (uint64_t) new_size));
+    }
+  }
+  return ok;
+}
+
+int mg_iobuf_init(struct mg_iobuf *io, size_t size) {
+  io->buf = NULL;
+  io->size = io->len = 0;
+  return mg_iobuf_resize(io, size);
+}
+
+size_t mg_iobuf_add(struct mg_iobuf *io, size_t ofs, const void *buf,
+                    size_t len, size_t chunk_size) {
+  size_t new_size = io->len + len;
+  if (new_size > io->size) {
+    new_size += chunk_size;             // Make sure that io->size
+    new_size -= new_size % chunk_size;  // is aligned by chunk_size boundary
+    mg_iobuf_resize(io, new_size);      // Attempt to realloc
+    if (new_size != io->size) len = 0;  // Realloc failure, append nothing
+  }
+  if (ofs < io->len) memmove(io->buf + ofs + len, io->buf + ofs, io->len - ofs);
+  if (buf != NULL) memmove(io->buf + ofs, buf, len);
+  if (ofs > io->len) io->len += ofs - io->len;
+  io->len += len;
+  return len;
+}
+
+size_t mg_iobuf_del(struct mg_iobuf *io, size_t ofs, size_t len) {
+  if (ofs > io->len) ofs = io->len;
+  if (ofs + len > io->len) len = io->len - ofs;
+  if (io->buf) memmove(io->buf + ofs, io->buf + ofs + len, io->len - ofs - len);
+  if (io->buf) zeromem(io->buf + io->len - len, len);
+  io->len -= len;
+  return len;
+}
+
+void mg_iobuf_free(struct mg_iobuf *io) {
+  mg_iobuf_resize(io, 0);
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/json.c"
+#endif
+
+
+
+static const char *escapeseq(int esc) {
+  return esc ? "\b\f\n\r\t\\\"" : "bfnrt\\\"";
+}
+
+static char json_esc(int c, int esc) {
+  const char *p, *esc1 = escapeseq(esc), *esc2 = escapeseq(!esc);
+  for (p = esc1; *p != '\0'; p++) {
+    if (*p == c) return esc2[p - esc1];
+  }
+  return 0;
+}
+
+static int mg_pass_string(const char *s, int len) {
+  int i;
+  for (i = 0; i < len; i++) {
+    if (s[i] == '\\' && i + 1 < len && json_esc(s[i + 1], 1)) {
+      i++;
+    } else if (s[i] == '\0') {
+      return MG_JSON_INVALID;
+    } else if (s[i] == '"') {
+      return i;
+    }
+  }
+  return MG_JSON_INVALID;
+}
+
+int mg_json_get(const char *s, int len, const char *path, int *toklen) {
+  enum { S_VALUE, S_KEY, S_COLON, S_COMMA_OR_EOO } expecting = S_VALUE;
+  unsigned char nesting[MG_JSON_MAX_DEPTH];
+  int i, j = 0, depth = 0;
+  int pos = 1;           // Current position in path
+  int ed = 0;            // Expected depth
+  int ci = -1, ei = -1;  // Current and expected index in array
+
+  if (path[0] != '$') return MG_JSON_INVALID;
+
+#if 0
+#define MG_DBGP(x)                                                             \
+  do {                                                                         \
+    printf("%c %.*s j=%d i=%d pos=%d depth=%d ed=%d ci=%d ei=%d\n", x, len, s, \
+           j, i, pos, depth, ed, ci, ei);                                      \
+  } while (0)
+#else
+#define MG_DBGP(x)
+#endif
+
+#define MG_CHECKRET(x)                                  \
+  do {                                                  \
+    MG_DBGP(x);                                         \
+    if (depth == ed && path[pos] == '\0' && ci == ei) { \
+      if (toklen) *toklen = i - j + 1;                  \
+      return j;                                         \
+    }                                                   \
+  } while (0)
+
+// In the ascii table, the distance between `[` and `]` is 2.
+// Ditto for `{` and `}`. Hence +2 in the code below.
+#define MG_EOO(x)                                            \
+  do {                                                       \
+    if (depth == ed && ci != ei) return MG_JSON_NOT_FOUND;   \
+    if (c != nesting[depth - 1] + 2) return MG_JSON_INVALID; \
+    depth--;                                                 \
+    MG_CHECKRET(x);                                          \
+  } while (0)
+
+  for (i = 0; i < len; i++) {
+    unsigned char c = ((unsigned char *) s)[i];
+    if (c == ' ' || c == '\t' || c == '\n' || c == '\r') continue;
+    MG_DBGP('-');
+    switch (expecting) {
+      case S_VALUE:
+        if (depth == ed) j = i;
+        if (c == '{') {
+          if (depth >= (int) sizeof(nesting)) return MG_JSON_TOO_DEEP;
+          if (depth == ed && path[pos] == '.') ed++, pos++;
+          nesting[depth++] = c;
+          expecting = S_KEY;
+          break;
+        } else if (c == '[') {
+          if (depth >= (int) sizeof(nesting)) return MG_JSON_TOO_DEEP;
+          if (depth == ed && path[pos] == '[' && ei == ci) {
+            ed++, pos++, ci = 0;
+            for (ei = 0; path[pos] != ']' && path[pos] != '\0'; pos++) {
+              ei *= 10;
+              ei += path[pos] - '0';
+            }
+            if (path[pos] != 0) pos++;
+          }
+          nesting[depth++] = c;
+          break;
+        } else if (c == ']' && depth > 0) {  // Empty array
+          MG_EOO(']');
+        } else if (c == 't' && i + 3 < len && memcmp(&s[i], "true", 4) == 0) {
+          i += 3;
+        } else if (c == 'n' && i + 3 < len && memcmp(&s[i], "null", 4) == 0) {
+          i += 3;
+        } else if (c == 'f' && i + 4 < len && memcmp(&s[i], "false", 5) == 0) {
+          i += 4;
+        } else if (c == '-' || ((c >= '0' && c <= '9'))) {
+          int numlen = 0;
+          mg_atod(&s[i], len - i, &numlen);
+          i += numlen - 1;
+        } else if (c == '"') {
+          int n = mg_pass_string(&s[i + 1], len - i - 1);
+          if (n < 0) return n;
+          i += n + 1;
+        } else {
+          return MG_JSON_INVALID;
+        }
+        MG_CHECKRET('V');
+        if (depth == ed && ei >= 0) ci++;
+        expecting = S_COMMA_OR_EOO;
+        break;
+
+      case S_KEY:
+        if (c == '"') {
+          int n = mg_pass_string(&s[i + 1], len - i - 1);
+          if (n < 0) return n;
+          // printf("K[%.*s] %d %d\n", n, &s[i + 1], depth, ed);
+          if (depth == ed && path[pos - 1] == '.' &&
+              memcmp(&s[i + 1], &path[pos], (size_t) n) == 0) {
+            pos += n;
+          }
+          i += n + 1;
+          expecting = S_COLON;
+        } else if (c == '}') {  // Empty object
+          MG_EOO('}');
+          expecting = S_COMMA_OR_EOO;
+        } else {
+          return MG_JSON_INVALID;
+        }
+        break;
+
+      case S_COLON:
+        if (c == ':') {
+          expecting = S_VALUE;
+        } else {
+          return MG_JSON_INVALID;
+        }
+        break;
+
+      case S_COMMA_OR_EOO:
+        if (depth <= 0) {
+          return MG_JSON_INVALID;
+        } else if (c == ',') {
+          expecting = (nesting[depth - 1] == '{') ? S_KEY : S_VALUE;
+          // MG_CHECKRET('C');
+        } else if (c == ']' || c == '}') {
+          MG_EOO('O');
+          if (depth == ed && ei >= 0) ci++;
+        } else {
+          return MG_JSON_INVALID;
+        }
+        break;
+    }
+    MG_DBGP('E');
+  }
+  return MG_JSON_NOT_FOUND;
+}
+
+bool mg_json_get_num(struct mg_str json, const char *path, double *v) {
+  int n, toklen, found = 0;
+  if ((n = mg_json_get(json.ptr, (int) json.len, path, &toklen)) >= 0 &&
+      (json.ptr[n] == '-' || (json.ptr[n] >= '0' && json.ptr[n] <= '9'))) {
+    if (v != NULL) *v = mg_atod(json.ptr + n, toklen, NULL);
+    found = 1;
+  }
+  return found;
+}
+
+bool mg_json_get_bool(struct mg_str json, const char *path, bool *v) {
+  int n, toklen, found = 0;
+  if ((n = mg_json_get(json.ptr, (int) json.len, path, &toklen)) >= 0 &&
+      (json.ptr[n] == 't' || json.ptr[n] == 'f')) {
+    if (v != NULL) *v = json.ptr[n] == 't';
+    found = 1;
+  }
+  return found;
+}
+
+static bool json_unescape(const char *s, size_t len, char *to, size_t n) {
+  size_t i, j;
+  for (i = 0, j = 0; i < len && j < n; i++, j++) {
+    if (s[i] == '\\' && i + 5 < len && s[i + 1] == 'u') {
+      //  \uXXXX escape. We could process a simple one-byte chars
+      // \u00xx from the ASCII range. More complex chars would require
+      // dragging in a UTF8 library, which is too much for us
+      if (s[i + 2] != '0' || s[i + 3] != '0') return false;  // Give up
+      ((unsigned char *) to)[j] = (unsigned char) mg_unhexn(s + i + 4, 2);
+
+      i += 5;
+    } else if (s[i] == '\\' && i + 1 < len) {
+      char c = json_esc(s[i + 1], 0);
+      if (c == 0) return false;
+      to[j] = c;
+      i++;
+    } else {
+      to[j] = s[i];
+    }
+  }
+  if (j >= n) return false;
+  if (n > 0) to[j] = '\0';
+  return true;
+}
+
+char *mg_json_get_str(struct mg_str json, const char *path) {
+  int n, toklen;
+  char *result = NULL;
+  if ((n = mg_json_get(json.ptr, (int) json.len, path, &toklen)) >= 0 &&
+      json.ptr[n] == '"') {
+    if ((result = (char *) calloc(1, (size_t) toklen)) != NULL &&
+        !json_unescape(json.ptr + n + 1, (size_t) (toklen - 2), result,
+                       (size_t) toklen)) {
+      free(result);
+      result = NULL;
+    }
+  }
+  return result;
+}
+
+char *mg_json_get_b64(struct mg_str json, const char *path, int *len) {
+  int n, toklen;
+  char *result = NULL;
+  if ((n = mg_json_get(json.ptr, (int) json.len, path, &toklen)) >= 0 &&
+      json.ptr[n] == '"' && toklen > 1 &&
+      (result = (char *) calloc(1, (size_t) toklen)) != NULL) {
+    int k = mg_base64_decode(json.ptr + n + 1, toklen - 2, result);
+    if (len != NULL) *len = k;
+  }
+  return result;
+}
+
+char *mg_json_get_hex(struct mg_str json, const char *path, int *len) {
+  int n, toklen;
+  char *result = NULL;
+  if ((n = mg_json_get(json.ptr, (int) json.len, path, &toklen)) >= 0 &&
+      json.ptr[n] == '"' && toklen > 1 &&
+      (result = (char *) calloc(1, (size_t) toklen / 2)) != NULL) {
+    mg_unhex(json.ptr + n + 1, (size_t) (toklen - 2), (uint8_t *) result);
+    result[(toklen - 2) / 2] = '\0';
+    if (len != NULL) *len = (toklen - 2) / 2;
+  }
+  return result;
+}
+
+long mg_json_get_long(struct mg_str json, const char *path, long dflt) {
+  double dv;
+  long result = dflt;
+  if (mg_json_get_num(json, path, &dv)) result = (long) dv;
+  return result;
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/log.c"
+#endif
+
+
+
+static void default_logger(unsigned char c) {
+  putchar(c);
+  (void) c;
+}
+
+static const char *s_spec = "2";
+static void (*s_log_func)(unsigned char) = default_logger;
+
+void mg_log_set_fn(void (*fn)(unsigned char)) {
+  s_log_func = fn;
+}
+
+static void logc(unsigned char c) {
+  s_log_func(c);
+}
+
+static void logs(const char *buf, size_t len) {
+  size_t i;
+  for (i = 0; i < len; i++) logc(((unsigned char *) buf)[i]);
+}
+
+void mg_log_set(const char *spec) {
+  MG_DEBUG(("Setting log level to %s", spec));
+  s_spec = spec;
+}
+
+bool mg_log_prefix(int level, const char *file, int line, const char *fname) {
+  // static unsigned long seq;
+  int max = MG_LL_INFO;
+  struct mg_str k, v, s = mg_str(s_spec);
+  const char *p = strrchr(file, '/');
+
+  if (p == NULL) p = strrchr(file, '\\');
+  p = p == NULL ? file : p + 1;
+
+  while (mg_commalist(&s, &k, &v)) {
+    if (v.len == 0) max = atoi(k.ptr);
+    if (v.len > 0 && strncmp(p, k.ptr, k.len) == 0) max = atoi(v.ptr);
+  }
+
+  if (level <= max) {
+    char buf[41];
+    size_t n = mg_snprintf(buf, sizeof(buf), "%llx %d %s:%d:%s", mg_millis(),
+                           level, p, line, fname);
+    if (n > sizeof(buf) - 2) n = sizeof(buf) - 2;
+    while (n < sizeof(buf)) buf[n++] = ' ';
+    logs(buf, n - 1);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+void mg_log(const char *fmt, ...) {
+  char mem[256], *buf = mem;
+  va_list ap;
+  size_t len;
+  va_start(ap, fmt);
+  len = mg_vasprintf(&buf, sizeof(mem), fmt, ap);
+  va_end(ap);
+  logs(buf, len);
+  logc((unsigned char) '\n');
+  if (buf != mem) free(buf);
+}
+
+static unsigned char nibble(unsigned c) {
+  return (unsigned char) (c < 10 ? c + '0' : c + 'W');
+}
+
+#define ISPRINT(x) ((x) >= ' ' && (x) <= '~')
+void mg_hexdump(const void *buf, size_t len) {
+  const unsigned char *p = (const unsigned char *) buf;
+  unsigned char ascii[16], alen = 0;
+  size_t i;
+  for (i = 0; i < len; i++) {
+    if ((i % 16) == 0) {
+      // Print buffered ascii chars
+      if (i > 0) logs("  ", 2), logs((char *) ascii, 16), logc('\n'), alen = 0;
+      // Print hex address, then \t
+      logc(nibble((i >> 12) & 15)), logc(nibble((i >> 8) & 15)),
+          logc(nibble((i >> 4) & 15)), logc('0'), logs("   ", 3);
+    }
+    logc(nibble(p[i] >> 4)), logc(nibble(p[i] & 15));  // Two nibbles, e.g. c5
+    logc(' ');                                         // Space after hex number
+    ascii[alen++] = ISPRINT(p[i]) ? p[i] : '.';        // Add to the ascii buf
+  }
+  while (alen < 16) logs("   ", 3), ascii[alen++] = ' ';
+  logs("  ", 2), logs((char *) ascii, 16), logc('\n');
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/md5.c"
+#endif
+
+
+
+#if defined(MG_ENABLE_MD5) && MG_ENABLE_MD5
+#if !defined(BYTE_ORDER) && defined(__BYTE_ORDER)
+#define BYTE_ORDER __BYTE_ORDER
+#ifndef LITTLE_ENDIAN
+#define LITTLE_ENDIAN __LITTLE_ENDIAN
+#endif /* LITTLE_ENDIAN */
+#ifndef BIG_ENDIAN
+#define BIG_ENDIAN __LITTLE_ENDIAN
+#endif /* BIG_ENDIAN */
+#endif /* BYTE_ORDER */
+
+static void mg_byte_reverse(unsigned char *buf, unsigned longs) {
+/* Forrest: MD5 expect LITTLE_ENDIAN, swap if BIG_ENDIAN */
+#if BYTE_ORDER == BIG_ENDIAN
+  do {
+    uint32_t t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
+                 ((unsigned) buf[1] << 8 | buf[0]);
+    *(uint32_t *) buf = t;
+    buf += 4;
+  } while (--longs);
+#else
+  (void) buf;
+  (void) longs;
+#endif
+}
+
+#define F1(x, y, z) (z ^ (x & (y ^ z)))
+#define F2(x, y, z) F1(z, x, y)
+#define F3(x, y, z) (x ^ y ^ z)
+#define F4(x, y, z) (y ^ (x | ~z))
+
+#define MD5STEP(f, w, x, y, z, data, s) \
+  (w += f(x, y, z) + data, w = w << s | w >> (32 - s), w += x)
+
+/*
+ * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
+ * initialization constants.
+ */
+void mg_md5_init(mg_md5_ctx *ctx) {
+  ctx->buf[0] = 0x67452301;
+  ctx->buf[1] = 0xefcdab89;
+  ctx->buf[2] = 0x98badcfe;
+  ctx->buf[3] = 0x10325476;
+
+  ctx->bits[0] = 0;
+  ctx->bits[1] = 0;
+}
+
+static void mg_md5_transform(uint32_t buf[4], uint32_t const in[16]) {
+  uint32_t a, b, c, d;
+
+  a = buf[0];
+  b = buf[1];
+  c = buf[2];
+  d = buf[3];
+
+  MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
+  MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
+  MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
+  MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
+  MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
+  MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
+  MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
+  MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
+  MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
+  MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
+  MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
+  MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
+  MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
+  MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
+  MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
+  MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
+
+  MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
+  MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
+  MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
+  MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
+  MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
+  MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
+  MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
+  MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
+  MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
+  MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
+  MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
+  MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
+  MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
+  MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
+  MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
+  MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
+
+  MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
+  MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
+  MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
+  MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
+  MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
+  MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
+  MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
+  MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
+  MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
+  MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
+  MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
+  MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
+  MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
+  MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
+  MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
+  MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
+
+  MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
+  MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
+  MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
+  MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
+  MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
+  MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
+  MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
+  MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
+  MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
+  MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
+  MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
+  MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
+  MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
+  MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
+  MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
+  MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
+
+  buf[0] += a;
+  buf[1] += b;
+  buf[2] += c;
+  buf[3] += d;
+}
+
+void mg_md5_update(mg_md5_ctx *ctx, const unsigned char *buf, size_t len) {
+  uint32_t t;
+
+  t = ctx->bits[0];
+  if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t) ctx->bits[1]++;
+  ctx->bits[1] += (uint32_t) len >> 29;
+
+  t = (t >> 3) & 0x3f;
+
+  if (t) {
+    unsigned char *p = (unsigned char *) ctx->in + t;
+
+    t = 64 - t;
+    if (len < t) {
+      memcpy(p, buf, len);
+      return;
+    }
+    memcpy(p, buf, t);
+    mg_byte_reverse(ctx->in, 16);
+    mg_md5_transform(ctx->buf, (uint32_t *) ctx->in);
+    buf += t;
+    len -= t;
+  }
+
+  while (len >= 64) {
+    memcpy(ctx->in, buf, 64);
+    mg_byte_reverse(ctx->in, 16);
+    mg_md5_transform(ctx->buf, (uint32_t *) ctx->in);
+    buf += 64;
+    len -= 64;
+  }
+
+  memcpy(ctx->in, buf, len);
+}
+
+void mg_md5_final(mg_md5_ctx *ctx, unsigned char digest[16]) {
+  unsigned count;
+  unsigned char *p;
+  uint32_t *a;
+
+  count = (ctx->bits[0] >> 3) & 0x3F;
+
+  p = ctx->in + count;
+  *p++ = 0x80;
+  count = 64 - 1 - count;
+  if (count < 8) {
+    memset(p, 0, count);
+    mg_byte_reverse(ctx->in, 16);
+    mg_md5_transform(ctx->buf, (uint32_t *) ctx->in);
+    memset(ctx->in, 0, 56);
+  } else {
+    memset(p, 0, count - 8);
+  }
+  mg_byte_reverse(ctx->in, 14);
+
+  a = (uint32_t *) ctx->in;
+  a[14] = ctx->bits[0];
+  a[15] = ctx->bits[1];
+
+  mg_md5_transform(ctx->buf, (uint32_t *) ctx->in);
+  mg_byte_reverse((unsigned char *) ctx->buf, 4);
+  memcpy(digest, ctx->buf, 16);
+  memset((char *) ctx, 0, sizeof(*ctx));
+}
+#endif
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/mqtt.c"
+#endif
+
+
+
+
+
+
+
+
+#define MQTT_CLEAN_SESSION 0x02
+#define MQTT_HAS_WILL 0x04
+#define MQTT_WILL_RETAIN 0x20
+#define MQTT_HAS_PASSWORD 0x40
+#define MQTT_HAS_USER_NAME 0x80
+
+void mg_mqtt_send_header(struct mg_connection *c, uint8_t cmd, uint8_t flags,
+                         uint32_t len) {
+  uint8_t buf[1 + sizeof(len)], *vlen = &buf[1];
+  buf[0] = (uint8_t) ((cmd << 4) | flags);
+  do {
+    *vlen = len % 0x80;
+    len /= 0x80;
+    if (len > 0) *vlen |= 0x80;
+    vlen++;
+  } while (len > 0 && vlen < &buf[sizeof(buf)]);
+  mg_send(c, buf, (size_t) (vlen - buf));
+}
+
+static void mg_send_u16(struct mg_connection *c, uint16_t value) {
+  mg_send(c, &value, sizeof(value));
+}
+
+void mg_mqtt_login(struct mg_connection *c, const struct mg_mqtt_opts *opts) {
+  char rnd[10], client_id[21], zero = 0;
+  struct mg_str cid = opts->client_id;
+  uint32_t total_len = 7 + 1 + 2 + 2;
+  uint8_t hdr[8] = {0, 4, 'M', 'Q', 'T', 'T', opts->version, 0};
+
+  if (cid.len == 0) {
+    mg_random(rnd, sizeof(rnd));
+    mg_hex(rnd, sizeof(rnd), client_id);
+    client_id[sizeof(client_id) - 1] = '\0';
+    cid = mg_str(client_id);
+  }
+
+  if (hdr[6] == 0) hdr[6] = 4;  // If version is not set, use 4 (3.1.1)
+  c->is_mqtt5 = hdr[6] == 5;    // Set version 5 flag
+  hdr[7] = (uint8_t) ((opts->will_qos & 3) << 3);  // Connection flags
+  if (opts->user.len > 0) {
+    total_len += 2 + (uint32_t) opts->user.len;
+    hdr[7] |= MQTT_HAS_USER_NAME;
+  }
+  if (opts->pass.len > 0) {
+    total_len += 2 + (uint32_t) opts->pass.len;
+    hdr[7] |= MQTT_HAS_PASSWORD;
+  }
+  if (opts->will_topic.len > 0 && opts->will_message.len > 0) {
+    total_len +=
+        4 + (uint32_t) opts->will_topic.len + (uint32_t) opts->will_message.len;
+    hdr[7] |= MQTT_HAS_WILL;
+  }
+  if (opts->clean || cid.len == 0) hdr[7] |= MQTT_CLEAN_SESSION;
+  if (opts->will_retain) hdr[7] |= MQTT_WILL_RETAIN;
+  total_len += (uint32_t) cid.len;
+  if (c->is_mqtt5) total_len += 1U + (hdr[7] & MQTT_HAS_WILL ? 1U : 0);
+
+  mg_mqtt_send_header(c, MQTT_CMD_CONNECT, 0, total_len);
+  mg_send(c, hdr, sizeof(hdr));
+  // keepalive == 0 means "do not disconnect us!"
+  mg_send_u16(c, mg_htons((uint16_t) opts->keepalive));
+
+  if (c->is_mqtt5) mg_send(c, &zero, sizeof(zero));  // V5 properties
+  mg_send_u16(c, mg_htons((uint16_t) cid.len));
+  mg_send(c, cid.ptr, cid.len);
+
+  if (hdr[7] & MQTT_HAS_WILL) {
+    if (c->is_mqtt5) mg_send(c, &zero, sizeof(zero));  // will props
+    mg_send_u16(c, mg_htons((uint16_t) opts->will_topic.len));
+    mg_send(c, opts->will_topic.ptr, opts->will_topic.len);
+    mg_send_u16(c, mg_htons((uint16_t) opts->will_message.len));
+    mg_send(c, opts->will_message.ptr, opts->will_message.len);
+  }
+  if (opts->user.len > 0) {
+    mg_send_u16(c, mg_htons((uint16_t) opts->user.len));
+    mg_send(c, opts->user.ptr, opts->user.len);
+  }
+  if (opts->pass.len > 0) {
+    mg_send_u16(c, mg_htons((uint16_t) opts->pass.len));
+    mg_send(c, opts->pass.ptr, opts->pass.len);
+  }
+}
+
+void mg_mqtt_pub(struct mg_connection *c, struct mg_str topic,
+                 struct mg_str data, int qos, bool retain) {
+  uint8_t flags = (uint8_t) (((qos & 3) << 1) | (retain ? 1 : 0)), zero = 0;
+  uint32_t len = 2 + (uint32_t) topic.len + (uint32_t) data.len;
+  MG_DEBUG(("%lu [%.*s] -> [%.*s]", c->id, (int) topic.len, (char *) topic.ptr,
+            (int) data.len, (char *) data.ptr));
+  if (qos > 0) len += 2;
+  if (c->is_mqtt5) len++;
+  mg_mqtt_send_header(c, MQTT_CMD_PUBLISH, flags, len);
+  mg_send_u16(c, mg_htons((uint16_t) topic.len));
+  mg_send(c, topic.ptr, topic.len);
+  if (qos > 0) {
+    if (++c->mgr->mqtt_id == 0) ++c->mgr->mqtt_id;
+    mg_send_u16(c, mg_htons(c->mgr->mqtt_id));
+  }
+  if (c->is_mqtt5) mg_send(c, &zero, sizeof(zero));
+  mg_send(c, data.ptr, data.len);
+}
+
+void mg_mqtt_sub(struct mg_connection *c, struct mg_str topic, int qos) {
+  uint8_t qos_ = qos & 3, zero = 0;
+  uint32_t len = 2 + (uint32_t) topic.len + 2 + 1 + (c->is_mqtt5 ? 1 : 0);
+  mg_mqtt_send_header(c, MQTT_CMD_SUBSCRIBE, 2, len);
+  if (++c->mgr->mqtt_id == 0) ++c->mgr->mqtt_id;
+  mg_send_u16(c, mg_htons(c->mgr->mqtt_id));
+  if (c->is_mqtt5) mg_send(c, &zero, sizeof(zero));
+  mg_send_u16(c, mg_htons((uint16_t) topic.len));
+  mg_send(c, topic.ptr, topic.len);
+  mg_send(c, &qos_, sizeof(qos_));
+}
+
+int mg_mqtt_parse(const uint8_t *buf, size_t len, uint8_t version,
+                  struct mg_mqtt_message *m) {
+  uint8_t lc = 0, *p, *end;
+  uint32_t n = 0, len_len = 0;
+
+  memset(m, 0, sizeof(*m));
+  m->dgram.ptr = (char *) buf;
+  if (len < 2) return MQTT_INCOMPLETE;
+  m->cmd = (uint8_t) (buf[0] >> 4);
+  m->qos = (buf[0] >> 1) & 3;
+
+  n = len_len = 0;
+  p = (uint8_t *) buf + 1;
+  while ((size_t) (p - buf) < len) {
+    lc = *((uint8_t *) p++);
+    n += (uint32_t) ((lc & 0x7f) << 7 * len_len);
+    len_len++;
+    if (!(lc & 0x80)) break;
+    if (len_len >= 4) return MQTT_MALFORMED;
+  }
+  end = p + n;
+  if ((lc & 0x80) || (end > buf + len)) return MQTT_INCOMPLETE;
+  m->dgram.len = (size_t) (end - buf);
+
+  switch (m->cmd) {
+    case MQTT_CMD_CONNACK:
+      if (end - p < 2) return MQTT_MALFORMED;
+      m->ack = p[1];
+      break;
+    case MQTT_CMD_PUBACK:
+    case MQTT_CMD_PUBREC:
+    case MQTT_CMD_PUBREL:
+    case MQTT_CMD_PUBCOMP:
+    case MQTT_CMD_SUBSCRIBE:
+    case MQTT_CMD_SUBACK:
+    case MQTT_CMD_UNSUBSCRIBE:
+    case MQTT_CMD_UNSUBACK:
+      if (p + 2 > end) return MQTT_MALFORMED;
+      m->id = (uint16_t) ((((uint16_t) p[0]) << 8) | p[1]);
+      p += 2;
+      break;
+    case MQTT_CMD_PUBLISH: {
+      if (p + 2 > end) return MQTT_MALFORMED;
+      m->topic.len = (uint16_t) ((((uint16_t) p[0]) << 8) | p[1]);
+      m->topic.ptr = (char *) p + 2;
+      p += 2 + m->topic.len;
+      if (p > end) return MQTT_MALFORMED;
+      if (m->qos > 0) {
+        if (p + 2 > end) return MQTT_MALFORMED;
+        m->id = (uint16_t) ((((uint16_t) p[0]) << 8) | p[1]);
+        p += 2;
+      }
+      if (p >= end) return MQTT_MALFORMED;
+      if (version == 5) p += 1 + p[0];  // Skip options
+      if (p > end) return MQTT_MALFORMED;
+      m->data.ptr = (char *) p;
+      m->data.len = (size_t) (end - p);
+      break;
+    }
+    default:
+      break;
+  }
+  return MQTT_OK;
+}
+
+static size_t mg_mqtt_next_topic(struct mg_mqtt_message *msg,
+                                 struct mg_str *topic, uint8_t *qos,
+                                 size_t pos) {
+  unsigned char *buf = (unsigned char *) msg->dgram.ptr + pos;
+  size_t new_pos;
+  if (pos >= msg->dgram.len) return 0;
+
+  topic->len = (size_t) (((unsigned) buf[0]) << 8 | buf[1]);
+  topic->ptr = (char *) buf + 2;
+  new_pos = pos + 2 + topic->len + (qos == NULL ? 0 : 1);
+  if ((size_t) new_pos > msg->dgram.len) return 0;
+  if (qos != NULL) *qos = buf[2 + topic->len];
+  return new_pos;
+}
+
+size_t mg_mqtt_next_sub(struct mg_mqtt_message *msg, struct mg_str *topic,
+                        uint8_t *qos, size_t pos) {
+  uint8_t tmp;
+  return mg_mqtt_next_topic(msg, topic, qos == NULL ? &tmp : qos, pos);
+}
+
+size_t mg_mqtt_next_unsub(struct mg_mqtt_message *msg, struct mg_str *topic,
+                          size_t pos) {
+  return mg_mqtt_next_topic(msg, topic, NULL, pos);
+}
+
+static void mqtt_cb(struct mg_connection *c, int ev, void *ev_data,
+                    void *fn_data) {
+  if (ev == MG_EV_READ) {
+    for (;;) {
+      uint8_t version = c->is_mqtt5 ? 5 : 4;
+      struct mg_mqtt_message mm;
+      int rc = mg_mqtt_parse(c->recv.buf, c->recv.len, version, &mm);
+      if (rc == MQTT_MALFORMED) {
+        MG_ERROR(("%lu MQTT malformed message", c->id));
+        c->is_closing = 1;
+        break;
+      } else if (rc == MQTT_OK) {
+        MG_VERBOSE(("%p MQTT CMD %d len %d [%.*s]", c->fd, mm.cmd,
+                    (int) mm.dgram.len, (int) mm.data.len, mm.data.ptr));
+        switch (mm.cmd) {
+          case MQTT_CMD_CONNACK:
+            mg_call(c, MG_EV_MQTT_OPEN, &mm.ack);
+            if (mm.ack == 0) {
+              MG_DEBUG(("%lu Connected", c->id));
+            } else {
+              MG_ERROR(("%lu MQTT auth failed, code %d", c->id, mm.ack));
+              c->is_closing = 1;
+            }
+            break;
+          case MQTT_CMD_PUBLISH: {
+            MG_DEBUG(("%lu [%.*s] -> [%.*s]", c->id, (int) mm.topic.len,
+                      mm.topic.ptr, (int) mm.data.len, mm.data.ptr));
+            if (mm.qos > 0) {
+              uint16_t id = mg_htons(mm.id);
+              mg_mqtt_send_header(c, MQTT_CMD_PUBACK, 0, sizeof(id));
+              mg_send(c, &id, sizeof(id));
+            }
+            mg_call(c, MG_EV_MQTT_MSG, &mm);
+            break;
+          }
+        }
+        mg_call(c, MG_EV_MQTT_CMD, &mm);
+        mg_iobuf_del(&c->recv, 0, mm.dgram.len);
+      } else {
+        break;
+      }
+    }
+  }
+  (void) ev_data;
+  (void) fn_data;
+}
+
+void mg_mqtt_ping(struct mg_connection *nc) {
+  mg_mqtt_send_header(nc, MQTT_CMD_PINGREQ, 0, 0);
+}
+
+void mg_mqtt_pong(struct mg_connection *nc) {
+  mg_mqtt_send_header(nc, MQTT_CMD_PINGRESP, 0, 0);
+}
+
+void mg_mqtt_disconnect(struct mg_connection *nc) {
+  mg_mqtt_send_header(nc, MQTT_CMD_DISCONNECT, 0, 0);
+}
+
+struct mg_connection *mg_mqtt_connect(struct mg_mgr *mgr, const char *url,
+                                      const struct mg_mqtt_opts *opts,
+                                      mg_event_handler_t fn, void *fn_data) {
+  struct mg_connection *c = mg_connect(mgr, url, fn, fn_data);
+  if (c != NULL) {
+    struct mg_mqtt_opts empty;
+    memset(&empty, 0, sizeof(empty));
+    mg_mqtt_login(c, opts == NULL ? &empty : opts);
+    c->pfn = mqtt_cb;
+  }
+  return c;
+}
+
+struct mg_connection *mg_mqtt_listen(struct mg_mgr *mgr, const char *url,
+                                     mg_event_handler_t fn, void *fn_data) {
+  struct mg_connection *c = mg_listen(mgr, url, fn, fn_data);
+  if (c != NULL) c->pfn = mqtt_cb, c->pfn_data = mgr;
+  return c;
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/net.c"
+#endif
+
+
+
+
+
+
+
+size_t mg_vprintf(struct mg_connection *c, const char *fmt, va_list ap) {
+  size_t old = c->send.len;
+  va_list tmp;
+  va_copy(tmp, ap);
+  mg_vrprintf(mg_putchar_iobuf, &c->send, fmt, &tmp);
+  return c->send.len - old;
+}
+
+size_t mg_printf(struct mg_connection *c, const char *fmt, ...) {
+  size_t len = 0;
+  va_list ap;
+  va_start(ap, fmt);
+  len = mg_vprintf(c, fmt, ap);
+  va_end(ap);
+  return len;
+}
+
+char *mg_straddr(struct mg_addr *a, char *buf, size_t len) {
+  char tmp[30];
+  const char *fmt = a->is_ip6 ? "[%s]:%d" : "%s:%d";
+  mg_ntoa(a, tmp, sizeof(tmp));
+  mg_snprintf(buf, len, fmt, tmp, (int) mg_ntohs(a->port));
+  return buf;
+}
+
+char *mg_ntoa(const struct mg_addr *addr, char *buf, size_t len) {
+  if (addr->is_ip6) {
+    uint16_t *p = (uint16_t *) addr->ip6;
+    mg_snprintf(buf, len, "%x:%x:%x:%x:%x:%x:%x:%x", mg_htons(p[0]),
+                mg_htons(p[1]), mg_htons(p[2]), mg_htons(p[3]), mg_htons(p[4]),
+                mg_htons(p[5]), mg_htons(p[6]), mg_htons(p[7]));
+  } else {
+    uint8_t p[4];
+    memcpy(p, &addr->ip, sizeof(p));
+    mg_snprintf(buf, len, "%d.%d.%d.%d", (int) p[0], (int) p[1], (int) p[2],
+                (int) p[3]);
+  }
+  return buf;
+}
+
+static bool mg_atonl(struct mg_str str, struct mg_addr *addr) {
+  if (mg_vcasecmp(&str, "localhost") != 0) return false;
+  addr->ip = mg_htonl(0x7f000001);
+  addr->is_ip6 = false;
+  return true;
+}
+
+static bool mg_atone(struct mg_str str, struct mg_addr *addr) {
+  if (str.len > 0) return false;
+  addr->ip = 0;
+  addr->is_ip6 = false;
+  return true;
+}
+
+static bool mg_aton4(struct mg_str str, struct mg_addr *addr) {
+  uint8_t data[4] = {0, 0, 0, 0};
+  size_t i, num_dots = 0;
+  for (i = 0; i < str.len; i++) {
+    if (str.ptr[i] >= '0' && str.ptr[i] <= '9') {
+      int octet = data[num_dots] * 10 + (str.ptr[i] - '0');
+      if (octet > 255) return false;
+      data[num_dots] = (uint8_t) octet;
+    } else if (str.ptr[i] == '.') {
+      if (num_dots >= 3 || i == 0 || str.ptr[i - 1] == '.') return false;
+      num_dots++;
+    } else {
+      return false;
+    }
+  }
+  if (num_dots != 3 || str.ptr[i - 1] == '.') return false;
+  memcpy(&addr->ip, data, sizeof(data));
+  addr->is_ip6 = false;
+  return true;
+}
+
+static bool mg_v4mapped(struct mg_str str, struct mg_addr *addr) {
+  int i;
+  if (str.len < 14) return false;
+  if (str.ptr[0] != ':' || str.ptr[1] != ':' || str.ptr[6] != ':') return false;
+  for (i = 2; i < 6; i++) {
+    if (str.ptr[i] != 'f' && str.ptr[i] != 'F') return false;
+  }
+  if (!mg_aton4(mg_str_n(&str.ptr[7], str.len - 7), addr)) return false;
+  memset(addr->ip6, 0, sizeof(addr->ip6));
+  addr->ip6[10] = addr->ip6[11] = 255;
+  memcpy(&addr->ip6[12], &addr->ip, 4);
+  addr->is_ip6 = true;
+  return true;
+}
+
+static bool mg_aton6(struct mg_str str, struct mg_addr *addr) {
+  size_t i, j = 0, n = 0, dc = 42;
+  if (str.len > 2 && str.ptr[0] == '[') str.ptr++, str.len -= 2;
+  if (mg_v4mapped(str, addr)) return true;
+  for (i = 0; i < str.len; i++) {
+    if ((str.ptr[i] >= '0' && str.ptr[i] <= '9') ||
+        (str.ptr[i] >= 'a' && str.ptr[i] <= 'f') ||
+        (str.ptr[i] >= 'A' && str.ptr[i] <= 'F')) {
+      unsigned long val;
+      if (i > j + 3) return false;
+      // MG_DEBUG(("%zu %zu [%.*s]", i, j, (int) (i - j + 1), &str.ptr[j]));
+      val = mg_unhexn(&str.ptr[j], i - j + 1);
+      addr->ip6[n] = (uint8_t) ((val >> 8) & 255);
+      addr->ip6[n + 1] = (uint8_t) (val & 255);
+    } else if (str.ptr[i] == ':') {
+      j = i + 1;
+      if (i > 0 && str.ptr[i - 1] == ':') {
+        dc = n;  // Double colon
+        if (i > 1 && str.ptr[i - 2] == ':') return false;
+      } else if (i > 0) {
+        n += 2;
+      }
+      if (n > 14) return false;
+      addr->ip6[n] = addr->ip6[n + 1] = 0;  // For trailing ::
+    } else {
+      return false;
+    }
+  }
+  if (n < 14 && dc == 42) return false;
+  if (n < 14) {
+    memmove(&addr->ip6[dc + (14 - n)], &addr->ip6[dc], n - dc + 2);
+    memset(&addr->ip6[dc], 0, 14 - n);
+  }
+  addr->is_ip6 = true;
+  return true;
+}
+
+bool mg_aton(struct mg_str str, struct mg_addr *addr) {
+  // MG_INFO(("[%.*s]", (int) str.len, str.ptr));
+  return mg_atone(str, addr) || mg_atonl(str, addr) || mg_aton4(str, addr) ||
+         mg_aton6(str, addr);
+}
+
+struct mg_connection *mg_alloc_conn(struct mg_mgr *mgr) {
+  struct mg_connection *c =
+      (struct mg_connection *) calloc(1, sizeof(*c) + mgr->extraconnsize);
+  if (c != NULL) {
+    c->mgr = mgr;
+    c->id = ++mgr->nextid;
+  }
+  return c;
+}
+
+void mg_close_conn(struct mg_connection *c) {
+  mg_resolve_cancel(c);  // Close any pending DNS query
+  LIST_DELETE(struct mg_connection, &c->mgr->conns, c);
+  if (c == c->mgr->dns4.c) c->mgr->dns4.c = NULL;
+  if (c == c->mgr->dns6.c) c->mgr->dns6.c = NULL;
+  // Order of operations is important. `MG_EV_CLOSE` event must be fired
+  // before we deallocate received data, see #1331
+  mg_call(c, MG_EV_CLOSE, NULL);
+  MG_DEBUG(("%lu closed", c->id));
+
+  mg_tls_free(c);
+  mg_iobuf_free(&c->recv);
+  mg_iobuf_free(&c->send);
+  memset(c, 0, sizeof(*c));
+  free(c);
+}
+
+struct mg_connection *mg_connect(struct mg_mgr *mgr, const char *url,
+                                 mg_event_handler_t fn, void *fn_data) {
+  struct mg_connection *c = NULL;
+  if (url == NULL || url[0] == '\0') {
+    MG_ERROR(("null url"));
+  } else if ((c = mg_alloc_conn(mgr)) == NULL) {
+    MG_ERROR(("OOM"));
+  } else {
+    LIST_ADD_HEAD(struct mg_connection, &mgr->conns, c);
+    c->is_udp = (strncmp(url, "udp:", 4) == 0);
+    c->fn = fn;
+    c->is_client = true;
+    c->fd = (void *) (size_t) -1;  // Set to invalid socket
+    c->fn_data = fn_data;
+    MG_DEBUG(("%lu -1 %s", c->id, url));
+    mg_call(c, MG_EV_OPEN, NULL);
+    mg_resolve(c, url);
+  }
+  return c;
+}
+
+struct mg_connection *mg_listen(struct mg_mgr *mgr, const char *url,
+                                mg_event_handler_t fn, void *fn_data) {
+  struct mg_connection *c = NULL;
+  if ((c = mg_alloc_conn(mgr)) == NULL) {
+    MG_ERROR(("OOM %s", url));
+  } else if (!mg_open_listener(c, url)) {
+    MG_ERROR(("Failed: %s, errno %d", url, errno));
+    free(c);
+    c = NULL;
+  } else {
+    c->is_listening = 1;
+    c->is_udp = strncmp(url, "udp:", 4) == 0;
+    LIST_ADD_HEAD(struct mg_connection, &mgr->conns, c);
+    c->fn = fn;
+    c->fn_data = fn_data;
+    mg_call(c, MG_EV_OPEN, NULL);
+    MG_DEBUG(("%lu %p %s", c->id, c->fd, url));
+  }
+  return c;
+}
+
+struct mg_connection *mg_wrapfd(struct mg_mgr *mgr, int fd,
+                                mg_event_handler_t fn, void *fn_data) {
+  struct mg_connection *c = mg_alloc_conn(mgr);
+  if (c != NULL) {
+    c->fd = (void *) (size_t) fd;
+    c->fn = fn;
+    c->fn_data = fn_data;
+    mg_call(c, MG_EV_OPEN, NULL);
+    LIST_ADD_HEAD(struct mg_connection, &mgr->conns, c);
+  }
+  return c;
+}
+
+struct mg_timer *mg_timer_add(struct mg_mgr *mgr, uint64_t milliseconds,
+                              unsigned flags, void (*fn)(void *), void *arg) {
+  struct mg_timer *t = (struct mg_timer *) calloc(1, sizeof(*t));
+  mg_timer_init(&mgr->timers, t, milliseconds, flags, fn, arg);
+  t->id = mgr->timerid++;
+  return t;
+}
+
+void mg_mgr_free(struct mg_mgr *mgr) {
+  struct mg_connection *c;
+  struct mg_timer *tmp, *t = mgr->timers;
+  while (t != NULL) tmp = t->next, free(t), t = tmp;
+  mgr->timers = NULL;  // Important. Next call to poll won't touch timers
+  for (c = mgr->conns; c != NULL; c = c->next) c->is_closing = 1;
+  mg_mgr_poll(mgr, 0);
+#if MG_ARCH == MG_ARCH_FREERTOS_TCP
+  FreeRTOS_DeleteSocketSet(mgr->ss);
+#endif
+  MG_DEBUG(("All connections closed"));
+}
+
+void mg_mgr_init(struct mg_mgr *mgr) {
+  memset(mgr, 0, sizeof(*mgr));
+#if MG_ARCH == MG_ARCH_WIN32 && MG_ENABLE_WINSOCK
+  // clang-format off
+  { WSADATA data; WSAStartup(MAKEWORD(2, 2), &data); }
+  // clang-format on
+#elif MG_ARCH == MG_ARCH_FREERTOS_TCP
+  mgr->ss = FreeRTOS_CreateSocketSet();
+#elif defined(__unix) || defined(__unix__) || defined(__APPLE__)
+  // Ignore SIGPIPE signal, so if client cancels the request, it
+  // won't kill the whole process.
+  signal(SIGPIPE, SIG_IGN);
+#endif
+  mgr->dnstimeout = 3000;
+  mgr->dns4.url = "udp://8.8.8.8:53";
+  mgr->dns6.url = "udp://[2001:4860:4860::8888]:53";
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/sha1.c"
+#endif
+/* Copyright(c) By Steve Reid <steve@edmweb.com> */
+/* 100% Public Domain */
+
+
+
+/*
+ * clang with std=-c99 uses __LITTLE_ENDIAN, by default
+ * while for ex, RTOS gcc - LITTLE_ENDIAN, by default
+ * it depends on __USE_BSD, but let's have everything
+ */
+#if !defined(BYTE_ORDER) && defined(__BYTE_ORDER)
+#define BYTE_ORDER __BYTE_ORDER
+#ifndef LITTLE_ENDIAN
+#define LITTLE_ENDIAN __LITTLE_ENDIAN
+#endif /* LITTLE_ENDIAN */
+#ifndef BIG_ENDIAN
+#define BIG_ENDIAN __LITTLE_ENDIAN
+#endif /* BIG_ENDIAN */
+#endif /* BYTE_ORDER */
+
+union char64long16 {
+  unsigned char c[64];
+  uint32_t l[16];
+};
+
+#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
+
+static uint32_t blk0(union char64long16 *block, int i) {
+/* Forrest: SHA expect BIG_ENDIAN, swap if LITTLE_ENDIAN */
+#if BYTE_ORDER == LITTLE_ENDIAN
+  block->l[i] =
+      (rol(block->l[i], 24) & 0xFF00FF00) | (rol(block->l[i], 8) & 0x00FF00FF);
+#endif
+  return block->l[i];
+}
+
+/* Avoid redefine warning (ARM /usr/include/sys/ucontext.h define R0~R4) */
+#undef blk
+#undef R0
+#undef R1
+#undef R2
+#undef R3
+#undef R4
+
+#define blk(i)                                                               \
+  (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \
+                              block->l[(i + 2) & 15] ^ block->l[i & 15],     \
+                          1))
+#define R0(v, w, x, y, z, i)                                          \
+  z += ((w & (x ^ y)) ^ y) + blk0(block, i) + 0x5A827999 + rol(v, 5); \
+  w = rol(w, 30);
+#define R1(v, w, x, y, z, i)                                  \
+  z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
+  w = rol(w, 30);
+#define R2(v, w, x, y, z, i)                          \
+  z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \
+  w = rol(w, 30);
+#define R3(v, w, x, y, z, i)                                        \
+  z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
+  w = rol(w, 30);
+#define R4(v, w, x, y, z, i)                          \
+  z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
+  w = rol(w, 30);
+
+static void mg_sha1_transform(uint32_t state[5],
+                              const unsigned char buffer[64]) {
+  uint32_t a, b, c, d, e;
+  union char64long16 block[1];
+
+  memcpy(block, buffer, 64);
+  a = state[0];
+  b = state[1];
+  c = state[2];
+  d = state[3];
+  e = state[4];
+  R0(a, b, c, d, e, 0);
+  R0(e, a, b, c, d, 1);
+  R0(d, e, a, b, c, 2);
+  R0(c, d, e, a, b, 3);
+  R0(b, c, d, e, a, 4);
+  R0(a, b, c, d, e, 5);
+  R0(e, a, b, c, d, 6);
+  R0(d, e, a, b, c, 7);
+  R0(c, d, e, a, b, 8);
+  R0(b, c, d, e, a, 9);
+  R0(a, b, c, d, e, 10);
+  R0(e, a, b, c, d, 11);
+  R0(d, e, a, b, c, 12);
+  R0(c, d, e, a, b, 13);
+  R0(b, c, d, e, a, 14);
+  R0(a, b, c, d, e, 15);
+  R1(e, a, b, c, d, 16);
+  R1(d, e, a, b, c, 17);
+  R1(c, d, e, a, b, 18);
+  R1(b, c, d, e, a, 19);
+  R2(a, b, c, d, e, 20);
+  R2(e, a, b, c, d, 21);
+  R2(d, e, a, b, c, 22);
+  R2(c, d, e, a, b, 23);
+  R2(b, c, d, e, a, 24);
+  R2(a, b, c, d, e, 25);
+  R2(e, a, b, c, d, 26);
+  R2(d, e, a, b, c, 27);
+  R2(c, d, e, a, b, 28);
+  R2(b, c, d, e, a, 29);
+  R2(a, b, c, d, e, 30);
+  R2(e, a, b, c, d, 31);
+  R2(d, e, a, b, c, 32);
+  R2(c, d, e, a, b, 33);
+  R2(b, c, d, e, a, 34);
+  R2(a, b, c, d, e, 35);
+  R2(e, a, b, c, d, 36);
+  R2(d, e, a, b, c, 37);
+  R2(c, d, e, a, b, 38);
+  R2(b, c, d, e, a, 39);
+  R3(a, b, c, d, e, 40);
+  R3(e, a, b, c, d, 41);
+  R3(d, e, a, b, c, 42);
+  R3(c, d, e, a, b, 43);
+  R3(b, c, d, e, a, 44);
+  R3(a, b, c, d, e, 45);
+  R3(e, a, b, c, d, 46);
+  R3(d, e, a, b, c, 47);
+  R3(c, d, e, a, b, 48);
+  R3(b, c, d, e, a, 49);
+  R3(a, b, c, d, e, 50);
+  R3(e, a, b, c, d, 51);
+  R3(d, e, a, b, c, 52);
+  R3(c, d, e, a, b, 53);
+  R3(b, c, d, e, a, 54);
+  R3(a, b, c, d, e, 55);
+  R3(e, a, b, c, d, 56);
+  R3(d, e, a, b, c, 57);
+  R3(c, d, e, a, b, 58);
+  R3(b, c, d, e, a, 59);
+  R4(a, b, c, d, e, 60);
+  R4(e, a, b, c, d, 61);
+  R4(d, e, a, b, c, 62);
+  R4(c, d, e, a, b, 63);
+  R4(b, c, d, e, a, 64);
+  R4(a, b, c, d, e, 65);
+  R4(e, a, b, c, d, 66);
+  R4(d, e, a, b, c, 67);
+  R4(c, d, e, a, b, 68);
+  R4(b, c, d, e, a, 69);
+  R4(a, b, c, d, e, 70);
+  R4(e, a, b, c, d, 71);
+  R4(d, e, a, b, c, 72);
+  R4(c, d, e, a, b, 73);
+  R4(b, c, d, e, a, 74);
+  R4(a, b, c, d, e, 75);
+  R4(e, a, b, c, d, 76);
+  R4(d, e, a, b, c, 77);
+  R4(c, d, e, a, b, 78);
+  R4(b, c, d, e, a, 79);
+  state[0] += a;
+  state[1] += b;
+  state[2] += c;
+  state[3] += d;
+  state[4] += e;
+  /* Erase working structures. The order of operations is important,
+   * used to ensure that compiler doesn't optimize those out. */
+  memset(block, 0, sizeof(block));
+  a = b = c = d = e = 0;
+  (void) a;
+  (void) b;
+  (void) c;
+  (void) d;
+  (void) e;
+}
+
+void mg_sha1_init(mg_sha1_ctx *context) {
+  context->state[0] = 0x67452301;
+  context->state[1] = 0xEFCDAB89;
+  context->state[2] = 0x98BADCFE;
+  context->state[3] = 0x10325476;
+  context->state[4] = 0xC3D2E1F0;
+  context->count[0] = context->count[1] = 0;
+}
+
+void mg_sha1_update(mg_sha1_ctx *context, const unsigned char *data,
+                    size_t len) {
+  size_t i, j;
+
+  j = context->count[0];
+  if ((context->count[0] += (uint32_t) len << 3) < j) context->count[1]++;
+  context->count[1] += (uint32_t) (len >> 29);
+  j = (j >> 3) & 63;
+  if ((j + len) > 63) {
+    memcpy(&context->buffer[j], data, (i = 64 - j));
+    mg_sha1_transform(context->state, context->buffer);
+    for (; i + 63 < len; i += 64) {
+      mg_sha1_transform(context->state, &data[i]);
+    }
+    j = 0;
+  } else
+    i = 0;
+  memcpy(&context->buffer[j], &data[i], len - i);
+}
+
+void mg_sha1_final(unsigned char digest[20], mg_sha1_ctx *context) {
+  unsigned i;
+  unsigned char finalcount[8], c;
+
+  for (i = 0; i < 8; i++) {
+    finalcount[i] = (unsigned char) ((context->count[(i >= 4 ? 0 : 1)] >>
+                                      ((3 - (i & 3)) * 8)) &
+                                     255);
+  }
+  c = 0200;
+  mg_sha1_update(context, &c, 1);
+  while ((context->count[0] & 504) != 448) {
+    c = 0000;
+    mg_sha1_update(context, &c, 1);
+  }
+  mg_sha1_update(context, finalcount, 8);
+  for (i = 0; i < 20; i++) {
+    digest[i] =
+        (unsigned char) ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
+  }
+  memset(context, '\0', sizeof(*context));
+  memset(&finalcount, '\0', sizeof(finalcount));
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/sntp.c"
+#endif
+
+
+
+
+
+
+#define SNTP_INTERVAL_SEC 3600
+#define SNTP_TIME_OFFSET 2208988800UL
+
+int64_t mg_sntp_parse(const unsigned char *buf, size_t len) {
+  int64_t res = -1;
+  int mode = len > 0 ? buf[0] & 7 : 0;
+  int version = len > 0 ? (buf[0] >> 3) & 7 : 0;
+  if (len < 48) {
+    MG_ERROR(("%s", "corrupt packet"));
+  } else if (mode != 4 && mode != 5) {
+    MG_ERROR(("%s", "not a server reply"));
+  } else if (buf[1] == 0) {
+    MG_ERROR(("%s", "server sent a kiss of death"));
+  } else if (version == 4 || version == 3) {
+    uint32_t *data = (uint32_t *) &buf[40];
+    unsigned long seconds = mg_ntohl(data[0]) - SNTP_TIME_OFFSET;
+    unsigned long fracseconds = mg_ntohl(data[1]);
+    res = ((int64_t) seconds) * 1000 + (((int64_t) (fracseconds) * 1000) >> 32);
+  } else {
+    MG_ERROR(("unexpected version: %d", version));
+  }
+  return res;
+}
+
+static void sntp_cb(struct mg_connection *c, int ev, void *evd, void *fnd) {
+  if (ev == MG_EV_READ) {
+    int64_t milliseconds = mg_sntp_parse(c->recv.buf, c->recv.len);
+    if (milliseconds > 0) {
+      mg_call(c, MG_EV_SNTP_TIME, (uint64_t *) &milliseconds);
+      MG_VERBOSE(("%u.%u", (unsigned) (milliseconds / 1000),
+                  (unsigned) (milliseconds % 1000)));
+    }
+    mg_iobuf_del(&c->recv, 0, c->recv.len);  // Free receive buffer
+  } else if (ev == MG_EV_CONNECT) {
+    mg_sntp_request(c);
+  } else if (ev == MG_EV_CLOSE) {
+  }
+  (void) fnd;
+  (void) evd;
+}
+
+void mg_sntp_request(struct mg_connection *c) {
+  if (c->is_resolving) {
+    MG_ERROR(("%lu wait until resolved", c->id));
+  } else {
+    uint8_t buf[48] = {0};
+    buf[0] = (0 << 6) | (4 << 3) | 3;
+    mg_send(c, buf, sizeof(buf));
+  }
+}
+
+struct mg_connection *mg_sntp_connect(struct mg_mgr *mgr, const char *url,
+                                      mg_event_handler_t fn, void *fnd) {
+  struct mg_connection *c = NULL;
+  if (url == NULL) url = "udp://time.google.com:123";
+  if ((c = mg_connect(mgr, url, fn, fnd)) != NULL) c->pfn = sntp_cb;
+  return c;
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/sock.c"
+#endif
+
+
+
+
+
+
+
+
+
+
+#if MG_ENABLE_SOCKET
+#if MG_ARCH == MG_ARCH_WIN32 && MG_ENABLE_WINSOCK
+typedef unsigned long nfds_t;
+#define MG_SOCK_ERRNO WSAGetLastError()
+#if defined(_MSC_VER)
+#pragma comment(lib, "ws2_32.lib")
+#define alloca(a) _alloca(a)
+#endif
+#define poll(a, b, c) WSAPoll((a), (b), (c))
+#ifndef SO_EXCLUSIVEADDRUSE
+#define SO_EXCLUSIVEADDRUSE ((int) (~SO_REUSEADDR))
+#endif
+#elif MG_ARCH == MG_ARCH_FREERTOS_TCP
+#define MG_SOCK_ERRNO errno
+typedef Socket_t SOCKET;
+#define INVALID_SOCKET FREERTOS_INVALID_SOCKET
+#elif MG_ARCH == MG_ARCH_TIRTOS
+#define MG_SOCK_ERRNO errno
+#define closesocket(x) close(x)
+#else
+#define MG_SOCK_ERRNO errno
+#ifndef closesocket
+#define closesocket(x) close(x)
+#endif
+#define INVALID_SOCKET (-1)
+typedef int SOCKET;
+#endif
+
+#define FD(c_) ((SOCKET) (size_t) (c_)->fd)
+#define S2PTR(s_) ((void *) (size_t) (s_))
+
+#ifndef MSG_NONBLOCKING
+#define MSG_NONBLOCKING 0
+#endif
+
+#ifndef AF_INET6
+#define AF_INET6 10
+#endif
+
+union usa {
+  struct sockaddr sa;
+  struct sockaddr_in sin;
+#if MG_ENABLE_IPV6
+  struct sockaddr_in6 sin6;
+#endif
+};
+
+static socklen_t tousa(struct mg_addr *a, union usa *usa) {
+  socklen_t len = sizeof(usa->sin);
+  memset(usa, 0, sizeof(*usa));
+  usa->sin.sin_family = AF_INET;
+  usa->sin.sin_port = a->port;
+  *(uint32_t *) &usa->sin.sin_addr = a->ip;
+#if MG_ENABLE_IPV6
+  if (a->is_ip6) {
+    usa->sin.sin_family = AF_INET6;
+    usa->sin6.sin6_port = a->port;
+    memcpy(&usa->sin6.sin6_addr, a->ip6, sizeof(a->ip6));
+    len = sizeof(usa->sin6);
+  }
+#endif
+  return len;
+}
+
+static void tomgaddr(union usa *usa, struct mg_addr *a, bool is_ip6) {
+  a->is_ip6 = is_ip6;
+  a->port = usa->sin.sin_port;
+  memcpy(&a->ip, &usa->sin.sin_addr, sizeof(a->ip));
+#if MG_ENABLE_IPV6
+  if (is_ip6) {
+    memcpy(a->ip6, &usa->sin6.sin6_addr, sizeof(a->ip6));
+    a->port = usa->sin6.sin6_port;
+  }
+#endif
+}
+
+bool mg_sock_would_block(void);
+bool mg_sock_would_block(void) {
+  int err = MG_SOCK_ERRNO;
+  return err == EINPROGRESS || err == EWOULDBLOCK
+#ifndef WINCE
+         || err == EAGAIN || err == EINTR
+#endif
+#if MG_ARCH == MG_ARCH_WIN32 && MG_ENABLE_WINSOCK
+         || err == WSAEINTR || err == WSAEWOULDBLOCK
+#endif
+      ;
+}
+
+bool mg_sock_conn_reset(void);
+bool mg_sock_conn_reset(void) {
+  int err = MG_SOCK_ERRNO;
+#if MG_ARCH == MG_ARCH_WIN32 && MG_ENABLE_WINSOCK
+  return err == WSAECONNRESET;
+#else
+  return err == EPIPE || err == ECONNRESET;
+#endif
+}
+
+static void setlocaddr(SOCKET fd, struct mg_addr *addr) {
+  union usa usa;
+  socklen_t n = sizeof(usa);
+  if (getsockname(fd, &usa.sa, &n) == 0) {
+    tomgaddr(&usa, addr, n != sizeof(usa.sin));
+  }
+}
+
+static void iolog(struct mg_connection *c, char *buf, long n, bool r) {
+  if (n == 0) {
+    // Do nothing
+  } else if (n < 0) {
+    c->is_closing = 1;  // Termination. Don't call mg_error(): #1529
+  } else if (n > 0) {
+    if (c->is_hexdumping) {
+      union usa usa;
+      char t1[50], t2[50];
+      socklen_t slen = sizeof(usa.sin);
+      struct mg_addr a;
+      memset(&usa, 0, sizeof(usa));
+      memset(&a, 0, sizeof(a));
+      if (getsockname(FD(c), &usa.sa, &slen) < 0) (void) 0;  // Ignore result
+      tomgaddr(&usa, &a, c->rem.is_ip6);
+      MG_INFO(("\n-- %lu %s %s %s %s %ld", c->id,
+               mg_straddr(&a, t1, sizeof(t1)), r ? "<-" : "->",
+               mg_straddr(&c->rem, t2, sizeof(t2)), c->label, n));
+
+      mg_hexdump(buf, (size_t) n);
+    }
+    if (r) {
+      struct mg_str evd = mg_str_n(buf, (size_t) n);
+      c->recv.len += (size_t) n;
+      mg_call(c, MG_EV_READ, &evd);
+    } else {
+      mg_iobuf_del(&c->send, 0, (size_t) n);
+      // if (c->send.len == 0) mg_iobuf_resize(&c->send, 0);
+      mg_call(c, MG_EV_WRITE, &n);
+    }
+  }
+}
+
+static long mg_sock_send(struct mg_connection *c, const void *buf, size_t len) {
+  long n;
+  if (c->is_udp) {
+    union usa usa;
+    socklen_t slen = tousa(&c->rem, &usa);
+    n = sendto(FD(c), (char *) buf, len, 0, &usa.sa, slen);
+    if (n > 0) setlocaddr(FD(c), &c->loc);
+  } else {
+    n = send(FD(c), (char *) buf, len, MSG_NONBLOCKING);
+#if MG_ARCH == MG_ARCH_RTX
+    if (n == BSD_EWOULDBLOCK) return 0;
+#endif
+  }
+  return n == 0 ? -1 : n < 0 && mg_sock_would_block() ? 0 : n;
+}
+
+bool mg_send(struct mg_connection *c, const void *buf, size_t len) {
+  if (c->is_udp) {
+    long n = mg_sock_send(c, buf, len);
+    MG_DEBUG(("%lu %p %d:%d %ld err %d", c->id, c->fd, (int) c->send.len,
+              (int) c->recv.len, n, MG_SOCK_ERRNO));
+    iolog(c, (char *) buf, n, false);
+    return n > 0;
+  } else {
+    return mg_iobuf_add(&c->send, c->send.len, buf, len, MG_IO_SIZE);
+  }
+}
+
+static void mg_set_non_blocking_mode(SOCKET fd) {
+#if defined(MG_CUSTOM_NONBLOCK)
+  MG_CUSTOM_NONBLOCK(fd);
+#elif MG_ARCH == MG_ARCH_WIN32 && MG_ENABLE_WINSOCK
+  unsigned long on = 1;
+  ioctlsocket(fd, FIONBIO, &on);
+#elif MG_ARCH == MG_ARCH_RTX
+  unsigned long on = 1;
+  ioctlsocket(fd, FIONBIO, &on);
+#elif MG_ARCH == MG_ARCH_FREERTOS_TCP
+  const BaseType_t off = 0;
+  if (setsockopt(fd, 0, FREERTOS_SO_RCVTIMEO, &off, sizeof(off)) != 0) (void) 0;
+  if (setsockopt(fd, 0, FREERTOS_SO_SNDTIMEO, &off, sizeof(off)) != 0) (void) 0;
+#elif MG_ARCH == MG_ARCH_FREERTOS_LWIP || MG_ARCH == MG_ARCH_RTX_LWIP
+  lwip_fcntl(fd, F_SETFL, O_NONBLOCK);
+#elif MG_ARCH == MG_ARCH_AZURERTOS
+  fcntl(fd, F_SETFL, O_NONBLOCK);
+#elif MG_ARCH == MG_ARCH_TIRTOS
+  int val = 0;
+  setsockopt(fd, 0, SO_BLOCKING, &val, sizeof(val));
+  int status = 0;
+  int res = SockStatus(fd, FDSTATUS_SEND, &status);
+  if (res == 0 && status > 0) {
+    val = status / 2;
+    int val_size = sizeof(val);
+    res = SockSet(fd, SOL_SOCKET, SO_SNDLOWAT, &val, val_size);
+  }
+#else
+  fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK);  // Non-blocking mode
+  fcntl(fd, F_SETFD, FD_CLOEXEC);                          // Set close-on-exec
+#endif
+}
+
+bool mg_open_listener(struct mg_connection *c, const char *url) {
+  SOCKET fd = INVALID_SOCKET;
+  bool success = false;
+  c->loc.port = mg_htons(mg_url_port(url));
+  if (!mg_aton(mg_url_host(url), &c->loc)) {
+    MG_ERROR(("invalid listening URL: %s", url));
+  } else {
+    union usa usa;
+    socklen_t slen = tousa(&c->loc, &usa);
+    int on = 1, af = c->loc.is_ip6 ? AF_INET6 : AF_INET;
+    int type = strncmp(url, "udp:", 4) == 0 ? SOCK_DGRAM : SOCK_STREAM;
+    int proto = type == SOCK_DGRAM ? IPPROTO_UDP : IPPROTO_TCP;
+    (void) on;
+
+    if ((fd = socket(af, type, proto)) == INVALID_SOCKET) {
+      MG_ERROR(("socket: %d", MG_SOCK_ERRNO));
+#if ((MG_ARCH == MG_ARCH_WIN32) || (MG_ARCH == MG_ARCH_UNIX) || \
+     (defined(LWIP_SOCKET) && SO_REUSE == 1))
+    } else if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &on,
+                          sizeof(on)) != 0) {
+      // 1. SO_RESUSEADDR is not enabled on Windows because the semantics of
+      //    SO_REUSEADDR on UNIX and Windows is different. On Windows,
+      //    SO_REUSEADDR allows to bind a socket to a port without error even
+      //    if the port is already open by another program. This is not the
+      //    behavior SO_REUSEADDR was designed for, and leads to hard-to-track
+      //    failure scenarios. Therefore, SO_REUSEADDR was disabled on Windows
+      //    unless SO_EXCLUSIVEADDRUSE is supported and set on a socket.
+      // 2. In case of LWIP, SO_REUSEADDR should be explicitly enabled, by
+      // defining
+      //    SO_REUSE (in lwipopts.h), otherwise the code below will compile
+      //    but won't work! (setsockopt will return EINVAL)
+      MG_ERROR(("reuseaddr: %d", MG_SOCK_ERRNO));
+#endif
+#if MG_ARCH == MG_ARCH_WIN32 && !defined(SO_EXCLUSIVEADDRUSE) && !defined(WINCE)
+    } else if (setsockopt(fd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char *) &on,
+                          sizeof(on)) != 0) {
+      // "Using SO_REUSEADDR and SO_EXCLUSIVEADDRUSE"
+      MG_ERROR(("exclusiveaddruse: %d", MG_SOCK_ERRNO));
+#endif
+    } else if (bind(fd, &usa.sa, slen) != 0) {
+      MG_ERROR(("bind: %d", MG_SOCK_ERRNO));
+    } else if ((type == SOCK_STREAM &&
+                listen(fd, MG_SOCK_LISTEN_BACKLOG_SIZE) != 0)) {
+      // NOTE(lsm): FreeRTOS uses backlog value as a connection limit
+      // In case port was set to 0, get the real port number
+      MG_ERROR(("listen: %d", MG_SOCK_ERRNO));
+    } else {
+      setlocaddr(fd, &c->loc);
+      mg_set_non_blocking_mode(fd);
+      c->fd = S2PTR(fd);
+      success = true;
+    }
+  }
+  if (success == false && fd != INVALID_SOCKET) closesocket(fd);
+  return success;
+}
+
+static long mg_sock_recv(struct mg_connection *c, void *buf, size_t len) {
+  long n = 0;
+  if (c->is_udp) {
+    union usa usa;
+    socklen_t slen = tousa(&c->rem, &usa);
+    n = recvfrom(FD(c), (char *) buf, len, 0, &usa.sa, &slen);
+    if (n > 0) tomgaddr(&usa, &c->rem, slen != sizeof(usa.sin));
+  } else {
+    n = recv(FD(c), (char *) buf, len, MSG_NONBLOCKING);
+  }
+  return n == 0 ? -1 : n < 0 && mg_sock_would_block() ? 0 : n;
+}
+
+// NOTE(lsm): do only one iteration of reads, cause some systems
+// (e.g. FreeRTOS stack) return 0 instead of -1/EWOULDBLOCK when no data
+static void read_conn(struct mg_connection *c) {
+  long n = -1;
+  if (c->recv.len >= MG_MAX_RECV_SIZE) {
+    mg_error(c, "max_recv_buf_size reached");
+  } else if (c->recv.size <= c->recv.len &&
+             !mg_iobuf_resize(&c->recv, c->recv.size + MG_IO_SIZE)) {
+    mg_error(c, "oom");
+  } else {
+    char *buf = (char *) &c->recv.buf[c->recv.len];
+    size_t len = c->recv.size - c->recv.len;
+    n = c->is_tls ? mg_tls_recv(c, buf, len) : mg_sock_recv(c, buf, len);
+    MG_DEBUG(("%lu %p %d:%d %ld err %d", c->id, c->fd, (int) c->send.len,
+              (int) c->recv.len, n, MG_SOCK_ERRNO));
+    iolog(c, buf, n, true);
+  }
+}
+
+static void write_conn(struct mg_connection *c) {
+  char *buf = (char *) c->send.buf;
+  size_t len = c->send.len;
+  long n = c->is_tls ? mg_tls_send(c, buf, len) : mg_sock_send(c, buf, len);
+  MG_DEBUG(("%lu %p %d:%d %ld err %d", c->id, c->fd, (int) c->send.len,
+            (int) c->recv.len, n, MG_SOCK_ERRNO));
+  iolog(c, buf, n, false);
+}
+
+static void close_conn(struct mg_connection *c) {
+  if (FD(c) != INVALID_SOCKET) {
+    closesocket(FD(c));
+#if MG_ARCH == MG_ARCH_FREERTOS_TCP
+    FreeRTOS_FD_CLR(c->fd, c->mgr->ss, eSELECT_ALL);
+#endif
+    c->fd = NULL;
+  }
+  mg_close_conn(c);
+}
+
+static void connect_conn(struct mg_connection *c) {
+  union usa usa;
+  socklen_t n = sizeof(usa);
+  // Use getpeername() to test whether we have connected
+  if (getpeername(FD(c), &usa.sa, &n) == 0) {
+    c->is_connecting = 0;
+    mg_call(c, MG_EV_CONNECT, NULL);
+    if (c->is_tls_hs) mg_tls_handshake(c);
+  } else {
+    mg_error(c, "socket error");
+  }
+}
+
+static void setsockopts(struct mg_connection *c) {
+#if MG_ARCH == MG_ARCH_FREERTOS_TCP || MG_ARCH == MG_ARCH_AZURERTOS || \
+    MG_ARCH == MG_ARCH_TIRTOS
+  (void) c;
+#else
+  int on = 1;
+#if !defined(SOL_TCP)
+#define SOL_TCP IPPROTO_TCP
+#endif
+  if (setsockopt(FD(c), SOL_TCP, TCP_NODELAY, (char *) &on, sizeof(on)) != 0)
+    (void) 0;
+  if (setsockopt(FD(c), SOL_SOCKET, SO_KEEPALIVE, (char *) &on, sizeof(on)) !=
+      0)
+    (void) 0;
+#endif
+}
+
+void mg_connect_resolved(struct mg_connection *c) {
+  // char buf[40];
+  int type = c->is_udp ? SOCK_DGRAM : SOCK_STREAM;
+  int rc, af = c->rem.is_ip6 ? AF_INET6 : AF_INET;
+  // mg_straddr(&c->rem, buf, sizeof(buf));
+  c->fd = S2PTR(socket(af, type, 0));
+  c->is_resolving = 0;
+  if (FD(c) == INVALID_SOCKET) {
+    mg_error(c, "socket(): %d", MG_SOCK_ERRNO);
+  } else if (c->is_udp) {
+    mg_call(c, MG_EV_RESOLVE, NULL);
+    mg_call(c, MG_EV_CONNECT, NULL);
+  } else {
+    union usa usa;
+    socklen_t slen = tousa(&c->rem, &usa);
+    mg_set_non_blocking_mode(FD(c));
+    setsockopts(c);
+    mg_call(c, MG_EV_RESOLVE, NULL);
+    if ((rc = connect(FD(c), &usa.sa, slen)) == 0) {
+      mg_call(c, MG_EV_CONNECT, NULL);
+    } else if (mg_sock_would_block()) {
+      MG_DEBUG(("%lu %p -> %x:%hu pend", c->id, c->fd, mg_ntohl(c->rem.ip),
+                mg_ntohs(c->rem.port)));
+      c->is_connecting = 1;
+    } else {
+      mg_error(c, "connect: %d", MG_SOCK_ERRNO);
+    }
+  }
+}
+
+static SOCKET raccept(SOCKET sock, union usa *usa, socklen_t len) {
+  SOCKET s = INVALID_SOCKET;
+  do {
+    memset(usa, 0, sizeof(*usa));
+    s = accept(sock, &usa->sa, &len);
+  } while (s == INVALID_SOCKET && errno == EINTR);
+  return s;
+}
+
+static void accept_conn(struct mg_mgr *mgr, struct mg_connection *lsn) {
+  struct mg_connection *c = NULL;
+  union usa usa;
+  socklen_t sa_len = sizeof(usa);
+  SOCKET fd = raccept(FD(lsn), &usa, sa_len);
+  if (fd == INVALID_SOCKET) {
+#if MG_ARCH == MG_ARCH_AZURERTOS
+    // AzureRTOS, in non-block socket mode can mark listening socket readable
+    // even it is not. See comment for 'select' func implementation in
+    // nx_bsd.c That's not an error, just should try later
+    if (MG_SOCK_ERRNO != EAGAIN)
+#endif
+      MG_ERROR(("%lu accept failed, errno %d", lsn->id, MG_SOCK_ERRNO));
+#if (MG_ARCH != MG_ARCH_WIN32) && (MG_ARCH != MG_ARCH_FREERTOS_TCP) && \
+    (MG_ARCH != MG_ARCH_TIRTOS) && !(MG_ENABLE_POLL)
+  } else if ((long) fd >= FD_SETSIZE) {
+    MG_ERROR(("%ld > %ld", (long) fd, (long) FD_SETSIZE));
+    closesocket(fd);
+#endif
+  } else if ((c = mg_alloc_conn(mgr)) == NULL) {
+    MG_ERROR(("%lu OOM", lsn->id));
+    closesocket(fd);
+  } else {
+    char buf[40];
+    tomgaddr(&usa, &c->rem, sa_len != sizeof(usa.sin));
+    mg_straddr(&c->rem, buf, sizeof(buf));
+    MG_DEBUG(("%lu accepted %s", c->id, buf));
+    LIST_ADD_HEAD(struct mg_connection, &mgr->conns, c);
+    c->fd = S2PTR(fd);
+    mg_set_non_blocking_mode(FD(c));
+    setsockopts(c);
+    c->is_accepted = 1;
+    c->is_hexdumping = lsn->is_hexdumping;
+    c->loc = lsn->loc;
+    c->pfn = lsn->pfn;
+    c->pfn_data = lsn->pfn_data;
+    c->fn = lsn->fn;
+    c->fn_data = lsn->fn_data;
+    mg_call(c, MG_EV_OPEN, NULL);
+    mg_call(c, MG_EV_ACCEPT, NULL);
+  }
+}
+
+static bool mg_socketpair(SOCKET sp[2], union usa usa[2], bool udp) {
+  SOCKET sock;
+  socklen_t n = sizeof(usa[0].sin);
+  bool success = false;
+
+  sock = sp[0] = sp[1] = INVALID_SOCKET;
+  (void) memset(&usa[0], 0, sizeof(usa[0]));
+  usa[0].sin.sin_family = AF_INET;
+  *(uint32_t *) &usa->sin.sin_addr = mg_htonl(0x7f000001U);  // 127.0.0.1
+  usa[1] = usa[0];
+
+  if (udp && (sp[0] = socket(AF_INET, SOCK_DGRAM, 0)) != INVALID_SOCKET &&
+      (sp[1] = socket(AF_INET, SOCK_DGRAM, 0)) != INVALID_SOCKET &&
+      bind(sp[0], &usa[0].sa, n) == 0 && bind(sp[1], &usa[1].sa, n) == 0 &&
+      getsockname(sp[0], &usa[0].sa, &n) == 0 &&
+      getsockname(sp[1], &usa[1].sa, &n) == 0 &&
+      connect(sp[0], &usa[1].sa, n) == 0 &&
+      connect(sp[1], &usa[0].sa, n) == 0) {
+    success = true;
+  } else if (!udp &&
+             (sock = socket(AF_INET, SOCK_STREAM, 0)) != INVALID_SOCKET &&
+             bind(sock, &usa[0].sa, n) == 0 &&
+             listen(sock, MG_SOCK_LISTEN_BACKLOG_SIZE) == 0 &&
+             getsockname(sock, &usa[0].sa, &n) == 0 &&
+             (sp[0] = socket(AF_INET, SOCK_STREAM, 0)) != INVALID_SOCKET &&
+             connect(sp[0], &usa[0].sa, n) == 0 &&
+             (sp[1] = raccept(sock, &usa[1], n)) != INVALID_SOCKET) {
+    success = true;
+  }
+  if (success) {
+    mg_set_non_blocking_mode(sp[1]);
+  } else {
+    if (sp[0] != INVALID_SOCKET) closesocket(sp[0]);
+    if (sp[1] != INVALID_SOCKET) closesocket(sp[1]);
+    sp[0] = sp[1] = INVALID_SOCKET;
+  }
+  if (sock != INVALID_SOCKET) closesocket(sock);
+  return success;
+}
+
+int mg_mkpipe(struct mg_mgr *mgr, mg_event_handler_t fn, void *fn_data,
+              bool udp) {
+  union usa usa[2];
+  SOCKET sp[2] = {INVALID_SOCKET, INVALID_SOCKET};
+  struct mg_connection *c = NULL;
+  if (!mg_socketpair(sp, usa, udp)) {
+    MG_ERROR(("Cannot create socket pair"));
+  } else if ((c = mg_wrapfd(mgr, (int) sp[1], fn, fn_data)) == NULL) {
+    closesocket(sp[0]);
+    closesocket(sp[1]);
+    sp[0] = sp[1] = INVALID_SOCKET;
+  } else {
+    tomgaddr(&usa[0], &c->rem, false);
+    MG_DEBUG(("%lu %p pipe %lu", c->id, c->fd, (unsigned long) sp[0]));
+  }
+  return (int) sp[0];
+}
+
+static bool can_read(const struct mg_connection *c) {
+  return c->is_full == false;
+}
+
+static bool can_write(const struct mg_connection *c) {
+  return c->is_connecting || (c->send.len > 0 && c->is_tls_hs == 0);
+}
+
+static bool skip_iotest(const struct mg_connection *c) {
+  return (c->is_closing || c->is_resolving || FD(c) == INVALID_SOCKET) ||
+         (can_read(c) == false && can_write(c) == false);
+}
+
+static void mg_iotest(struct mg_mgr *mgr, int ms) {
+#if MG_ARCH == MG_ARCH_FREERTOS_TCP
+  struct mg_connection *c;
+  for (c = mgr->conns; c != NULL; c = c->next) {
+    c->is_readable = c->is_writable = 0;
+    if (skip_iotest(c)) continue;
+    if (can_read(c))
+      FreeRTOS_FD_SET(c->fd, mgr->ss, eSELECT_READ | eSELECT_EXCEPT);
+    if (can_write(c)) FreeRTOS_FD_SET(c->fd, mgr->ss, eSELECT_WRITE);
+  }
+  FreeRTOS_select(mgr->ss, pdMS_TO_TICKS(ms));
+  for (c = mgr->conns; c != NULL; c = c->next) {
+    EventBits_t bits = FreeRTOS_FD_ISSET(c->fd, mgr->ss);
+    c->is_readable = bits & (eSELECT_READ | eSELECT_EXCEPT) ? 1 : 0;
+    c->is_writable = bits & eSELECT_WRITE ? 1 : 0;
+    FreeRTOS_FD_CLR(c->fd, mgr->ss,
+                    eSELECT_READ | eSELECT_EXCEPT | eSELECT_WRITE);
+  }
+#elif MG_ENABLE_POLL
+  nfds_t n = 0;
+  for (struct mg_connection *c = mgr->conns; c != NULL; c = c->next) n++;
+  struct pollfd *fds = (struct pollfd *) alloca(n * sizeof(fds[0]));
+  memset(fds, 0, n * sizeof(fds[0]));
+  n = 0;
+  for (struct mg_connection *c = mgr->conns; c != NULL; c = c->next) {
+    c->is_readable = c->is_writable = 0;
+    if (skip_iotest(c)) {
+      // Socket not valid, ignore
+    } else if (mg_tls_pending(c) > 0) {
+      ms = 1;  // Don't wait if TLS is ready
+    } else {
+      fds[n].fd = FD(c);
+      if (can_read(c)) fds[n].events |= POLLIN;
+      if (can_write(c)) fds[n].events |= POLLOUT;
+      n++;
+    }
+  }
+
+  // MG_INFO(("poll n=%d ms=%d", (int) n, ms));
+  if (poll(fds, n, ms) < 0) {
+#if MG_ARCH == MG_ARCH_WIN32
+    if (n == 0) Sleep(ms);  // On Windows, poll fails if no sockets
+#endif
+    memset(fds, 0, n * sizeof(fds[0]));
+  }
+  n = 0;
+  for (struct mg_connection *c = mgr->conns; c != NULL; c = c->next) {
+    if (skip_iotest(c)) {
+      // Socket not valid, ignore
+    } else if (mg_tls_pending(c) > 0) {
+      c->is_readable = 1;
+    } else {
+      if (fds[n].revents & POLLERR) {
+        mg_error(c, "socket error");
+      } else {
+        c->is_readable =
+            (unsigned) (fds[n].revents & (POLLIN | POLLHUP) ? 1 : 0);
+        c->is_writable = (unsigned) (fds[n].revents & POLLOUT ? 1 : 0);
+      }
+      n++;
+    }
+  }
+#else
+  struct timeval tv = {ms / 1000, (ms % 1000) * 1000}, tv_zero = {0, 0};
+  struct mg_connection *c;
+  fd_set rset, wset, eset;
+  SOCKET maxfd = 0;
+  int rc;
+
+  FD_ZERO(&rset);
+  FD_ZERO(&wset);
+  FD_ZERO(&eset);
+  for (c = mgr->conns; c != NULL; c = c->next) {
+    c->is_readable = c->is_writable = 0;
+    if (skip_iotest(c)) continue;
+    FD_SET(FD(c), &eset);
+    if (can_read(c)) FD_SET(FD(c), &rset);
+    if (can_write(c)) FD_SET(FD(c), &wset);
+    if (mg_tls_pending(c) > 0) tv = tv_zero;
+    if (FD(c) > maxfd) maxfd = FD(c);
+  }
+
+  if ((rc = select((int) maxfd + 1, &rset, &wset, &eset, &tv)) < 0) {
+#if MG_ARCH == MG_ARCH_WIN32
+    if (maxfd == 0) Sleep(ms);  // On Windows, select fails if no sockets
+#else
+    MG_ERROR(("select: %d %d", rc, MG_SOCK_ERRNO));
+#endif
+    FD_ZERO(&rset);
+    FD_ZERO(&wset);
+    FD_ZERO(&eset);
+  }
+
+  for (c = mgr->conns; c != NULL; c = c->next) {
+    if (FD(c) != INVALID_SOCKET && FD_ISSET(FD(c), &eset)) {
+      mg_error(c, "socket error");
+    } else {
+      c->is_readable = FD(c) != INVALID_SOCKET && FD_ISSET(FD(c), &rset);
+      c->is_writable = FD(c) != INVALID_SOCKET && FD_ISSET(FD(c), &wset);
+      if (mg_tls_pending(c) > 0) c->is_readable = 1;
+    }
+  }
+#endif
+}
+
+void mg_mgr_poll(struct mg_mgr *mgr, int ms) {
+  struct mg_connection *c, *tmp;
+  uint64_t now;
+
+  mg_iotest(mgr, ms);
+  now = mg_millis();
+  mg_timer_poll(&mgr->timers, now);
+
+  for (c = mgr->conns; c != NULL; c = tmp) {
+    tmp = c->next;
+    mg_call(c, MG_EV_POLL, &now);
+    MG_VERBOSE(("%lu %c%c %c%c%c%c%c", c->id, c->is_readable ? 'r' : '-',
+                c->is_writable ? 'w' : '-', c->is_tls ? 'T' : 't',
+                c->is_connecting ? 'C' : 'c', c->is_tls_hs ? 'H' : 'h',
+                c->is_resolving ? 'R' : 'r', c->is_closing ? 'C' : 'c'));
+    if (c->is_resolving || c->is_closing) {
+      // Do nothing
+    } else if (c->is_listening && c->is_udp == 0) {
+      if (c->is_readable) accept_conn(mgr, c);
+    } else if (c->is_connecting) {
+      if (c->is_readable || c->is_writable) connect_conn(c);
+    } else if (c->is_tls_hs) {
+      if ((c->is_readable || c->is_writable)) mg_tls_handshake(c);
+    } else {
+      if (c->is_readable) read_conn(c);
+      if (c->is_writable) write_conn(c);
+    }
+
+    if (c->is_draining && c->send.len == 0) c->is_closing = 1;
+    if (c->is_closing) close_conn(c);
+  }
+}
+#endif
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/ssi.c"
+#endif
+
+
+
+
+#ifndef MG_MAX_SSI_DEPTH
+#define MG_MAX_SSI_DEPTH 5
+#endif
+
+#ifndef MG_SSI_BUFSIZ
+#define MG_SSI_BUFSIZ 1024
+#endif
+
+#if MG_ENABLE_SSI
+static char *mg_ssi(const char *path, const char *root, int depth) {
+  struct mg_iobuf b = {NULL, 0, 0};
+  FILE *fp = fopen(path, "rb");
+  if (fp != NULL) {
+    char buf[MG_SSI_BUFSIZ], arg[sizeof(buf)];
+    int ch, intag = 0;
+    size_t len = 0, align = MG_IO_SIZE;
+    buf[0] = arg[0] = '\0';
+    while ((ch = fgetc(fp)) != EOF) {
+      if (intag && ch == '>' && buf[len - 1] == '-' && buf[len - 2] == '-') {
+        buf[len++] = (char) (ch & 0xff);
+        buf[len] = '\0';
+        if (sscanf(buf, "<!--#include file=\"%[^\"]", arg)) {
+          char tmp[MG_PATH_MAX + MG_SSI_BUFSIZ + 10],
+              *p = (char *) path + strlen(path), *data;
+          while (p > path && p[-1] != MG_DIRSEP && p[-1] != '/') p--;
+          mg_snprintf(tmp, sizeof(tmp), "%.*s%s", (int) (p - path), path, arg);
+          if (depth < MG_MAX_SSI_DEPTH &&
+              (data = mg_ssi(tmp, root, depth + 1)) != NULL) {
+            mg_iobuf_add(&b, b.len, data, strlen(data), align);
+            free(data);
+          } else {
+            MG_ERROR(("%s: file=%s error or too deep", path, arg));
+          }
+        } else if (sscanf(buf, "<!--#include virtual=\"%[^\"]", arg)) {
+          char tmp[MG_PATH_MAX + MG_SSI_BUFSIZ + 10], *data;
+          mg_snprintf(tmp, sizeof(tmp), "%s%s", root, arg);
+          if (depth < MG_MAX_SSI_DEPTH &&
+              (data = mg_ssi(tmp, root, depth + 1)) != NULL) {
+            mg_iobuf_add(&b, b.len, data, strlen(data), align);
+            free(data);
+          } else {
+            MG_ERROR(("%s: virtual=%s error or too deep", path, arg));
+          }
+        } else {
+          // Unknown SSI tag
+          MG_ERROR(("Unknown SSI tag: %.*s", (int) len, buf));
+          mg_iobuf_add(&b, b.len, buf, len, align);
+        }
+        intag = 0;
+        len = 0;
+      } else if (ch == '<') {
+        intag = 1;
+        if (len > 0) mg_iobuf_add(&b, b.len, buf, len, align);
+        len = 0;
+        buf[len++] = (char) (ch & 0xff);
+      } else if (intag) {
+        if (len == 5 && strncmp(buf, "<!--#", 5) != 0) {
+          intag = 0;
+        } else if (len >= sizeof(buf) - 2) {
+          MG_ERROR(("%s: SSI tag is too large", path));
+          len = 0;
+        }
+        buf[len++] = (char) (ch & 0xff);
+      } else {
+        buf[len++] = (char) (ch & 0xff);
+        if (len >= sizeof(buf)) {
+          mg_iobuf_add(&b, b.len, buf, len, align);
+          len = 0;
+        }
+      }
+    }
+    if (len > 0) mg_iobuf_add(&b, b.len, buf, len, align);
+    if (b.len > 0) mg_iobuf_add(&b, b.len, "", 1, align);  // nul-terminate
+    fclose(fp);
+  }
+  (void) depth;
+  (void) root;
+  return (char *) b.buf;
+}
+
+void mg_http_serve_ssi(struct mg_connection *c, const char *root,
+                       const char *fullpath) {
+  const char *headers = "Content-Type: text/html; charset=utf-8\r\n";
+  char *data = mg_ssi(fullpath, root, 0);
+  mg_http_reply(c, 200, headers, "%s", data == NULL ? "" : data);
+  free(data);
+}
+#else
+void mg_http_serve_ssi(struct mg_connection *c, const char *root,
+                       const char *fullpath) {
+  mg_http_reply(c, 501, NULL, "SSI not enabled");
+  (void) root, (void) fullpath;
+}
+#endif
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/str.c"
+#endif
+
+
+struct mg_str mg_str_s(const char *s) {
+  struct mg_str str = {s, s == NULL ? 0 : strlen(s)};
+  return str;
+}
+
+struct mg_str mg_str_n(const char *s, size_t n) {
+  struct mg_str str = {s, n};
+  return str;
+}
+
+int mg_lower(const char *s) {
+  int c = *s;
+  if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
+  return c;
+}
+
+int mg_ncasecmp(const char *s1, const char *s2, size_t len) {
+  int diff = 0;
+  if (len > 0) do {
+      diff = mg_lower(s1++) - mg_lower(s2++);
+    } while (diff == 0 && s1[-1] != '\0' && --len > 0);
+  return diff;
+}
+
+int mg_casecmp(const char *s1, const char *s2) {
+  return mg_ncasecmp(s1, s2, (size_t) ~0);
+}
+
+int mg_vcmp(const struct mg_str *s1, const char *s2) {
+  size_t n2 = strlen(s2), n1 = s1->len;
+  int r = strncmp(s1->ptr, s2, (n1 < n2) ? n1 : n2);
+  if (r == 0) return (int) (n1 - n2);
+  return r;
+}
+
+int mg_vcasecmp(const struct mg_str *str1, const char *str2) {
+  size_t n2 = strlen(str2), n1 = str1->len;
+  int r = mg_ncasecmp(str1->ptr, str2, (n1 < n2) ? n1 : n2);
+  if (r == 0) return (int) (n1 - n2);
+  return r;
+}
+
+struct mg_str mg_strdup(const struct mg_str s) {
+  struct mg_str r = {NULL, 0};
+  if (s.len > 0 && s.ptr != NULL) {
+    char *sc = (char *) calloc(1, s.len + 1);
+    if (sc != NULL) {
+      memcpy(sc, s.ptr, s.len);
+      sc[s.len] = '\0';
+      r.ptr = sc;
+      r.len = s.len;
+    }
+  }
+  return r;
+}
+
+int mg_strcmp(const struct mg_str str1, const struct mg_str str2) {
+  size_t i = 0;
+  while (i < str1.len && i < str2.len) {
+    int c1 = str1.ptr[i];
+    int c2 = str2.ptr[i];
+    if (c1 < c2) return -1;
+    if (c1 > c2) return 1;
+    i++;
+  }
+  if (i < str1.len) return 1;
+  if (i < str2.len) return -1;
+  return 0;
+}
+
+const char *mg_strstr(const struct mg_str haystack,
+                      const struct mg_str needle) {
+  size_t i;
+  if (needle.len > haystack.len) return NULL;
+  for (i = 0; i <= haystack.len - needle.len; i++) {
+    if (memcmp(haystack.ptr + i, needle.ptr, needle.len) == 0) {
+      return haystack.ptr + i;
+    }
+  }
+  return NULL;
+}
+
+static bool is_space(int c) {
+  return c == ' ' || c == '\r' || c == '\n' || c == '\t';
+}
+
+struct mg_str mg_strstrip(struct mg_str s) {
+  while (s.len > 0 && is_space((int) *s.ptr)) s.ptr++, s.len--;
+  while (s.len > 0 && is_space((int) *(s.ptr + s.len - 1))) s.len--;
+  return s;
+}
+
+bool mg_match(struct mg_str s, struct mg_str p, struct mg_str *caps) {
+  size_t i = 0, j = 0, ni = 0, nj = 0;
+  if (caps) caps->ptr = NULL, caps->len = 0;
+  while (i < p.len || j < s.len) {
+    if (i < p.len && j < s.len && (p.ptr[i] == '?' || s.ptr[j] == p.ptr[i])) {
+      if (caps == NULL) {
+      } else if (p.ptr[i] == '?') {
+        caps->ptr = &s.ptr[j], caps->len = 1;     // Finalize `?` cap
+        caps++, caps->ptr = NULL, caps->len = 0;  // Init next cap
+      } else if (caps->ptr != NULL && caps->len == 0) {
+        caps->len = (size_t) (&s.ptr[j] - caps->ptr);  // Finalize current cap
+        caps++, caps->len = 0, caps->ptr = NULL;       // Init next cap
+      }
+      i++, j++;
+    } else if (i < p.len && (p.ptr[i] == '*' || p.ptr[i] == '#')) {
+      if (caps && !caps->ptr) caps->len = 0, caps->ptr = &s.ptr[j];  // Init cap
+      ni = i++, nj = j + 1;
+    } else if (nj > 0 && nj <= s.len && (p.ptr[ni] == '#' || s.ptr[j] != '/')) {
+      i = ni, j = nj;
+      if (caps && caps->ptr == NULL && caps->len == 0) {
+        caps--, caps->len = 0;  // Restart previous cap
+      }
+    } else {
+      return false;
+    }
+  }
+  if (caps && caps->ptr && caps->len == 0) {
+    caps->len = (size_t) (&s.ptr[j] - caps->ptr);
+  }
+  return true;
+}
+
+bool mg_globmatch(const char *s1, size_t n1, const char *s2, size_t n2) {
+  return mg_match(mg_str_n(s2, n2), mg_str_n(s1, n1), NULL);
+}
+
+static size_t mg_nce(const char *s, size_t n, size_t ofs, size_t *koff,
+                     size_t *klen, size_t *voff, size_t *vlen, char delim) {
+  size_t kvlen, kl;
+  for (kvlen = 0; ofs + kvlen < n && s[ofs + kvlen] != delim;) kvlen++;
+  for (kl = 0; kl < kvlen && s[ofs + kl] != '=';) kl++;
+  if (koff != NULL) *koff = ofs;
+  if (klen != NULL) *klen = kl;
+  if (voff != NULL) *voff = kl < kvlen ? ofs + kl + 1 : 0;
+  if (vlen != NULL) *vlen = kl < kvlen ? kvlen - kl - 1 : 0;
+  ofs += kvlen + 1;
+  return ofs > n ? n : ofs;
+}
+
+bool mg_split(struct mg_str *s, struct mg_str *k, struct mg_str *v, char sep) {
+  size_t koff = 0, klen = 0, voff = 0, vlen = 0, off = 0;
+  if (s->ptr == NULL || s->len == 0) return 0;
+  off = mg_nce(s->ptr, s->len, 0, &koff, &klen, &voff, &vlen, sep);
+  if (k != NULL) *k = mg_str_n(s->ptr + koff, klen);
+  if (v != NULL) *v = mg_str_n(s->ptr + voff, vlen);
+  *s = mg_str_n(s->ptr + off, s->len - off);
+  return off > 0;
+}
+
+bool mg_commalist(struct mg_str *s, struct mg_str *k, struct mg_str *v) {
+  return mg_split(s, k, v, ',');
+}
+
+size_t mg_snprintf(char *buf, size_t len, const char *fmt, ...) {
+  va_list ap;
+  size_t n;
+  va_start(ap, fmt);
+  n = mg_vsnprintf(buf, len, fmt, &ap);
+  va_end(ap);
+  return n;
+}
+
+char *mg_hex(const void *buf, size_t len, char *to) {
+  const unsigned char *p = (const unsigned char *) buf;
+  const char *hex = "0123456789abcdef";
+  size_t i = 0;
+  for (; len--; p++) {
+    to[i++] = hex[p[0] >> 4];
+    to[i++] = hex[p[0] & 0x0f];
+  }
+  to[i] = '\0';
+  return to;
+}
+
+static unsigned char mg_unhex_nimble(unsigned char c) {
+  return (c >= '0' && c <= '9')   ? (unsigned char) (c - '0')
+         : (c >= 'A' && c <= 'F') ? (unsigned char) (c - '7')
+                                  : (unsigned char) (c - 'W');
+}
+
+unsigned long mg_unhexn(const char *s, size_t len) {
+  unsigned long i = 0, v = 0;
+  for (i = 0; i < len; i++) v <<= 4, v |= mg_unhex_nimble(((uint8_t *) s)[i]);
+  return v;
+}
+
+void mg_unhex(const char *buf, size_t len, unsigned char *to) {
+  size_t i;
+  for (i = 0; i < len; i += 2) {
+    to[i >> 1] = (unsigned char) mg_unhexn(&buf[i], 2);
+  }
+}
+
+uint64_t mg_tou64(struct mg_str str) {
+  uint64_t result = 0;
+  size_t i = 0;
+  while (i < str.len && (str.ptr[i] == ' ' || str.ptr[i] == '\t')) i++;
+  while (i < str.len && str.ptr[i] >= '0' && str.ptr[i] <= '9') {
+    result *= 10;
+    result += (unsigned) (str.ptr[i] - '0');
+    i++;
+  }
+  return result;
+}
+
+int64_t mg_to64(struct mg_str str) {
+  int64_t result = 0, neg = 1, max = 922337203685477570 /* INT64_MAX/10-10 */;
+  size_t i = 0;
+  while (i < str.len && (str.ptr[i] == ' ' || str.ptr[i] == '\t')) i++;
+  if (i < str.len && str.ptr[i] == '-') neg = -1, i++;
+  while (i < str.len && str.ptr[i] >= '0' && str.ptr[i] <= '9') {
+    if (result > max) return 0;
+    result *= 10;
+    result += (str.ptr[i] - '0');
+    i++;
+  }
+  return result * neg;
+}
+
+char *mg_remove_double_dots(char *s) {
+  char *saved = s, *p = s;
+  while (*s != '\0') {
+    *p++ = *s++;
+    if (s[-1] == '/' || s[-1] == '\\') {
+      while (s[0] != '\0') {
+        if (s[0] == '/' || s[0] == '\\') {
+          s++;
+        } else if (s[0] == '.' && s[1] == '.' &&
+                   (s[2] == '/' || s[2] == '\\')) {
+          s += 2;
+        } else {
+          break;
+        }
+      }
+    }
+  }
+  *p = '\0';
+  return saved;
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/timer.c"
+#endif
+// Copyright (c) Cesanta Software Limited
+// All rights reserved
+
+
+
+
+#define MG_TIMER_CALLED 4
+
+void mg_timer_init(struct mg_timer **head, struct mg_timer *t, uint64_t ms,
+                   unsigned flags, void (*fn)(void *), void *arg) {
+  struct mg_timer tmp = {0U, ms, 0U, 0U, flags, fn, arg, *head};
+  *t = tmp;
+  *head = t;
+}
+
+void mg_timer_free(struct mg_timer **head, struct mg_timer *t) {
+  while (*head && *head != t) head = &(*head)->next;
+  if (*head) *head = t->next;
+}
+
+void mg_timer_poll(struct mg_timer **head, uint64_t now_ms) {
+  // If time goes back (wrapped around), reset timers
+  struct mg_timer *t, *tmp;
+  for (t = *head; t != NULL; t = tmp) {
+    tmp = t->next;
+    if (t->prev_ms > now_ms) t->expire = 0;  // Handle time wrap
+    t->prev_ms = now_ms;
+    if (t->expire == 0 && (t->flags & MG_TIMER_RUN_NOW) &&
+        !(t->flags & MG_TIMER_CALLED)) {
+      // Handle MG_TIMER_NOW only once
+    } else if (t->expire == 0) {
+      t->expire = now_ms + t->period_ms;
+    }
+    if (t->expire > now_ms) continue;
+    if ((t->flags & MG_TIMER_REPEAT) || !(t->flags & MG_TIMER_CALLED)) {
+      t->fn(t->arg);
+    }
+    t->flags |= MG_TIMER_CALLED;
+    // Try to tick timers with the given period as accurate as possible,
+    // even if this polling function is called with some random period.
+    t->expire = now_ms - t->expire > t->period_ms ? now_ms + t->period_ms
+                                                  : t->expire + t->period_ms;
+  }
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/tls_dummy.c"
+#endif
+
+
+#if !MG_ENABLE_MBEDTLS && !MG_ENABLE_OPENSSL && !MG_ENABLE_CUSTOM_TLS
+void mg_tls_init(struct mg_connection *c, const struct mg_tls_opts *opts) {
+  (void) opts;
+  mg_error(c, "TLS is not enabled");
+}
+void mg_tls_handshake(struct mg_connection *c) {
+  (void) c;
+}
+void mg_tls_free(struct mg_connection *c) {
+  (void) c;
+}
+long mg_tls_recv(struct mg_connection *c, void *buf, size_t len) {
+  return c == NULL || buf == NULL || len == 0 ? 0 : -1;
+}
+long mg_tls_send(struct mg_connection *c, const void *buf, size_t len) {
+  return c == NULL || buf == NULL || len == 0 ? 0 : -1;
+}
+size_t mg_tls_pending(struct mg_connection *c) {
+  (void) c;
+  return 0;
+}
+#endif
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/tls_mbed.c"
+#endif
+
+
+
+#if MG_ENABLE_MBEDTLS
+
+#if defined(MBEDTLS_VERSION_NUMBER) && MBEDTLS_VERSION_NUMBER >= 0x03000000
+#define MGRNG , rng_get, NULL
+#else
+#define MGRNG
+#endif
+
+void mg_tls_free(struct mg_connection *c) {
+  struct mg_tls *tls = (struct mg_tls *) c->tls;
+  if (tls != NULL) {
+    free(tls->cafile);
+    mbedtls_ssl_free(&tls->ssl);
+    mbedtls_pk_free(&tls->pk);
+    mbedtls_x509_crt_free(&tls->ca);
+    mbedtls_x509_crt_free(&tls->cert);
+    mbedtls_ssl_config_free(&tls->conf);
+    free(tls);
+    c->tls = NULL;
+  }
+}
+
+bool mg_sock_would_block(void);
+bool mg_sock_conn_reset(void);
+
+static int mg_net_send(void *ctx, const unsigned char *buf, size_t len) {
+  struct mg_connection *c = (struct mg_connection *) ctx;
+  int fd = (int) (size_t) c->fd;
+  int n = (int) send(fd, buf, len, 0);
+  MG_VERBOSE(("%lu n=%d, errno=%d", c->id, n, errno));
+  if (n < 0) {
+    if (mg_sock_would_block()) return MBEDTLS_ERR_SSL_WANT_WRITE;
+    if (mg_sock_conn_reset()) return MBEDTLS_ERR_NET_CONN_RESET;
+    return MBEDTLS_ERR_NET_SEND_FAILED;
+  }
+  return n;
+}
+
+static int mg_net_recv(void *ctx, unsigned char *buf, size_t len) {
+  struct mg_connection *c = (struct mg_connection *) ctx;
+  int n, fd = (int) (size_t) c->fd;
+  n = (int) recv(fd, buf, len, 0);
+  MG_VERBOSE(("%lu n=%d, errno=%d", c->id, n, errno));
+  if (n < 0) {
+    if (mg_sock_would_block()) return MBEDTLS_ERR_SSL_WANT_READ;
+    if (mg_sock_conn_reset()) return MBEDTLS_ERR_NET_CONN_RESET;
+    return MBEDTLS_ERR_NET_RECV_FAILED;
+  }
+  return n;
+}
+
+void mg_tls_handshake(struct mg_connection *c) {
+  struct mg_tls *tls = (struct mg_tls *) c->tls;
+  int rc;
+  mbedtls_ssl_set_bio(&tls->ssl, c, mg_net_send, mg_net_recv, 0);
+  rc = mbedtls_ssl_handshake(&tls->ssl);
+  if (rc == 0) {  // Success
+    MG_DEBUG(("%lu success", c->id));
+    c->is_tls_hs = 0;
+  } else if (rc == MBEDTLS_ERR_SSL_WANT_READ ||
+             rc == MBEDTLS_ERR_SSL_WANT_WRITE) {  // Still pending
+    MG_VERBOSE(("%lu pending, %d%d %d (-%#x)", c->id, c->is_connecting,
+                c->is_tls_hs, rc, -rc));
+  } else {
+    mg_error(c, "TLS handshake: -%#x", -rc);  // Error
+  }
+}
+
+static int mbed_rng(void *ctx, unsigned char *buf, size_t len) {
+  mg_random(buf, len);
+  (void) ctx;
+  return 0;
+}
+
+static void debug_cb(void *c, int lev, const char *s, int n, const char *s2) {
+  n = (int) strlen(s2) - 1;
+  MG_VERBOSE(("%lu %d %.*s", ((struct mg_connection *) c)->id, lev, n, s2));
+  (void) s;
+}
+
+#if defined(MBEDTLS_VERSION_NUMBER) && MBEDTLS_VERSION_NUMBER >= 0x03000000
+static int rng_get(void *p_rng, unsigned char *buf, size_t len) {
+  (void) p_rng;
+  mg_random(buf, len);
+  return 0;
+}
+#endif
+
+static struct mg_str mg_loadfile(struct mg_fs *fs, const char *path) {
+  size_t n = 0;
+  if (path[0] == '-') return mg_str(path);
+  char *p = mg_file_read(fs, path, &n);
+  return mg_str_n(p, n);
+}
+
+void mg_tls_init(struct mg_connection *c, const struct mg_tls_opts *opts) {
+  struct mg_fs *fs = opts->fs == NULL ? &mg_fs_posix : opts->fs;
+  struct mg_tls *tls = (struct mg_tls *) calloc(1, sizeof(*tls));
+  int rc = 0;
+  c->tls = tls;
+  if (c->tls == NULL) {
+    mg_error(c, "TLS OOM");
+    goto fail;
+  }
+  MG_DEBUG(("%lu Setting TLS", c->id));
+  mbedtls_ssl_init(&tls->ssl);
+  mbedtls_ssl_config_init(&tls->conf);
+  mbedtls_x509_crt_init(&tls->ca);
+  mbedtls_x509_crt_init(&tls->cert);
+  mbedtls_pk_init(&tls->pk);
+  mbedtls_ssl_conf_dbg(&tls->conf, debug_cb, c);
+#if defined(MG_MBEDTLS_DEBUG_LEVEL)
+  mbedtls_debug_set_threshold(MG_MBEDTLS_DEBUG_LEVEL);
+#endif
+  if ((rc = mbedtls_ssl_config_defaults(
+           &tls->conf,
+           c->is_client ? MBEDTLS_SSL_IS_CLIENT : MBEDTLS_SSL_IS_SERVER,
+           MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT)) != 0) {
+    mg_error(c, "tls defaults %#x", -rc);
+    goto fail;
+  }
+  mbedtls_ssl_conf_rng(&tls->conf, mbed_rng, c);
+  if (opts->ca == NULL || strcmp(opts->ca, "*") == 0) {
+    mbedtls_ssl_conf_authmode(&tls->conf, MBEDTLS_SSL_VERIFY_NONE);
+  } else if (opts->ca != NULL && opts->ca[0] != '\0') {
+#if defined(MBEDTLS_X509_CA_CHAIN_ON_DISK)
+    tls->cafile = strdup(opts->ca);
+    rc = mbedtls_ssl_conf_ca_chain_file(&tls->conf, tls->cafile, NULL);
+    if (rc != 0) {
+      mg_error(c, "parse on-disk chain(%s) err %#x", tls->cafile, -rc);
+      goto fail;
+    }
+#else
+    struct mg_str s = mg_loadfile(fs, opts->ca);
+    rc = mbedtls_x509_crt_parse(&tls->ca, (uint8_t *) s.ptr, s.len + 1);
+    if (opts->ca[0] != '-') free((char *) s.ptr);
+    if (rc != 0) {
+      mg_error(c, "parse(%s) err %#x", opts->ca, -rc);
+      goto fail;
+    }
+    mbedtls_ssl_conf_ca_chain(&tls->conf, &tls->ca, NULL);
+#endif
+    if (opts->srvname.len > 0) {
+      char mem[128], *buf = mem;
+      mg_asprintf(&buf, sizeof(mem), "%.*s", (int) opts->srvname.len,
+                  opts->srvname.ptr);
+      mbedtls_ssl_set_hostname(&tls->ssl, buf);
+      if (buf != mem) free(buf);
+    }
+    mbedtls_ssl_conf_authmode(&tls->conf, MBEDTLS_SSL_VERIFY_REQUIRED);
+  }
+  if (opts->cert != NULL && opts->cert[0] != '\0') {
+    struct mg_str s = mg_loadfile(fs, opts->cert);
+    const char *key = opts->certkey == NULL ? opts->cert : opts->certkey;
+    rc = mbedtls_x509_crt_parse(&tls->cert, (uint8_t *) s.ptr, s.len + 1);
+    if (opts->cert[0] != '-') free((char *) s.ptr);
+    if (rc != 0) {
+      mg_error(c, "parse(%s) err %#x", opts->cert, -rc);
+      goto fail;
+    }
+    s = mg_loadfile(fs, key);
+    rc = mbedtls_pk_parse_key(&tls->pk, (uint8_t *) s.ptr, s.len + 1, NULL,
+                              0 MGRNG);
+    if (key[0] != '-') free((char *) s.ptr);
+    if (rc != 0) {
+      mg_error(c, "tls key(%s) %#x", key, -rc);
+      goto fail;
+    }
+    rc = mbedtls_ssl_conf_own_cert(&tls->conf, &tls->cert, &tls->pk);
+    if (rc != 0) {
+      mg_error(c, "own cert %#x", -rc);
+      goto fail;
+    }
+  }
+  if ((rc = mbedtls_ssl_setup(&tls->ssl, &tls->conf)) != 0) {
+    mg_error(c, "setup err %#x", -rc);
+    goto fail;
+  }
+  c->tls = tls;
+  c->is_tls = 1;
+  c->is_tls_hs = 1;
+  if (c->is_client && c->is_resolving == 0 && c->is_connecting == 0) {
+    mg_tls_handshake(c);
+  }
+  return;
+fail:
+  mg_tls_free(c);
+}
+
+size_t mg_tls_pending(struct mg_connection *c) {
+  struct mg_tls *tls = (struct mg_tls *) c->tls;
+  return tls == NULL ? 0 : mbedtls_ssl_get_bytes_avail(&tls->ssl);
+}
+
+long mg_tls_recv(struct mg_connection *c, void *buf, size_t len) {
+  struct mg_tls *tls = (struct mg_tls *) c->tls;
+  long n = mbedtls_ssl_read(&tls->ssl, (unsigned char *) buf, len);
+  return n == 0 ? -1 : n == MBEDTLS_ERR_SSL_WANT_READ ? 0 : n;
+}
+
+long mg_tls_send(struct mg_connection *c, const void *buf, size_t len) {
+  struct mg_tls *tls = (struct mg_tls *) c->tls;
+  long n = mbedtls_ssl_write(&tls->ssl, (unsigned char *) buf, len);
+  return n == 0 ? -1 : n == MBEDTLS_ERR_SSL_WANT_WRITE ? 0 : n;
+}
+#endif
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/tls_openssl.c"
+#endif
+
+
+#if MG_ENABLE_OPENSSL
+static int mg_tls_err(struct mg_tls *tls, int res) {
+  int err = SSL_get_error(tls->ssl, res);
+  // We've just fetched the last error from the queue.
+  // Now we need to clear the error queue. If we do not, then the following
+  // can happen (actually reported):
+  //  - A new connection is accept()-ed with cert error (e.g. self-signed cert)
+  //  - Since all accept()-ed connections share listener's context,
+  //  - *ALL* SSL accepted connection report read error on the next poll cycle.
+  //    Thus a single errored connection can close all the rest, unrelated ones.
+  // Clearing the error keeps the shared SSL_CTX in an OK state.
+
+  if (err != 0) ERR_print_errors_fp(stderr);
+  ERR_clear_error();
+  if (err == SSL_ERROR_WANT_READ) return 0;
+  if (err == SSL_ERROR_WANT_WRITE) return 0;
+  return err;
+}
+
+void mg_tls_init(struct mg_connection *c, const struct mg_tls_opts *opts) {
+  struct mg_tls *tls = (struct mg_tls *) calloc(1, sizeof(*tls));
+  const char *id = "mongoose";
+  static unsigned char s_initialised = 0;
+  int rc;
+
+  if (tls == NULL) {
+    mg_error(c, "TLS OOM");
+    goto fail;
+  }
+
+  if (!s_initialised) {
+    SSL_library_init();
+    s_initialised++;
+  }
+  MG_DEBUG(("%lu Setting TLS, CA: %s, cert: %s, key: %s", c->id,
+            opts->ca == NULL ? "null" : opts->ca,
+            opts->cert == NULL ? "null" : opts->cert,
+            opts->certkey == NULL ? "null" : opts->certkey));
+  tls->ctx = c->is_client ? SSL_CTX_new(SSLv23_client_method())
+                          : SSL_CTX_new(SSLv23_server_method());
+  if ((tls->ssl = SSL_new(tls->ctx)) == NULL) {
+    mg_error(c, "SSL_new");
+    goto fail;
+  }
+  SSL_set_session_id_context(tls->ssl, (const uint8_t *) id,
+                             (unsigned) strlen(id));
+  // Disable deprecated protocols
+  SSL_set_options(tls->ssl, SSL_OP_NO_SSLv2);
+  SSL_set_options(tls->ssl, SSL_OP_NO_SSLv3);
+  SSL_set_options(tls->ssl, SSL_OP_NO_TLSv1);
+  SSL_set_options(tls->ssl, SSL_OP_NO_TLSv1_1);
+#ifdef MG_ENABLE_OPENSSL_NO_COMPRESSION
+  SSL_set_options(tls->ssl, SSL_OP_NO_COMPRESSION);
+#endif
+#ifdef MG_ENABLE_OPENSSL_CIPHER_SERVER_PREFERENCE
+  SSL_set_options(tls->ssl, SSL_OP_CIPHER_SERVER_PREFERENCE);
+#endif
+
+  if (opts->ca != NULL && opts->ca[0] != '\0') {
+    SSL_set_verify(tls->ssl, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
+                   NULL);
+    if ((rc = SSL_CTX_load_verify_locations(tls->ctx, opts->ca, NULL)) != 1) {
+      mg_error(c, "load('%s') %d err %d", opts->ca, rc, mg_tls_err(tls, rc));
+      goto fail;
+    }
+  }
+  if (opts->cert != NULL && opts->cert[0] != '\0') {
+    const char *key = opts->certkey;
+    if (key == NULL) key = opts->cert;
+    if ((rc = SSL_use_certificate_file(tls->ssl, opts->cert, 1)) != 1) {
+      mg_error(c, "Invalid SSL cert, err %d", mg_tls_err(tls, rc));
+      goto fail;
+    } else if ((rc = SSL_use_PrivateKey_file(tls->ssl, key, 1)) != 1) {
+      mg_error(c, "Invalid SSL key, err %d", mg_tls_err(tls, rc));
+      goto fail;
+#if OPENSSL_VERSION_NUMBER > 0x10100000L
+    } else if ((rc = SSL_use_certificate_chain_file(tls->ssl, opts->cert)) !=
+               1) {
+      mg_error(c, "Invalid chain, err %d", mg_tls_err(tls, rc));
+      goto fail;
+#endif
+    } else {
+      SSL_set_mode(tls->ssl, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
+#if OPENSSL_VERSION_NUMBER > 0x10002000L
+      SSL_set_ecdh_auto(tls->ssl, 1);
+#endif
+    }
+  }
+#if OPENSSL_VERSION_NUMBER > 0x10002000L
+  if (opts->srvname.len > 0) {
+    char mem[128], *buf = mem;
+    mg_asprintf(&buf, sizeof(mem), "%.*s", (int) opts->srvname.len,
+                opts->srvname.ptr);
+    SSL_set1_host(tls->ssl, buf);
+    if (buf != mem) free(buf);
+  }
+#endif
+  if (opts->ciphers != NULL) SSL_set_cipher_list(tls->ssl, opts->ciphers);
+  if (opts->srvname.len > 0) {
+    char mem[128], *buf = mem;
+    mg_asprintf(&buf, sizeof(mem), "%.*s", (int) opts->srvname.len,
+                opts->srvname.ptr);
+    SSL_set_tlsext_host_name(tls->ssl, buf);
+    if (buf != mem) free(buf);
+  }
+  c->tls = tls;
+  c->is_tls = 1;
+  c->is_tls_hs = 1;
+  if (c->is_client && c->is_resolving == 0 && c->is_connecting == 0) {
+    mg_tls_handshake(c);
+  }
+  MG_DEBUG(("%lu SSL %s OK", c->id, c->is_accepted ? "accept" : "client"));
+  return;
+fail:
+  c->is_closing = 1;
+  free(tls);
+}
+
+void mg_tls_handshake(struct mg_connection *c) {
+  struct mg_tls *tls = (struct mg_tls *) c->tls;
+  int rc;
+  SSL_set_fd(tls->ssl, (int) (size_t) c->fd);
+  rc = c->is_client ? SSL_connect(tls->ssl) : SSL_accept(tls->ssl);
+  if (rc == 1) {
+    MG_DEBUG(("%lu success", c->id));
+    c->is_tls_hs = 0;
+  } else {
+    int code = mg_tls_err(tls, rc);
+    if (code != 0) mg_error(c, "tls hs: rc %d, err %d", rc, code);
+  }
+}
+
+void mg_tls_free(struct mg_connection *c) {
+  struct mg_tls *tls = (struct mg_tls *) c->tls;
+  if (tls == NULL) return;
+  SSL_free(tls->ssl);
+  SSL_CTX_free(tls->ctx);
+  free(tls);
+  c->tls = NULL;
+}
+
+size_t mg_tls_pending(struct mg_connection *c) {
+  struct mg_tls *tls = (struct mg_tls *) c->tls;
+  return tls == NULL ? 0 : (size_t) SSL_pending(tls->ssl);
+}
+
+long mg_tls_recv(struct mg_connection *c, void *buf, size_t len) {
+  struct mg_tls *tls = (struct mg_tls *) c->tls;
+  int n = SSL_read(tls->ssl, buf, (int) len);
+  return n == 0 ? -1 : n < 0 && mg_tls_err(tls, n) == 0 ? 0 : n;
+}
+
+long mg_tls_send(struct mg_connection *c, const void *buf, size_t len) {
+  struct mg_tls *tls = (struct mg_tls *) c->tls;
+  int n = SSL_write(tls->ssl, buf, (int) len);
+  return n == 0 ? -1 : n < 0 && mg_tls_err(tls, n) == 0 ? 0 : n;
+}
+#endif
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/url.c"
+#endif
+
+
+struct url {
+  size_t key, user, pass, host, port, uri, end;
+};
+
+int mg_url_is_ssl(const char *url) {
+  return strncmp(url, "wss:", 4) == 0 || strncmp(url, "https:", 6) == 0 ||
+         strncmp(url, "mqtts:", 6) == 0 || strncmp(url, "ssl:", 4) == 0 ||
+         strncmp(url, "tls:", 4) == 0;
+}
+
+static struct url urlparse(const char *url) {
+  size_t i;
+  struct url u;
+  memset(&u, 0, sizeof(u));
+  for (i = 0; url[i] != '\0'; i++) {
+    if (url[i] == '/' && i > 0 && u.host == 0 && url[i - 1] == '/') {
+      u.host = i + 1;
+      u.port = 0;
+    } else if (url[i] == ']') {
+      u.port = 0;  // IPv6 URLs, like http://[::1]/bar
+    } else if (url[i] == ':' && u.port == 0 && u.uri == 0) {
+      u.port = i + 1;
+    } else if (url[i] == '@' && u.user == 0 && u.pass == 0 && u.uri == 0) {
+      u.user = u.host;
+      u.pass = u.port;
+      u.host = i + 1;
+      u.port = 0;
+    } else if (url[i] == '/' && u.host && u.uri == 0) {
+      u.uri = i;
+    }
+  }
+  u.end = i;
+#if 0
+  printf("[%s] %d %d %d %d %d\n", url, u.user, u.pass, u.host, u.port, u.uri);
+#endif
+  return u;
+}
+
+struct mg_str mg_url_host(const char *url) {
+  struct url u = urlparse(url);
+  size_t n = u.port  ? u.port - u.host - 1
+             : u.uri ? u.uri - u.host
+                     : u.end - u.host;
+  struct mg_str s = mg_str_n(url + u.host, n);
+  return s;
+}
+
+const char *mg_url_uri(const char *url) {
+  struct url u = urlparse(url);
+  return u.uri ? url + u.uri : "/";
+}
+
+unsigned short mg_url_port(const char *url) {
+  struct url u = urlparse(url);
+  unsigned short port = 0;
+  if (strncmp(url, "http:", 5) == 0 || strncmp(url, "ws:", 3) == 0) port = 80;
+  if (strncmp(url, "wss:", 4) == 0 || strncmp(url, "https:", 6) == 0)
+    port = 443;
+  if (strncmp(url, "mqtt:", 5) == 0) port = 1883;
+  if (strncmp(url, "mqtts:", 6) == 0) port = 8883;
+  if (u.port) port = (unsigned short) atoi(url + u.port);
+  return port;
+}
+
+struct mg_str mg_url_user(const char *url) {
+  struct url u = urlparse(url);
+  struct mg_str s = mg_str("");
+  if (u.user && (u.pass || u.host)) {
+    size_t n = u.pass ? u.pass - u.user - 1 : u.host - u.user - 1;
+    s = mg_str_n(url + u.user, n);
+  }
+  return s;
+}
+
+struct mg_str mg_url_pass(const char *url) {
+  struct url u = urlparse(url);
+  struct mg_str s = mg_str_n("", 0UL);
+  if (u.pass && u.host) {
+    size_t n = u.host - u.pass - 1;
+    s = mg_str_n(url + u.pass, n);
+  }
+  return s;
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/util.c"
+#endif
+
+
+#if MG_ENABLE_CUSTOM_RANDOM
+#else
+void mg_random(void *buf, size_t len) {
+  bool done = false;
+  unsigned char *p = (unsigned char *) buf;
+#if MG_ARCH == MG_ARCH_ESP32
+  while (len--) *p++ = (unsigned char) (esp_random() & 255);
+  done = true;
+#elif MG_ARCH == MG_ARCH_WIN32
+#elif MG_ARCH == MG_ARCH_UNIX
+  FILE *fp = fopen("/dev/urandom", "rb");
+  if (fp != NULL) {
+    if (fread(buf, 1, len, fp) == len) done = true;
+    fclose(fp);
+  }
+#endif
+  // If everything above did not work, fallback to a pseudo random generator
+  while (!done && len--) *p++ = (unsigned char) (rand() & 255);
+}
+#endif
+
+char *mg_random_str(char *buf, size_t len) {
+  size_t i;
+  mg_random(buf, len);
+  for (i = 0; i < len; i++) {
+    uint8_t c = ((uint8_t *) buf)[i] % 62U;
+    buf[i] = i == len - 1 ? (char) '\0'            // 0-terminate last byte
+             : c < 26     ? (char) ('a' + c)       // lowercase
+             : c < 52     ? (char) ('A' + c - 26)  // uppercase
+                          : (char) ('0' + c - 52);     // numeric
+  }
+  return buf;
+}
+
+uint32_t mg_ntohl(uint32_t net) {
+  uint8_t data[4] = {0, 0, 0, 0};
+  memcpy(&data, &net, sizeof(data));
+  return (((uint32_t) data[3]) << 0) | (((uint32_t) data[2]) << 8) |
+         (((uint32_t) data[1]) << 16) | (((uint32_t) data[0]) << 24);
+}
+
+uint16_t mg_ntohs(uint16_t net) {
+  uint8_t data[2] = {0, 0};
+  memcpy(&data, &net, sizeof(data));
+  return (uint16_t) ((uint16_t) data[1] | (((uint16_t) data[0]) << 8));
+}
+
+uint32_t mg_crc32(uint32_t crc, const char *buf, size_t len) {
+  int i;
+  crc = ~crc;
+  while (len--) {
+    crc ^= *(unsigned char *) buf++;
+    for (i = 0; i < 8; i++) crc = crc & 1 ? (crc >> 1) ^ 0xedb88320 : crc >> 1;
+  }
+  return ~crc;
+}
+
+static int isbyte(int n) {
+  return n >= 0 && n <= 255;
+}
+
+static int parse_net(const char *spec, uint32_t *net, uint32_t *mask) {
+  int n, a, b, c, d, slash = 32, len = 0;
+  if ((sscanf(spec, "%d.%d.%d.%d/%d%n", &a, &b, &c, &d, &slash, &n) == 5 ||
+       sscanf(spec, "%d.%d.%d.%d%n", &a, &b, &c, &d, &n) == 4) &&
+      isbyte(a) && isbyte(b) && isbyte(c) && isbyte(d) && slash >= 0 &&
+      slash < 33) {
+    len = n;
+    *net = ((uint32_t) a << 24) | ((uint32_t) b << 16) | ((uint32_t) c << 8) |
+           (uint32_t) d;
+    *mask = slash ? (uint32_t) (0xffffffffU << (32 - slash)) : (uint32_t) 0;
+  }
+  return len;
+}
+
+int mg_check_ip_acl(struct mg_str acl, uint32_t remote_ip) {
+  struct mg_str k, v;
+  int allowed = acl.len == 0 ? '+' : '-';  // If any ACL is set, deny by default
+  while (mg_commalist(&acl, &k, &v)) {
+    uint32_t net, mask;
+    if (k.ptr[0] != '+' && k.ptr[0] != '-') return -1;
+    if (parse_net(&k.ptr[1], &net, &mask) == 0) return -2;
+    if ((mg_ntohl(remote_ip) & mask) == net) allowed = k.ptr[0];
+  }
+  return allowed == '+';
+}
+
+#if MG_ENABLE_CUSTOM_MILLIS
+#else
+uint64_t mg_millis(void) {
+#if MG_ARCH == MG_ARCH_WIN32
+  return GetTickCount();
+#elif MG_ARCH == MG_ARCH_RP2040
+  return time_us_64() / 1000;
+#elif MG_ARCH == MG_ARCH_ESP32
+  return esp_timer_get_time() / 1000;
+#elif MG_ARCH == MG_ARCH_ESP8266
+  return xTaskGetTickCount() * portTICK_PERIOD_MS;
+#elif MG_ARCH == MG_ARCH_FREERTOS_TCP || MG_ARCH == MG_ARCH_FREERTOS_LWIP
+  return xTaskGetTickCount() * portTICK_PERIOD_MS;
+#elif MG_ARCH == MG_ARCH_AZURERTOS
+  return tx_time_get() * (1000 /* MS per SEC */ / TX_TIMER_TICKS_PER_SECOND);
+#elif MG_ARCH == MG_ARCH_UNIX && defined(__APPLE__)
+  // Apple CLOCK_MONOTONIC_RAW is equivalent to CLOCK_BOOTTIME on linux
+  // Apple CLOCK_UPTIME_RAW is equivalent to CLOCK_MONOTONIC_RAW on linux
+  return clock_gettime_nsec_np(CLOCK_UPTIME_RAW) / 1000000;
+#elif MG_ARCH == MG_ARCH_UNIX
+  struct timespec ts = {0, 0};
+  // See #1615 - prefer monotonic clock
+#if defined(CLOCK_MONOTONIC_RAW)
+  // Raw hardware-based time that is not subject to NTP adjustment
+  clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
+#elif defined(CLOCK_MONOTONIC)
+  // Affected by the incremental adjustments performed by adjtime and NTP
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+#else
+  // Affected by discontinuous jumps in the system time and by the incremental
+  // adjustments performed by adjtime and NTP
+  clock_gettime(CLOCK_REALTIME, &ts);
+#endif
+  return ((uint64_t) ts.tv_sec * 1000 + (uint64_t) ts.tv_nsec / 1000000);
+#else
+  return (uint64_t) (time(NULL) * 1000);
+#endif
+}
+#endif
+
+#ifdef MG_ENABLE_LINES
+#line 1 "src/ws.c"
+#endif
+
+
+
+
+
+
+
+
+
+struct ws_msg {
+  uint8_t flags;
+  size_t header_len;
+  size_t data_len;
+};
+
+size_t mg_ws_vprintf(struct mg_connection *c, int op, const char *fmt,
+                     va_list ap) {
+  char mem[256], *buf = mem;
+  size_t len = mg_vasprintf(&buf, sizeof(mem), fmt, ap);
+  len = mg_ws_send(c, buf, len, op);
+  if (buf != mem) free(buf);
+  return len;
+}
+
+size_t mg_ws_printf(struct mg_connection *c, int op, const char *fmt, ...) {
+  size_t len = 0;
+  va_list ap;
+  va_start(ap, fmt);
+  len = mg_ws_vprintf(c, op, fmt, ap);
+  va_end(ap);
+  return len;
+}
+
+static void ws_handshake(struct mg_connection *c, const struct mg_str *wskey,
+                         const struct mg_str *wsproto, const char *fmt,
+                         va_list ap) {
+  const char *magic = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+  unsigned char sha[20], b64_sha[30];
+  char mem[128], *buf = mem;
+
+  mg_sha1_ctx sha_ctx;
+  mg_sha1_init(&sha_ctx);
+  mg_sha1_update(&sha_ctx, (unsigned char *) wskey->ptr, wskey->len);
+  mg_sha1_update(&sha_ctx, (unsigned char *) magic, 36);
+  mg_sha1_final(sha, &sha_ctx);
+  mg_base64_encode(sha, sizeof(sha), (char *) b64_sha);
+  buf[0] = '\0';
+  if (fmt != NULL) mg_vasprintf(&buf, sizeof(mem), fmt, ap);
+  mg_printf(c,
+            "HTTP/1.1 101 Switching Protocols\r\n"
+            "Upgrade: websocket\r\n"
+            "Connection: Upgrade\r\n"
+            "Sec-WebSocket-Accept: %s\r\n"
+            "%s",
+            b64_sha, buf);
+  if (buf != mem) free(buf);
+  if (wsproto != NULL) {
+    mg_printf(c, "Sec-WebSocket-Protocol: %.*s\r\n", (int) wsproto->len,
+              wsproto->ptr);
+  }
+  mg_send(c, "\r\n", 2);
+}
+
+static size_t ws_process(uint8_t *buf, size_t len, struct ws_msg *msg) {
+  size_t i, n = 0, mask_len = 0;
+  memset(msg, 0, sizeof(*msg));
+  if (len >= 2) {
+    n = buf[1] & 0x7f;                // Frame length
+    mask_len = buf[1] & 128 ? 4 : 0;  // last bit is a mask bit
+    msg->flags = buf[0];
+    if (n < 126 && len >= mask_len) {
+      msg->data_len = n;
+      msg->header_len = 2 + mask_len;
+    } else if (n == 126 && len >= 4 + mask_len) {
+      msg->header_len = 4 + mask_len;
+      msg->data_len = mg_ntohs(*(uint16_t *) &buf[2]);
+    } else if (len >= 10 + mask_len) {
+      msg->header_len = 10 + mask_len;
+      msg->data_len =
+          (size_t) (((uint64_t) mg_ntohl(*(uint32_t *) &buf[2])) << 32) +
+          mg_ntohl(*(uint32_t *) &buf[6]);
+    }
+  }
+  // Sanity check, and integer overflow protection for the boundary check below
+  // data_len should not be larger than 1 Gb
+  if (msg->data_len > 1024 * 1024 * 1024) return 0;
+  if (msg->header_len + msg->data_len > len) return 0;
+  if (mask_len > 0) {
+    uint8_t *p = buf + msg->header_len, *m = p - mask_len;
+    for (i = 0; i < msg->data_len; i++) p[i] ^= m[i & 3];
+  }
+  return msg->header_len + msg->data_len;
+}
+
+static size_t mkhdr(size_t len, int op, bool is_client, uint8_t *buf) {
+  size_t n = 0;
+  buf[0] = (uint8_t) (op | 128);
+  if (len < 126) {
+    buf[1] = (unsigned char) len;
+    n = 2;
+  } else if (len < 65536) {
+    uint16_t tmp = mg_htons((uint16_t) len);
+    buf[1] = 126;
+    memcpy(&buf[2], &tmp, sizeof(tmp));
+    n = 4;
+  } else {
+    uint32_t tmp;
+    buf[1] = 127;
+    tmp = mg_htonl((uint32_t) ((uint64_t) len >> 32));
+    memcpy(&buf[2], &tmp, sizeof(tmp));
+    tmp = mg_htonl((uint32_t) (len & 0xffffffff));
+    memcpy(&buf[6], &tmp, sizeof(tmp));
+    n = 10;
+  }
+  if (is_client) {
+    buf[1] |= 1 << 7;  // Set masking flag
+    mg_random(&buf[n], 4);
+    n += 4;
+  }
+  return n;
+}
+
+static void mg_ws_mask(struct mg_connection *c, size_t len) {
+  if (c->is_client && c->send.buf != NULL) {
+    size_t i;
+    uint8_t *p = c->send.buf + c->send.len - len, *mask = p - 4;
+    for (i = 0; i < len; i++) p[i] ^= mask[i & 3];
+  }
+}
+
+size_t mg_ws_send(struct mg_connection *c, const char *buf, size_t len,
+                  int op) {
+  uint8_t header[14];
+  size_t header_len = mkhdr(len, op, c->is_client, header);
+  mg_send(c, header, header_len);
+  MG_VERBOSE(("WS out: %d [%.*s]", (int) len, (int) len, buf));
+  mg_send(c, buf, len);
+  mg_ws_mask(c, len);
+  return header_len + len;
+}
+
+static void mg_ws_cb(struct mg_connection *c, int ev, void *ev_data,
+                     void *fn_data) {
+  struct ws_msg msg;
+  size_t ofs = (size_t) c->pfn_data;
+
+  // assert(ofs < c->recv.len);
+  if (ev == MG_EV_READ) {
+    if (!c->is_websocket && c->is_client) {
+      int n = mg_http_get_request_len(c->recv.buf, c->recv.len);
+      if (n < 0) {
+        c->is_closing = 1;  // Some just, not an HTTP request
+      } else if (n > 0) {
+        if (n < 15 || memcmp(c->recv.buf + 9, "101", 3) != 0) {
+          MG_ERROR(("%lu WS handshake error: %.*s", c->id, 15, c->recv.buf));
+          c->is_closing = 1;
+        } else {
+          struct mg_http_message hm;
+          mg_http_parse((char *) c->recv.buf, c->recv.len, &hm);
+          c->is_websocket = 1;
+          mg_call(c, MG_EV_WS_OPEN, &hm);
+        }
+        mg_iobuf_del(&c->recv, 0, (size_t) n);
+      } else {
+        return;  // A request is not yet received
+      }
+    }
+
+    while (ws_process(c->recv.buf + ofs, c->recv.len - ofs, &msg) > 0) {
+      char *s = (char *) c->recv.buf + ofs + msg.header_len;
+      struct mg_ws_message m = {{s, msg.data_len}, msg.flags};
+      size_t len = msg.header_len + msg.data_len;
+      uint8_t final = msg.flags & 128, op = msg.flags & 15;
+      // MG_VERBOSE ("fin %d op %d len %d [%.*s]", final, op,
+      //                       (int) m.data.len, (int) m.data.len, m.data.ptr));
+      switch (op) {
+        case WEBSOCKET_OP_CONTINUE:
+          mg_call(c, MG_EV_WS_CTL, &m);
+          break;
+        case WEBSOCKET_OP_PING:
+          MG_DEBUG(("%s", "WS PONG"));
+          mg_ws_send(c, s, msg.data_len, WEBSOCKET_OP_PONG);
+          mg_call(c, MG_EV_WS_CTL, &m);
+          break;
+        case WEBSOCKET_OP_PONG:
+          mg_call(c, MG_EV_WS_CTL, &m);
+          break;
+        case WEBSOCKET_OP_TEXT:
+        case WEBSOCKET_OP_BINARY:
+          if (final) mg_call(c, MG_EV_WS_MSG, &m);
+          break;
+        case WEBSOCKET_OP_CLOSE:
+          MG_DEBUG(("%lu Got WS CLOSE", c->id));
+          mg_call(c, MG_EV_WS_CTL, &m);
+          mg_ws_send(c, "", 0, WEBSOCKET_OP_CLOSE);
+          c->is_draining = 1;
+          break;
+        default:
+          // Per RFC6455, close conn when an unknown op is recvd
+          mg_error(c, "unknown WS op %d", op);
+          break;
+      }
+
+      // Handle fragmented frames: strip header, keep in c->recv
+      if (final == 0 || op == 0) {
+        if (op) ofs++, len--, msg.header_len--;       // First frame
+        mg_iobuf_del(&c->recv, ofs, msg.header_len);  // Strip header
+        len -= msg.header_len;
+        ofs += len;
+        c->pfn_data = (void *) ofs;
+        // MG_INFO(("FRAG %d [%.*s]", (int) ofs, (int) ofs, c->recv.buf));
+      }
+      // Remove non-fragmented frame
+      if (final && op) mg_iobuf_del(&c->recv, ofs, len);
+      // Last chunk of the fragmented frame
+      if (final && !op) {
+        m.flags = c->recv.buf[0];
+        m.data = mg_str_n((char *) &c->recv.buf[1], (size_t) (ofs - 1));
+        mg_call(c, MG_EV_WS_MSG, &m);
+        mg_iobuf_del(&c->recv, 0, ofs);
+        ofs = 0;
+        c->pfn_data = NULL;
+      }
+    }
+  }
+  (void) fn_data;
+  (void) ev_data;
+}
+
+struct mg_connection *mg_ws_connect(struct mg_mgr *mgr, const char *url,
+                                    mg_event_handler_t fn, void *fn_data,
+                                    const char *fmt, ...) {
+  struct mg_connection *c = mg_connect(mgr, url, fn, fn_data);
+  if (c != NULL) {
+    char nonce[16], key[30], mem1[128], mem2[256], *buf1 = mem1, *buf2 = mem2;
+    struct mg_str host = mg_url_host(url);
+    size_t n1 = 0, n2 = 0;
+    nonce[0] = key[0] = mem1[0] = mem2[0] = '\0';
+    if (fmt != NULL) {
+      va_list ap;
+      va_start(ap, fmt);
+      n1 = mg_vasprintf(&buf1, sizeof(mem1), fmt, ap);
+      va_end(ap);
+    }
+    // Send handshake request
+    mg_random(nonce, sizeof(nonce));
+    mg_base64_encode((unsigned char *) nonce, sizeof(nonce), key);
+    n2 = mg_asprintf(&buf2, sizeof(mem2),
+                     "GET %s HTTP/1.1\r\n"
+                     "Upgrade: websocket\r\n"
+                     "Host: %.*s\r\n"
+                     "Connection: Upgrade\r\n"
+                     "%.*s"
+                     "Sec-WebSocket-Version: 13\r\n"
+                     "Sec-WebSocket-Key: %s\r\n"
+                     "\r\n",
+                     mg_url_uri(url), (int) host.len, host.ptr, (int) n1, buf1,
+                     key);
+    mg_send(c, buf2, n2);
+    if (buf1 != mem1) free(buf1);
+    if (buf2 != mem2) free(buf2);
+    c->pfn = mg_ws_cb;
+    c->pfn_data = NULL;
+  }
+  return c;
+}
+
+void mg_ws_upgrade(struct mg_connection *c, struct mg_http_message *hm,
+                   const char *fmt, ...) {
+  struct mg_str *wskey = mg_http_get_header(hm, "Sec-WebSocket-Key");
+  c->pfn = mg_ws_cb;
+  c->pfn_data = NULL;
+  if (wskey == NULL) {
+    mg_http_reply(c, 426, "", "WS upgrade expected\n");
+    c->is_draining = 1;
+  } else {
+    struct mg_str *wsproto = mg_http_get_header(hm, "Sec-WebSocket-Protocol");
+    va_list ap;
+    va_start(ap, fmt);
+    ws_handshake(c, wskey, wsproto, fmt, ap);
+    va_end(ap);
+    c->is_websocket = 1;
+    mg_call(c, MG_EV_WS_OPEN, hm);
+  }
+}
+
+size_t mg_ws_wrap(struct mg_connection *c, size_t len, int op) {
+  uint8_t header[14], *p;
+  size_t header_len = mkhdr(len, op, c->is_client, header);
+
+  // NOTE: order of operations is important!
+  mg_iobuf_add(&c->send, c->send.len, NULL, header_len, MG_IO_SIZE);
+  p = &c->send.buf[c->send.len - len];         // p points to data
+  memmove(p, p - header_len, len);             // Shift data
+  memcpy(p - header_len, header, header_len);  // Prepend header
+  mg_ws_mask(c, len);                          // Mask data
+
+  return c->send.len;
+}
+
+#ifdef MG_ENABLE_LINES
+#line 1 "mip/driver_stm32.c"
+#endif
+// Copyright (c) 2022 Cesanta Software Limited
+// All rights reserved
+
+
+
+#if MG_ENABLE_MIP && defined(__arm__)
+
+struct stm32_eth {
+  volatile uint32_t MACCR, MACFFR, MACHTHR, MACHTLR, MACMIIAR, MACMIIDR, MACFCR,
+      MACVLANTR, RESERVED0[2], MACRWUFFR, MACPMTCSR, RESERVED1, MACDBGR, MACSR,
+      MACIMR, MACA0HR, MACA0LR, MACA1HR, MACA1LR, MACA2HR, MACA2LR, MACA3HR,
+      MACA3LR, RESERVED2[40], MMCCR, MMCRIR, MMCTIR, MMCRIMR, MMCTIMR,
+      RESERVED3[14], MMCTGFSCCR, MMCTGFMSCCR, RESERVED4[5], MMCTGFCR,
+      RESERVED5[10], MMCRFCECR, MMCRFAECR, RESERVED6[10], MMCRGUFCR,
+      RESERVED7[334], PTPTSCR, PTPSSIR, PTPTSHR, PTPTSLR, PTPTSHUR, PTPTSLUR,
+      PTPTSAR, PTPTTHR, PTPTTLR, RESERVED8, PTPTSSR, PTPPPSCR, RESERVED9[564],
+      DMABMR, DMATPDR, DMARPDR, DMARDLAR, DMATDLAR, DMASR, DMAOMR, DMAIER,
+      DMAMFBOCR, DMARSWTR, RESERVED10[8], DMACHTDR, DMACHRDR, DMACHTBAR,
+      DMACHRBAR;
+};
+#define ETH ((struct stm32_eth *) (uintptr_t) 0x40028000)
+
+#define BIT(x) ((uint32_t) 1 << (x))
+#define ETH_PKT_SIZE 1540  // Max frame size
+#define ETH_DESC_CNT 4     // Descriptors count
+#define ETH_DS 4           // Descriptor size (words)
+
+static uint32_t s_rxdesc[ETH_DESC_CNT][ETH_DS];      // RX descriptors
+static uint32_t s_txdesc[ETH_DESC_CNT][ETH_DS];      // TX descriptors
+static uint8_t s_rxbuf[ETH_DESC_CNT][ETH_PKT_SIZE];  // RX ethernet buffers
+static uint8_t s_txbuf[ETH_DESC_CNT][ETH_PKT_SIZE];  // TX ethernet buffers
+static void (*s_rx)(void *, size_t, void *);         // Recv callback
+static void *s_rxdata;                               // Recv callback data
+static void *s_userdata;                             // Driver data
+enum { PHY_ADDR = 0, PHY_BCR = 0, PHY_BSR = 1 };     // PHY constants
+
+static inline void spin(volatile uint32_t count) {
+  while (count--) asm("nop");
+}
+
+static uint32_t eth_read_phy(uint8_t addr, uint8_t reg) {
+  ETH->MACMIIAR &= (7 << 2);
+  ETH->MACMIIAR |= ((uint32_t) addr << 11) | ((uint32_t) reg << 6);
+  ETH->MACMIIAR |= BIT(0);
+  while (ETH->MACMIIAR & BIT(0)) spin(1);
+  return ETH->MACMIIDR;
+}
+
+static void eth_write_phy(uint8_t addr, uint8_t reg, uint32_t val) {
+  ETH->MACMIIDR = val;
+  ETH->MACMIIAR &= (7 << 2);
+  ETH->MACMIIAR |= ((uint32_t) addr << 11) | ((uint32_t) reg << 6) | BIT(1);
+  ETH->MACMIIAR |= BIT(0);
+  while (ETH->MACMIIAR & BIT(0)) spin(1);
+}
+
+static void mip_driver_stm32_init(void *userdata) {
+  s_userdata = userdata;
+
+  // Init RX descriptors
+  for (int i = 0; i < ETH_DESC_CNT; i++) {
+    s_rxdesc[i][0] = BIT(31);                            // Own
+    s_rxdesc[i][1] = sizeof(s_rxbuf[i]) | BIT(14);       // 2nd address chained
+    s_rxdesc[i][2] = (uint32_t) (uintptr_t) s_rxbuf[i];  // Point to data buffer
+    s_rxdesc[i][3] =
+        (uint32_t) (uintptr_t) s_rxdesc[(i + 1) % ETH_DESC_CNT];  // Chain
+  }
+
+  // Init TX descriptors
+  for (int i = 0; i < ETH_DESC_CNT; i++) {
+    s_txdesc[i][2] = (uint32_t) (uintptr_t) s_txbuf[i];  // Buf pointer
+    s_txdesc[i][3] =
+        (uint32_t) (uintptr_t) s_txdesc[(i + 1) % ETH_DESC_CNT];  // Chain
+  }
+
+  ETH->DMABMR |= BIT(0);                        // Software reset
+  while ((ETH->DMABMR & BIT(0)) != 0) spin(1);  // Wait until done
+  // NOTE(cpq): we do not use extended descriptor bit 7, and do not use
+  // hardware checksum. Therefore, descriptor size is 4, not 8
+  // ETH->DMABMR = BIT(13) | BIT(16) | BIT(22) | BIT(23) | BIT(25);
+  ETH->MACIMR = BIT(3) | BIT(9);              // Mask timestamp & PMT IT
+  ETH->MACMIIAR = 4 << 2;                     // MDC clock 150-216 MHz, 38.8.1
+  ETH->MACFCR = BIT(7);                       // Disable zero quarta pause
+  ETH->MACFFR = BIT(31);                      // Receive all
+  eth_write_phy(PHY_ADDR, PHY_BCR, BIT(15));  // Reset PHY
+  eth_write_phy(PHY_ADDR, PHY_BCR, BIT(12));  // Set autonegotiation
+  ETH->DMARDLAR = (uint32_t) (uintptr_t) s_rxdesc;     // RX descriptors
+  ETH->DMATDLAR = (uint32_t) (uintptr_t) s_txdesc;     // RX descriptors
+  ETH->DMAIER = BIT(6) | BIT(16);                      // RIE, NISE
+  ETH->MACCR = BIT(2) | BIT(3) | BIT(11) | BIT(14);    // RE, TE, Duplex, Fast
+  ETH->DMAOMR = BIT(1) | BIT(13) | BIT(21) | BIT(25);  // SR, ST, TSF, RSF
+}
+
+static void mip_driver_stm32_setrx(void (*rx)(void *, size_t, void *),
+                                   void *rxdata) {
+  s_rx = rx;
+  s_rxdata = rxdata;
+}
+
+static uint32_t s_txno;
+static size_t mip_driver_stm32_tx(const void *buf, size_t len, void *userdata) {
+  if (len > sizeof(s_txbuf[s_txno])) {
+    printf("%s: frame too big, %ld\n", __func__, (long) len);
+    len = 0;  // Frame is too big
+  } else if ((s_txdesc[s_txno][0] & BIT(31))) {
+    printf("%s: no free descr\n", __func__);
+    len = 0;  // All descriptors are busy, fail
+  } else {
+    memcpy(s_txbuf[s_txno], buf, len);     // Copy data
+    s_txdesc[s_txno][1] = (uint32_t) len;  // Set data len
+    s_txdesc[s_txno][0] = BIT(20) | BIT(28) | BIT(29) | BIT(30);  // Chain,FS,LS
+    s_txdesc[s_txno][0] |= BIT(31);  // Set OWN bit - let DMA take over
+    if (++s_txno >= ETH_DESC_CNT) s_txno = 0;
+  }
+  uint32_t sr = ETH->DMASR;
+  if (sr & BIT(2)) ETH->DMASR = BIT(2), ETH->DMATPDR = 0;  // Resume
+  if (sr & BIT(5)) ETH->DMASR = BIT(5), ETH->DMATPDR = 0;  // if busy
+  if (len == 0) printf("E: D0 %lx SR %lx\n", (long) s_txdesc[0][0], (long) sr);
+  return len;
+  (void) userdata;
+}
+
+static bool mip_driver_stm32_status(void *userdata) {
+  uint32_t bsr = eth_read_phy(PHY_ADDR, PHY_BSR);
+  return bsr & BIT(2) ? 1 : 0;
+  (void) userdata;
+}
+
+void ETH_IRQHandler(void);
+void ETH_IRQHandler(void) {
+  volatile uint32_t sr = ETH->DMASR;
+  if (sr & BIT(6)) {  // Frame received, loop
+    for (uint32_t i = 0; i < ETH_DESC_CNT; i++) {
+      if (s_rxdesc[i][0] & BIT(31)) continue;
+      uint32_t len = ((s_rxdesc[i][0] >> 16) & (BIT(14) - 1));
+      //    printf("%lx %lu %lx %lx\n", i, len, s_rxdesc[i][0], sr);
+      if (s_rx != NULL) s_rx(s_rxbuf[i], len > 4 ? len - 4 : len, s_rxdata);
+      s_rxdesc[i][0] = BIT(31);
+    }
+  }
+  if (sr & BIT(7)) ETH->DMARPDR = 0;     // Resume RX
+  ETH->DMASR = sr & ~(BIT(2) | BIT(7));  // Clear status
+}
+
+struct mip_driver mip_driver_stm32 = {.init = mip_driver_stm32_init,
+                                      .tx = mip_driver_stm32_tx,
+                                      .rxcb = mip_driver_stm32_setrx,
+                                      .status = mip_driver_stm32_status};
+#endif  // MG_ENABLE_MIP
+
+#ifdef MG_ENABLE_LINES
+#line 1 "mip/mip.c"
+#endif
+
+
+#if MG_ENABLE_MIP
+
+#if defined(_MSC_VER)
+#define _Atomic
+#define NET16(x) _byteswap_ushort(x)
+#define NET32(x) _byteswap_ulong(x)
+#else
+#include <stdatomic.h>
+#define NET16(x) __builtin_bswap16(x)
+#define NET32(x) __builtin_bswap32(x)
+#endif
+
+#define MIP_ETHEMERAL_PORT 49152
+#define U16(ptr) ((((uint16_t) (ptr)[0]) << 8) | (ptr)[1])
+#define PDIFF(a, b) ((size_t) (((char *) (b)) - ((char *) (a))))
+
+#ifndef MIP_ARP_ENTRIES
+#define MIP_ARP_ENTRIES 5  // Number of ARP cache entries. Maximum 21
+#endif
+#define MIP_ARP_CS (2 + 12 * MIP_ARP_ENTRIES)  // ARP cache size
+
+struct str {
+  uint8_t *buf;
+  size_t len;
+};
+
+// Receive queue - single producer, single consumer queue.  Interrupt-based
+// drivers copy received frames to the queue in interrupt context. mip_poll()
+// function runs in event loop context, reads from the queue
+struct queue {
+  uint8_t *buf;
+  size_t len;
+  volatile _Atomic size_t tail, head;
+};
+
+// Network interface
+struct mip_if {
+  uint8_t mac[6];             // MAC address. Must be set to a valid MAC
+  uint32_t ip, mask, gw;      // IP address, mask, default gateway. Can be 0
+  struct str rx;              // Output (TX) buffer
+  struct str tx;              // Input (RX) buffer
+  bool use_dhcp;              // Enable DCHP
+  struct mip_driver *driver;  // Low level driver
+  struct mg_mgr *mgr;         // Mongoose event manager
+
+  // Internal state, user can use it but should not change it
+  uint64_t curtime;               // Last poll timestamp in millis
+  uint64_t timer;                 // Timer
+  uint8_t arp_cache[MIP_ARP_CS];  // Each entry is 12 bytes
+  uint16_t eport;                 // Next ephemeral port
+  int state;                      // Current state
+#define MIP_STATE_DOWN 0          // Interface is down
+#define MIP_STATE_UP 1            // Interface is up
+#define MIP_STATE_READY 2         // Interface is up and has IP
+  struct queue queue;             // Receive queue
+};
+
+#pragma pack(push, 1)
+
+struct lcp {
+  uint8_t addr, ctrl, proto[2], code, id, len[2];
+};
+
+struct eth {
+  uint8_t dst[6];  // Destination MAC address
+  uint8_t src[6];  // Source MAC address
+  uint16_t type;   // Ethernet type
+};
+
+struct ip {
+  uint8_t ver;    // Version
+  uint8_t tos;    // Unused
+  uint16_t len;   // Length
+  uint16_t id;    // Unused
+  uint16_t frag;  // Fragmentation
+  uint8_t ttl;    // Time to live
+  uint8_t proto;  // Upper level protocol
+  uint16_t csum;  // Checksum
+  uint32_t src;   // Source IP
+  uint32_t dst;   // Destination IP
+};
+
+struct ip6 {
+  uint8_t ver;      // Version
+  uint8_t opts[3];  // Options
+  uint16_t len;     // Length
+  uint8_t proto;    // Upper level protocol
+  uint8_t ttl;      // Time to live
+  uint8_t src[16];  // Source IP
+  uint8_t dst[16];  // Destination IP
+};
+
+struct icmp {
+  uint8_t type;
+  uint8_t code;
+  uint16_t csum;
+};
+
+struct arp {
+  uint16_t fmt;    // Format of hardware address
+  uint16_t pro;    // Format of protocol address
+  uint8_t hlen;    // Length of hardware address
+  uint8_t plen;    // Length of protocol address
+  uint16_t op;     // Operation
+  uint8_t sha[6];  // Sender hardware address
+  uint32_t spa;    // Sender protocol address
+  uint8_t tha[6];  // Target hardware address
+  uint32_t tpa;    // Target protocol address
+};
+
+struct tcp {
+  uint16_t sport;  // Source port
+  uint16_t dport;  // Destination port
+  uint32_t seq;    // Sequence number
+  uint32_t ack;    // Acknowledgement number
+  uint8_t off;     // Data offset
+  uint8_t flags;   // TCP flags
+#define TH_FIN 0x01
+#define TH_SYN 0x02
+#define TH_RST 0x04
+#define TH_PUSH 0x08
+#define TH_ACK 0x10
+#define TH_URG 0x20
+#define TH_ECE 0x40
+#define TH_CWR 0x80
+  uint16_t win;   // Window
+  uint16_t csum;  // Checksum
+  uint16_t urp;   // Urgent pointer
+};
+
+struct udp {
+  uint16_t sport;  // Source port
+  uint16_t dport;  // Destination port
+  uint16_t len;    // UDP length
+  uint16_t csum;   // UDP checksum
+};
+
+struct dhcp {
+  uint8_t op, htype, hlen, hops;
+  uint32_t xid;
+  uint16_t secs, flags;
+  uint32_t ciaddr, yiaddr, siaddr, giaddr;
+  uint8_t hwaddr[208];
+  uint32_t magic;
+  uint8_t options[32];
+};
+
+#pragma pack(pop)
+
+struct pkt {
+  struct str raw;  // Raw packet data
+  struct str pay;  // Payload data
+  struct eth *eth;
+  struct llc *llc;
+  struct arp *arp;
+  struct ip *ip;
+  struct ip6 *ip6;
+  struct icmp *icmp;
+  struct tcp *tcp;
+  struct udp *udp;
+  struct dhcp *dhcp;
+};
+
+static void q_copyin(struct queue *q, const uint8_t *buf, size_t len,
+                     size_t head) {
+  size_t i = 0, left = q->len - head;
+  for (; i < len && i < left; i++) q->buf[head + i] = buf[i];
+  for (; i < len; i++) q->buf[i - left] = buf[i];
+}
+
+static void q_copyout(struct queue *q, uint8_t *buf, size_t len, size_t tail) {
+  size_t i = 0, left = q->len - tail;
+  for (; i < len && i < left; i++) buf[i] = q->buf[tail + i];
+  for (; i < len; i++) buf[i] = q->buf[i - left];
+}
+
+static bool q_write(struct queue *q, const void *buf, size_t len) {
+  bool success = false;
+  size_t left = q->len - q->head + q->tail;
+  if (len + sizeof(size_t) <= left) {
+    q_copyin(q, (uint8_t *) &len, sizeof(len), q->head);
+    q_copyin(q, (uint8_t *) buf, len, (q->head + sizeof(size_t)) % q->len);
+    q->head = (q->head + sizeof(len) + len) % q->len;
+    success = true;
+  }
+  return success;
+}
+
+static size_t q_avail(struct queue *q) {
+  size_t n = 0;
+  if (q->tail != q->head) q_copyout(q, (uint8_t *) &n, sizeof(n), q->tail);
+  return n;
+}
+
+static size_t q_read(struct queue *q, void *buf) {
+  size_t n = q_avail(q);
+  if (n > 0) {
+    q_copyout(q, (uint8_t *) buf, n, (q->tail + sizeof(n)) % q->len);
+    q->tail = (q->tail + sizeof(n) + n) % q->len;
+  }
+  return n;
+}
+
+static struct str mkstr(void *buf, size_t len) {
+  struct str str = {(uint8_t *) buf, len};
+  return str;
+}
+
+static void mkpay(struct pkt *pkt, void *p) {
+  pkt->pay = mkstr(p, (size_t) (&pkt->raw.buf[pkt->raw.len] - (uint8_t *) p));
+}
+
+static uint32_t csumup(uint32_t sum, const void *buf, size_t len) {
+  const uint8_t *p = (const uint8_t *) buf;
+  for (size_t i = 0; i < len; i++) sum += i & 1 ? p[i] : (uint32_t) (p[i] << 8);
+  return sum;
+}
+
+static uint16_t csumfin(uint32_t sum) {
+  while (sum >> 16) sum = (sum & 0xffff) + (sum >> 16);
+  return NET16(~sum & 0xffff);
+}
+
+static uint16_t ipcsum(const void *buf, size_t len) {
+  uint32_t sum = csumup(0, buf, len);
+  return csumfin(sum);
+}
+
+// ARP cache is organised as a doubly linked list. A successful cache lookup
+// moves an entry to the head of the list. New entries are added by replacing
+// the last entry in the list with a new IP/MAC.
+// ARP cache format: | prev | next | Entry0 | Entry1 | .... | EntryN |
+// ARP entry format: | prev | next | IP (4bytes) | MAC (6bytes) |
+// prev and next are 1-byte offsets in the cache, so cache size is max 256 bytes
+// ARP entry size is 12 bytes
+static void arp_cache_init(uint8_t *p, int n, int size) {
+  for (int i = 0; i < n; i++) p[2 + i * size] = (uint8_t) (2 + (i - 1) * size);
+  for (int i = 0; i < n; i++) p[3 + i * size] = (uint8_t) (2 + (i + 1) * size);
+  p[0] = p[2] = (uint8_t) (2 + (n - 1) * size);
+  p[1] = p[3 + (n - 1) * size] = 2;
+}
+
+static uint8_t *arp_cache_find(struct mip_if *ifp, uint32_t ip) {
+  uint8_t *p = ifp->arp_cache;
+  if (ip == 0) return NULL;
+  if (p[0] == 0 || p[1] == 0) arp_cache_init(p, MIP_ARP_ENTRIES, 12);
+  for (uint8_t i = 0, j = p[1]; i < MIP_ARP_ENTRIES; i++, j = p[j + 1]) {
+    if (memcmp(p + j + 2, &ip, sizeof(ip)) == 0) {
+      p[1] = j, p[0] = p[j];  // Found entry! Point list head to us
+      // MG_DEBUG(("ARP find: %#lx @ %x:%x:%x:%x:%x:%x\n", (long) ip, p[j + 6],
+      //          p[j + 7], p[j + 8], p[j + 9], p[j + 10], p[j + 11]));
+      return p + j + 6;  // And return MAC address
+    }
+  }
+  return NULL;
+}
+
+static void arp_cache_add(struct mip_if *ifp, uint32_t ip, uint8_t mac[6]) {
+  uint8_t *p = ifp->arp_cache;
+  if (ip == 0 || ip == ~0U) return;             // Bad IP
+  if (arp_cache_find(ifp, ip) != NULL) return;  // Already exists, do nothing
+  memcpy(p + p[0] + 2, &ip, sizeof(ip));  // Replace last entry: IP address
+  memcpy(p + p[0] + 6, mac, 6);           // And MAC address
+  p[1] = p[0], p[0] = p[p[1]];            // Point list head to us
+  // MG_DEBUG(("ARP cache: added %#lx @ %x:%x:%x:%x:%x:%x\n", (long) ip, mac[0],
+  //      mac[1], mac[2], mac[3], mac[4], mac[5]));
+}
+
+static void arp_ask(struct mip_if *ifp, uint32_t ip) {
+  struct eth *eth = (struct eth *) ifp->tx.buf;
+  struct arp *arp = (struct arp *) (eth + 1);
+  memset(eth->dst, 255, sizeof(eth->dst));
+  memcpy(eth->src, ifp->mac, sizeof(eth->src));
+  eth->type = NET16(0x806);
+  memset(arp, 0, sizeof(*arp));
+  arp->fmt = NET16(1), arp->pro = NET16(0x800), arp->hlen = 6, arp->plen = 4;
+  arp->op = NET16(1), arp->tpa = ip, arp->spa = ifp->ip;
+  memcpy(arp->sha, ifp->mac, sizeof(arp->sha));
+  ifp->driver->tx(eth, PDIFF(eth, arp + 1), ifp->driver->data);
+}
+
+static void onstatechange(struct mip_if *ifp) {
+  if (ifp->state == MIP_STATE_READY) {
+    char buf[40];
+    struct mg_addr addr = {.ip = ifp->ip};
+    MG_INFO(("READY, IP: %s", mg_ntoa(&addr, buf, sizeof(buf))));
+    arp_ask(ifp, ifp->gw);
+  } else if (ifp->state == MIP_STATE_UP) {
+    MG_ERROR(("Network up"));
+  } else if (ifp->state == MIP_STATE_DOWN) {
+    MG_ERROR(("Network down"));
+  }
+}
+
+static struct ip *tx_ip(struct mip_if *ifp, uint8_t proto, uint32_t ip_src,
+                        uint32_t ip_dst, size_t plen) {
+  struct eth *eth = (struct eth *) ifp->tx.buf;
+  struct ip *ip = (struct ip *) (eth + 1);
+  uint8_t *mac = arp_cache_find(ifp, ip_dst);         // Dst IP in ARP cache ?
+  if (!mac) mac = arp_cache_find(ifp, ifp->gw);       // No, use gateway
+  if (mac) memcpy(eth->dst, mac, sizeof(eth->dst));   // Found? Use it
+  if (!mac) memset(eth->dst, 255, sizeof(eth->dst));  // No? Use broadcast
+  memcpy(eth->src, ifp->mac, sizeof(eth->src));       // TODO(cpq): ARP lookup
+  eth->type = NET16(0x800);
+  memset(ip, 0, sizeof(*ip));
+  ip->ver = 0x45;   // Version 4, header length 5 words
+  ip->frag = 0x40;  // Don't fragment
+  ip->len = NET16((uint16_t) (sizeof(*ip) + plen));
+  ip->ttl = 64;
+  ip->proto = proto;
+  ip->src = ip_src;
+  ip->dst = ip_dst;
+  ip->csum = ipcsum(ip, sizeof(*ip));
+  return ip;
+}
+
+static void tx_udp(struct mip_if *ifp, uint32_t ip_src, uint16_t sport,
+                   uint32_t ip_dst, uint16_t dport, const void *buf,
+                   size_t len) {
+  struct ip *ip = tx_ip(ifp, 17, ip_src, ip_dst, len + sizeof(struct udp));
+  struct udp *udp = (struct udp *) (ip + 1);
+  udp->sport = sport;
+  udp->dport = dport;
+  udp->len = NET16((uint16_t) (sizeof(*udp) + len));
+  udp->csum = 0;
+  uint32_t cs = csumup(0, udp, sizeof(*udp));
+  cs = csumup(cs, buf, len);
+  cs = csumup(cs, &ip->src, sizeof(ip->src));
+  cs = csumup(cs, &ip->dst, sizeof(ip->dst));
+  cs += (uint32_t) (ip->proto + sizeof(*udp) + len);
+  udp->csum = csumfin(cs);
+  memmove(udp + 1, buf, len);
+  // MG_DEBUG(("UDP LEN %d %d\n", (int) len, (int) ifp->frame_len));
+  ifp->driver->tx(ifp->tx.buf,
+                  sizeof(struct eth) + sizeof(*ip) + sizeof(*udp) + len,
+                  ifp->driver->data);
+}
+
+static void tx_dhcp(struct mip_if *ifp, uint32_t src, uint32_t dst,
+                    uint8_t *opts, size_t optslen) {
+  struct dhcp dhcp = {.op = 1,
+                      .htype = 1,
+                      .hlen = 6,
+                      .ciaddr = src,
+                      .magic = NET32(0x63825363)};
+  memcpy(&dhcp.hwaddr, ifp->mac, sizeof(ifp->mac));
+  memcpy(&dhcp.xid, ifp->mac + 2, sizeof(dhcp.xid));
+  memcpy(&dhcp.options, opts, optslen);
+  tx_udp(ifp, src, NET16(68), dst, NET16(67), &dhcp, sizeof(dhcp));
+}
+
+static void tx_dhcp_request(struct mip_if *ifp, uint32_t src, uint32_t dst) {
+  uint8_t opts[] = {
+      53, 1, 3,                 // Type: DHCP request
+      55, 2, 1,   3,            // GW and mask
+      12, 3, 'm', 'i', 'p',     // Host name: "mip"
+      54, 4, 0,   0,   0,   0,  // DHCP server ID
+      50, 4, 0,   0,   0,   0,  // Requested IP
+      255                       // End of options
+  };
+  memcpy(opts + 14, &dst, sizeof(dst));
+  memcpy(opts + 20, &src, sizeof(src));
+  tx_dhcp(ifp, src, dst, opts, sizeof(opts));
+}
+
+static void tx_dhcp_discover(struct mip_if *ifp) {
+  uint8_t opts[] = {
+      53, 1, 1,     // Type: DHCP discover
+      55, 2, 1, 3,  // Parameters: ip, mask
+      255           // End of options
+  };
+  tx_dhcp(ifp, 0, 0xffffffff, opts, sizeof(opts));
+}
+
+static void rx_arp(struct mip_if *ifp, struct pkt *pkt) {
+  // MG_DEBUG(("ARP op %d %#x %#x\n", NET16(arp->op), arp->spa, arp->tpa));
+  if (pkt->arp->op == NET16(1) && pkt->arp->tpa == ifp->ip) {
+    // ARP request. Make a response, then send
+    struct eth *eth = (struct eth *) ifp->tx.buf;
+    struct arp *arp = (struct arp *) (eth + 1);
+    memcpy(eth->dst, pkt->eth->src, sizeof(eth->dst));
+    memcpy(eth->src, ifp->mac, sizeof(eth->src));
+    eth->type = NET16(0x806);
+    *arp = *pkt->arp;
+    arp->op = NET16(2);
+    memcpy(arp->tha, pkt->arp->sha, sizeof(pkt->arp->tha));
+    memcpy(arp->sha, ifp->mac, sizeof(pkt->arp->sha));
+    arp->tpa = pkt->arp->spa;
+    arp->spa = ifp->ip;
+    MG_DEBUG(("ARP response: we're %#lx", (long) ifp->ip));
+    ifp->driver->tx(ifp->tx.buf, PDIFF(eth, arp + 1), ifp->driver->data);
+  } else if (pkt->arp->op == NET16(2)) {
+    if (memcmp(pkt->arp->tha, ifp->mac, sizeof(pkt->arp->tha)) != 0) return;
+    // MG_INFO(("ARP RESPONSE"));
+    arp_cache_add(ifp, pkt->arp->spa, pkt->arp->sha);
+  }
+}
+
+static void rx_icmp(struct mip_if *ifp, struct pkt *pkt) {
+  // MG_DEBUG(("ICMP %d\n", (int) len));
+  if (pkt->icmp->type == 8 && pkt->ip->dst == ifp->ip) {
+    struct ip *ip = tx_ip(ifp, 1, ifp->ip, pkt->ip->src,
+                          sizeof(struct icmp) + pkt->pay.len);
+    struct icmp *icmp = (struct icmp *) (ip + 1);
+    memset(icmp, 0, sizeof(*icmp));  // Important - set csum to 0
+    memcpy(icmp + 1, pkt->pay.buf, pkt->pay.len);
+    icmp->csum = ipcsum(icmp, sizeof(*icmp) + pkt->pay.len);
+    ifp->driver->tx(ifp->tx.buf, PDIFF(ifp->tx.buf, icmp + 1) + pkt->pay.len,
+                    ifp->driver->data);
+  }
+}
+
+static void rx_dhcp(struct mip_if *ifp, struct pkt *pkt) {
+  uint32_t ip = 0, gw = 0, mask = 0;
+  uint8_t *p = pkt->dhcp->options, *end = &pkt->raw.buf[pkt->raw.len];
+  if (end < (uint8_t *) (pkt->dhcp + 1)) return;
+  // MG_DEBUG(("DHCP %u\n", (unsigned) pkt->raw.len));
+  while (p < end && p[0] != 255) {
+    if (p[0] == 1 && p[1] == sizeof(ifp->mask)) {
+      memcpy(&mask, p + 2, sizeof(mask));
+      // MG_DEBUG(("MASK %x\n", mask));
+    } else if (p[0] == 3 && p[1] == sizeof(ifp->gw)) {
+      memcpy(&gw, p + 2, sizeof(gw));
+      ip = pkt->dhcp->yiaddr;
+      // MG_DEBUG(("IP %x GW %x\n", ip, gw));
+    }
+    p += p[1] + 2;
+  }
+  if (ip && mask && gw && ifp->ip == 0) {
+    // MG_DEBUG(("DHCP offer ip %#08lx mask %#08lx gw %#08lx\n",
+    //      (long) ip, (long) mask, (long) gw));
+    arp_cache_add(ifp, pkt->dhcp->siaddr, ((struct eth *) pkt->raw.buf)->src);
+    ifp->ip = ip, ifp->gw = gw, ifp->mask = mask;
+    ifp->state = MIP_STATE_READY;
+    onstatechange(ifp);
+    tx_dhcp_request(ifp, ip, pkt->dhcp->siaddr);
+  }
+}
+
+static struct mg_connection *getpeer(struct mg_mgr *mgr, struct pkt *pkt,
+                                     bool lsn) {
+  struct mg_connection *c = NULL;
+  for (c = mgr->conns; c != NULL; c = c->next) {
+    if (c->is_udp && pkt->udp && c->loc.port == pkt->udp->dport) break;
+    if (!c->is_udp && pkt->tcp && c->loc.port == pkt->tcp->dport &&
+        lsn == c->is_listening && (lsn || c->rem.port == pkt->tcp->sport))
+      break;
+  }
+  return c;
+}
+
+static void rx_udp(struct mip_if *ifp, struct pkt *pkt) {
+  struct mg_connection *c = getpeer(ifp->mgr, pkt, true);
+  if (c == NULL) {
+    // No UDP listener on this port. Should send ICMP, but keep silent.
+  } else if (c != NULL) {
+    c->rem.port = pkt->udp->sport;
+    c->rem.ip = pkt->ip->src;
+    if (c->recv.len >= MG_MAX_RECV_SIZE) {
+      mg_error(c, "max_recv_buf_size reached");
+    } else if (c->recv.size - c->recv.len < pkt->pay.len &&
+               !mg_iobuf_resize(&c->recv, c->recv.len + pkt->pay.len)) {
+      mg_error(c, "oom");
+    } else {
+      memcpy(&c->recv.buf[c->recv.len], pkt->pay.buf, pkt->pay.len);
+      c->recv.len += pkt->pay.len;
+      struct mg_str evd = mg_str_n((char *) pkt->pay.buf, pkt->pay.len);
+      mg_call(c, MG_EV_READ, &evd);
+    }
+  }
+}
+
+struct tcpstate {
+  uint32_t seq, ack;
+  time_t expire;
+};
+
+static size_t tx_tcp(struct mip_if *ifp, uint32_t dst_ip, uint8_t flags,
+                     uint16_t sport, uint16_t dport, uint32_t seq, uint32_t ack,
+                     const void *buf, size_t len) {
+  struct ip *ip = tx_ip(ifp, 6, ifp->ip, dst_ip, sizeof(struct tcp) + len);
+  struct tcp *tcp = (struct tcp *) (ip + 1);
+  memset(tcp, 0, sizeof(*tcp));
+  memmove(tcp + 1, buf, len);
+  tcp->sport = sport;
+  tcp->dport = dport;
+  tcp->seq = seq;
+  tcp->ack = ack;
+  tcp->flags = flags;
+  tcp->win = mg_htons(8192);
+  tcp->off = (uint8_t) (sizeof(*tcp) / 4 << 4);
+  uint32_t cs = 0;
+  uint16_t n = (uint16_t) (sizeof(*tcp) + len);
+  uint8_t pseudo[] = {0, ip->proto, (uint8_t) (n >> 8), (uint8_t) (n & 255)};
+  cs = csumup(cs, tcp, n);
+  cs = csumup(cs, &ip->src, sizeof(ip->src));
+  cs = csumup(cs, &ip->dst, sizeof(ip->dst));
+  cs = csumup(cs, pseudo, sizeof(pseudo));
+  tcp->csum = csumfin(cs);
+  return ifp->driver->tx(ifp->tx.buf, PDIFF(ifp->tx.buf, tcp + 1) + len,
+                         ifp->driver->data);
+}
+
+static size_t tx_tcp_pkt(struct mip_if *ifp, struct pkt *pkt, uint8_t flags,
+                         uint32_t seq, const void *buf, size_t len) {
+  uint32_t delta = (pkt->tcp->flags & (TH_SYN | TH_FIN)) ? 1 : 0;
+  return tx_tcp(ifp, pkt->ip->src, flags, pkt->tcp->dport, pkt->tcp->sport, seq,
+                mg_htonl(mg_ntohl(pkt->tcp->seq) + delta), buf, len);
+}
+
+static struct mg_connection *accept_conn(struct mg_connection *lsn,
+                                         struct pkt *pkt) {
+  struct mg_connection *c = mg_alloc_conn(lsn->mgr);
+  struct tcpstate *s = (struct tcpstate *) (c + 1);
+  s->seq = mg_ntohl(pkt->tcp->ack), s->ack = mg_ntohl(pkt->tcp->seq);
+  c->rem.ip = pkt->ip->src;
+  c->rem.port = pkt->tcp->sport;
+  MG_DEBUG(("%lu accepted %lx:%hx", c->id, c->rem.ip, c->rem.port));
+  LIST_ADD_HEAD(struct mg_connection, &lsn->mgr->conns, c);
+  c->fd = (void *) (size_t) mg_ntohl(pkt->tcp->ack);
+  c->is_accepted = 1;
+  c->is_hexdumping = lsn->is_hexdumping;
+  c->pfn = lsn->pfn;
+  c->loc = lsn->loc;
+  c->pfn_data = lsn->pfn_data;
+  c->fn = lsn->fn;
+  c->fn_data = lsn->fn_data;
+  mg_call(c, MG_EV_OPEN, NULL);
+  mg_call(c, MG_EV_ACCEPT, NULL);
+  return c;
+}
+
+static void read_conn(struct mg_connection *c, struct pkt *pkt) {
+  struct tcpstate *s = (struct tcpstate *) (c + 1);
+  if (pkt->tcp->flags & TH_FIN) {
+    s->ack = mg_htonl(pkt->tcp->seq) + 1, s->seq = mg_htonl(pkt->tcp->ack);
+    c->is_closing = 1;
+  } else if (pkt->pay.len == 0) {
+  } else if (c->recv.size - c->recv.len < pkt->pay.len &&
+             !mg_iobuf_resize(&c->recv, c->recv.len + pkt->pay.len)) {
+    mg_error(c, "oom");
+  } else if (mg_ntohl(pkt->tcp->seq) != s->ack) {
+    mg_error(c, "oob: %x %x", mg_ntohl(pkt->tcp->seq), s->ack);
+  } else {
+    s->ack = (uint32_t) (mg_htonl(pkt->tcp->seq) + pkt->pay.len);
+    memcpy(&c->recv.buf[c->recv.len], pkt->pay.buf, pkt->pay.len);
+    c->recv.len += pkt->pay.len;
+    struct mg_str evd = mg_str_n((char *) pkt->pay.buf, pkt->pay.len);
+    mg_call(c, MG_EV_READ, &evd);
+#if 0
+    // Send ACK immediately
+    tx_tcp(ifp, c->rem.ip, TH_ACK, c->loc.port, c->rem.port, mg_htonl(s->seq),
+           mg_htonl(s->ack), NULL, 0);
+#endif
+  }
+}
+
+static void rx_tcp(struct mip_if *ifp, struct pkt *pkt) {
+  struct mg_connection *c = getpeer(ifp->mgr, pkt, false);
+#if 0
+  MG_INFO(("%lu %hhu %d", c ? c->id : 0, pkt->tcp->flags, (int) pkt->pay.len));
+#endif
+  if (c != NULL) {
+#if 0
+     MG_DEBUG(("%lu %d %lx:%hx -> %lx:%hx", c->id, (int) pkt->raw.len,
+             pkt->ip->src, pkt->tcp->sport, pkt->ip->dst, pkt->tcp->dport));
+     hexdump(pkt->pay.buf, pkt->pay.len);
+#endif
+    read_conn(c, pkt);
+  } else if ((c = getpeer(ifp->mgr, pkt, true)) == NULL) {
+    tx_tcp_pkt(ifp, pkt, TH_RST | TH_ACK, pkt->tcp->ack, NULL, 0);
+  } else if (pkt->tcp->flags & TH_SYN) {
+    // Use peer's source port as ISN, in order to recognise the handshake
+    uint32_t isn = mg_htonl((uint32_t) mg_ntohs(pkt->tcp->sport));
+    tx_tcp_pkt(ifp, pkt, TH_SYN | TH_ACK, isn, NULL, 0);
+  } else if (pkt->tcp->flags & TH_FIN) {
+    tx_tcp_pkt(ifp, pkt, TH_FIN | TH_ACK, pkt->tcp->ack, NULL, 0);
+  } else if (mg_htonl(pkt->tcp->ack) == mg_htons(pkt->tcp->sport) + 1U) {
+    accept_conn(c, pkt);
+  } else {
+    // MG_DEBUG(("dropped silently.."));
+  }
+}
+
+static void rx_ip(struct mip_if *ifp, struct pkt *pkt) {
+  // MG_DEBUG(("IP %d", (int) pkt->pay.len));
+  if (pkt->ip->proto == 1) {
+    pkt->icmp = (struct icmp *) (pkt->ip + 1);
+    if (pkt->pay.len < sizeof(*pkt->icmp)) return;
+    mkpay(pkt, pkt->icmp + 1);
+    rx_icmp(ifp, pkt);
+  } else if (pkt->ip->proto == 17) {
+    pkt->udp = (struct udp *) (pkt->ip + 1);
+    if (pkt->pay.len < sizeof(*pkt->udp)) return;
+    // MG_DEBUG(("  UDP %u %u -> %u\n", len, NET16(udp->sport),
+    // NET16(udp->dport)));
+    mkpay(pkt, pkt->udp + 1);
+    if (pkt->udp->dport == NET16(68)) {
+      pkt->dhcp = (struct dhcp *) (pkt->udp + 1);
+      mkpay(pkt, pkt->dhcp + 1);
+      rx_dhcp(ifp, pkt);
+    } else {
+      rx_udp(ifp, pkt);
+    }
+  } else if (pkt->ip->proto == 6) {
+    pkt->tcp = (struct tcp *) (pkt->ip + 1);
+    if (pkt->pay.len < sizeof(*pkt->tcp)) return;
+    mkpay(pkt, pkt->tcp + 1);
+    uint16_t iplen = mg_ntohs(pkt->ip->len);
+    uint16_t off = (uint16_t) (sizeof(*pkt->ip) + ((pkt->tcp->off >> 4) * 4U));
+    if (iplen >= off) pkt->pay.len = (size_t) (iplen - off);
+    rx_tcp(ifp, pkt);
+  }
+}
+
+static void rx_ip6(struct mip_if *ifp, struct pkt *pkt) {
+  // MG_DEBUG(("IP %d\n", (int) len));
+  if (pkt->ip6->proto == 1 || pkt->ip6->proto == 58) {
+    pkt->icmp = (struct icmp *) (pkt->ip6 + 1);
+    if (pkt->pay.len < sizeof(*pkt->icmp)) return;
+    mkpay(pkt, pkt->icmp + 1);
+    rx_icmp(ifp, pkt);
+  } else if (pkt->ip->proto == 17) {
+    pkt->udp = (struct udp *) (pkt->ip6 + 1);
+    if (pkt->pay.len < sizeof(*pkt->udp)) return;
+    // MG_DEBUG(("  UDP %u %u -> %u\n", len, NET16(udp->sport),
+    // NET16(udp->dport)));
+    mkpay(pkt, pkt->udp + 1);
+  }
+}
+
+static void mip_rx(struct mip_if *ifp, void *buf, size_t len) {
+  const uint8_t broadcast[] = {255, 255, 255, 255, 255, 255};
+  struct pkt pkt = {.raw = {.buf = (uint8_t *) buf, .len = len}};
+  pkt.eth = (struct eth *) buf;
+  if (pkt.raw.len < sizeof(*pkt.eth)) return;  // Truncated - runt?
+  if (memcmp(pkt.eth->dst, ifp->mac, sizeof(pkt.eth->dst)) != 0 &&
+      memcmp(pkt.eth->dst, broadcast, sizeof(pkt.eth->dst)) != 0) {
+    // Not for us. Drop silently
+  } else if (pkt.eth->type == NET16(0x806)) {
+    pkt.arp = (struct arp *) (pkt.eth + 1);
+    if (sizeof(*pkt.eth) + sizeof(*pkt.arp) > pkt.raw.len) return;  // Truncated
+    rx_arp(ifp, &pkt);
+  } else if (pkt.eth->type == NET16(0x86dd)) {
+    pkt.ip6 = (struct ip6 *) (pkt.eth + 1);
+    if (pkt.raw.len < sizeof(*pkt.eth) + sizeof(*pkt.ip6)) return;  // Truncated
+    if ((pkt.ip6->ver >> 4) != 0x6) return;                         // Not IP
+    mkpay(&pkt, pkt.ip6 + 1);
+    rx_ip6(ifp, &pkt);
+  } else if (pkt.eth->type == NET16(0x800)) {
+    pkt.ip = (struct ip *) (pkt.eth + 1);
+    if (pkt.raw.len < sizeof(*pkt.eth) + sizeof(*pkt.ip)) return;  // Truncated
+    if ((pkt.ip->ver >> 4) != 4) return;                           // Not IP
+    mkpay(&pkt, pkt.ip + 1);
+    rx_ip(ifp, &pkt);
+  } else {
+    MG_DEBUG(("  Unknown eth type %x\n", NET16(pkt.eth->type)));
+  }
+}
+
+static void mip_poll(struct mip_if *ifp, uint64_t uptime_ms) {
+  ifp->curtime = uptime_ms;
+
+  if (ifp->ip == 0 && uptime_ms > ifp->timer) {
+    tx_dhcp_discover(ifp);          // If IP not configured, send DHCP
+    ifp->timer = uptime_ms + 1000;  // with some interval
+  } else if (ifp->use_dhcp == false && uptime_ms > ifp->timer &&
+             arp_cache_find(ifp, ifp->gw) == NULL) {
+    arp_ask(ifp, ifp->gw);          // If GW's MAC address in not in ARP cache
+    ifp->timer = uptime_ms + 1000;  // send ARP who-has request
+  }
+
+  // Handle physical interface up/down status
+  if (ifp->driver->status) {
+    bool up = ifp->driver->status(ifp->driver->data);
+    bool current = ifp->state != MIP_STATE_DOWN;
+    if (up != current) {
+      ifp->state = up == false     ? MIP_STATE_DOWN
+                   : ifp->use_dhcp ? MIP_STATE_UP
+                                   : MIP_STATE_READY;
+      if (!up && ifp->use_dhcp) ifp->ip = 0;
+      onstatechange(ifp);
+    }
+  }
+
+  // Read data from the network
+  for (;;) {
+    size_t len = ifp->queue.len > 0 ? q_read(&ifp->queue, ifp->rx.buf)
+                                    : ifp->driver->rx(ifp->rx.buf, ifp->rx.len,
+                                                      ifp->driver->data);
+    if (len == 0) break;
+    mip_rx(ifp, ifp->rx.buf, len);
+  }
+}
+
+// This function executes in interrupt context, thus it should copy data
+// somewhere fast. Note that newlib's malloc is not thread safe, thus use
+// our lock-free queue with preallocated buffer to copy data and return asap
+static void on_rx(void *buf, size_t len, void *userdata) {
+  struct mip_if *ifp = (struct mip_if *) userdata;
+  if (!q_write(&ifp->queue, buf, len)) MG_ERROR(("dropped %d", (int) len));
+}
+
+void mip_init(struct mg_mgr *mgr, struct mip_ipcfg *ipcfg,
+              struct mip_driver *driver) {
+  size_t maxpktsize = 1500, qlen = driver->rxcb ? 1024 * 16 : 0;
+  struct mip_if *ifp =
+      (struct mip_if *) calloc(1, sizeof(*ifp) + 2 * maxpktsize + qlen);
+  memcpy(ifp->mac, ipcfg->mac, sizeof(ifp->mac));
+  ifp->use_dhcp = ipcfg->ip == 0;
+  ifp->ip = ipcfg->ip, ifp->mask = ipcfg->mask, ifp->gw = ipcfg->gw;
+  ifp->rx.buf = (uint8_t *) (ifp + 1), ifp->rx.len = maxpktsize;
+  ifp->tx.buf = ifp->rx.buf + maxpktsize, ifp->tx.len = maxpktsize;
+  ifp->driver = driver;
+  ifp->mgr = mgr;
+  ifp->queue.buf = ifp->tx.buf + maxpktsize;
+  ifp->queue.len = qlen;
+  if (driver->init) driver->init(driver->data);
+  if (driver->rxcb) driver->rxcb(on_rx, ifp);
+  mgr->priv = ifp;
+  mgr->extraconnsize = sizeof(struct tcpstate);
+}
+
+int mg_mkpipe(struct mg_mgr *m, mg_event_handler_t fn, void *d, bool udp) {
+  (void) m, (void) fn, (void) d, (void) udp;
+  MG_ERROR(("Not implemented"));
+  return -1;
+}
+
+void mg_connect_resolved(struct mg_connection *c) {
+  struct mip_if *ifp = (struct mip_if *) c->mgr->priv;
+  if (ifp->eport < MIP_ETHEMERAL_PORT) ifp->eport = MIP_ETHEMERAL_PORT;
+  if (c->is_udp) {
+    c->loc.ip = ifp->ip;
+    c->loc.port = mg_htons(ifp->eport++);
+    MG_DEBUG(("%lu %08lx.%hu->%08lx.%hu", c->id, mg_ntohl(c->loc.ip),
+              mg_ntohs(c->loc.port), mg_ntohl(c->rem.ip),
+              mg_ntohs(c->rem.port)));
+    mg_call(c, MG_EV_RESOLVE, NULL);
+    mg_call(c, MG_EV_CONNECT, NULL);
+  } else {
+    mg_error(c, "Not implemented");
+  }
+  c->is_resolving = 0;
+}
+
+bool mg_open_listener(struct mg_connection *c, const char *url) {
+  c->loc.port = mg_htons(mg_url_port(url));
+  return true;
+}
+
+static void write_conn(struct mg_connection *c) {
+  struct mip_if *ifp = (struct mip_if *) c->mgr->priv;
+  struct tcpstate *s = (struct tcpstate *) (c + 1);
+  size_t sent, n = c->send.len, hdrlen = 14 + 24 /*max IP*/ + 60 /*max TCP*/;
+  if (n + hdrlen > ifp->tx.len) n = ifp->tx.len - hdrlen;
+  sent = tx_tcp(ifp, c->rem.ip, TH_PUSH | TH_ACK, c->loc.port, c->rem.port,
+                mg_htonl(s->seq), mg_htonl(s->ack), c->send.buf, n);
+  if (sent > 0) {
+    mg_iobuf_del(&c->send, 0, n);
+    s->seq += (uint32_t) n;
+    mg_call(c, MG_EV_WRITE, &n);
+  }
+}
+
+static void fin_conn(struct mg_connection *c) {
+  struct mip_if *ifp = (struct mip_if *) c->mgr->priv;
+  struct tcpstate *s = (struct tcpstate *) (c + 1);
+  tx_tcp(ifp, c->rem.ip, TH_FIN | TH_ACK, c->loc.port, c->rem.port,
+         mg_htonl(s->seq), mg_htonl(s->ack), NULL, 0);
+}
+
+void mg_mgr_poll(struct mg_mgr *mgr, int ms) {
+  struct mg_connection *c, *tmp;
+  uint64_t now = mg_millis();
+  mip_poll((struct mip_if *) mgr->priv, now);
+  mg_timer_poll(&mgr->timers, now);
+  for (c = mgr->conns; c != NULL; c = tmp) {
+    tmp = c->next;
+    if (c->send.len > 0) write_conn(c);
+    if (c->is_draining && c->send.len == 0) c->is_closing = 1;
+    if (c->is_closing) {
+      if (c->is_udp == false && c->is_listening == false) fin_conn(c);
+      mg_close_conn(c);
+    }
+  }
+  (void) ms;
+}
+
+bool mg_send(struct mg_connection *c, const void *buf, size_t len) {
+  struct mip_if *ifp = (struct mip_if *) c->mgr->priv;
+  bool res = false;
+  if (ifp->ip == 0) {
+    mg_error(c, "net down");
+  } else if (c->is_udp) {
+    tx_udp(ifp, ifp->ip, c->loc.port, c->rem.ip, c->rem.port, buf, len);
+    res = true;
+  } else {
+    // tx_tdp(ifp, ifp->ip, c->loc.port, c->rem.ip, c->rem.port, buf, len);
+    return mg_iobuf_add(&c->send, c->send.len, buf, len, MG_IO_SIZE);
+  }
+  return res;
+}
+#endif  // MG_ENABLE_MIP
diff --git a/mongoose-server/mongoose.h b/mongoose-server/mongoose.h
new file mode 100644
index 0000000..056c69f
--- /dev/null
+++ b/mongoose-server/mongoose.h
@@ -0,0 +1,1383 @@
+// Copyright (c) 2004-2013 Sergey Lyubka
+// Copyright (c) 2013-2022 Cesanta Software Limited
+// All rights reserved
+//
+// This software is dual-licensed: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License version 2 as
+// published by the Free Software Foundation. For the terms of this
+// license, see http://www.gnu.org/licenses/
+//
+// You are free to use this software under the terms of the GNU General
+// Public License, but WITHOUT ANY WARRANTY; without even the implied
+// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+//
+// Alternatively, you can license this software under a commercial
+// license, as set out in https://www.mongoose.ws/licensing/
+//
+// SPDX-License-Identifier: GPL-2.0 or commercial
+
+#ifndef MONGOOSE_H
+#define MONGOOSE_H
+
+#define MG_VERSION "7.7"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define MG_ARCH_CUSTOM 0
+#define MG_ARCH_UNIX 1
+#define MG_ARCH_WIN32 2
+#define MG_ARCH_ESP32 3
+#define MG_ARCH_ESP8266 4
+#define MG_ARCH_FREERTOS_TCP 5
+#define MG_ARCH_FREERTOS_LWIP 6
+#define MG_ARCH_AZURERTOS 7
+#define MG_ARCH_RTX_LWIP 8
+#define MG_ARCH_ZEPHYR 9
+#define MG_ARCH_NEWLIB 10
+#define MG_ARCH_RTX 11
+#define MG_ARCH_TIRTOS 12
+#define MG_ARCH_RP2040 13
+
+#if !defined(MG_ARCH)
+#if defined(__unix__) || defined(__APPLE__)
+#define MG_ARCH MG_ARCH_UNIX
+#elif defined(_WIN32)
+#define MG_ARCH MG_ARCH_WIN32
+#elif defined(ICACHE_FLASH) || defined(ICACHE_RAM_ATTR)
+#define MG_ARCH MG_ARCH_ESP8266
+#elif defined(ESP_PLATFORM)
+#define MG_ARCH MG_ARCH_ESP32
+#elif defined(FREERTOS_IP_H)
+#define MG_ARCH MG_ARCH_FREERTOS_TCP
+#elif defined(AZURE_RTOS_THREADX)
+#define MG_ARCH MG_ARCH_AZURERTOS
+#elif defined(__ZEPHYR__)
+#define MG_ARCH MG_ARCH_ZEPHYR
+#elif defined(PICO_TARGET_NAME)
+#define MG_ARCH MG_ARCH_RP2040
+#endif
+
+#if !defined(MG_ARCH)
+#error "MG_ARCH is not specified and we couldn't guess it. Set -D MG_ARCH=..."
+#endif
+#endif  // !defined(MG_ARCH)
+
+#if MG_ARCH == MG_ARCH_CUSTOM
+#include <mongoose_custom.h>
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+#if MG_ARCH == MG_ARCH_AZURERTOS
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <time.h>
+
+#include <fx_api.h>
+#include <tx_api.h>
+
+#include <nx_api.h>
+#include <nx_bsd.h>
+#include <nx_port.h>
+#include <tx_port.h>
+
+#ifdef __REDLIB__
+#define va_copy(d, s) __builtin_va_copy(d, s)
+#endif
+
+#define PATH_MAX FX_MAXIMUM_PATH
+#define MG_DIRSEP '\\'
+
+#define socklen_t int
+#define closesocket(x) soc_close(x)
+
+#undef FOPEN_MAX
+
+#endif
+
+
+#if MG_ARCH == MG_ARCH_ESP32
+
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <netdb.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+
+#include <esp_timer.h>
+
+#define MG_PATH_MAX 128
+
+#endif
+
+
+#if MG_ARCH == MG_ARCH_ESP8266
+
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <netdb.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+
+#include <esp_system.h>
+
+#define MG_PATH_MAX 128
+
+#endif
+
+
+#if MG_ARCH == MG_ARCH_FREERTOS_LWIP
+
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#if defined(__GNUC__)
+#include <sys/stat.h>
+#include <sys/time.h>
+#else
+struct timeval {
+  time_t tv_sec;
+  long tv_usec;
+};
+#endif
+
+#include <FreeRTOS.h>
+#include <task.h>
+
+#include <lwip/sockets.h>
+
+#if LWIP_SOCKET != 1
+// Sockets support disabled in LWIP by default
+#error Set LWIP_SOCKET variable to 1 (in lwipopts.h)
+#endif
+
+// Re-route calloc/free to the FreeRTOS's functions, don't use stdlib
+static inline void *mg_calloc(int cnt, size_t size) {
+  void *p = pvPortMalloc(cnt * size);
+  if (p != NULL) memset(p, 0, size * cnt);
+  return p;
+}
+#define calloc(a, b) mg_calloc((a), (b))
+#define free(a) vPortFree(a)
+#define malloc(a) pvPortMalloc(a)
+
+#define mkdir(a, b) (-1)
+
+#ifndef MG_IO_SIZE
+#define MG_IO_SIZE 512
+#endif
+
+#ifndef MG_PATH_MAX
+#define MG_PATH_MAX 128
+#endif
+
+#endif  // MG_ARCH == MG_ARCH_FREERTOS_LWIP
+
+
+#if MG_ARCH == MG_ARCH_FREERTOS_TCP
+
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <time.h>
+
+#include <FreeRTOS.h>
+#include <FreeRTOS_IP.h>
+#include <FreeRTOS_Sockets.h>
+#include <task.h>
+
+// Why FreeRTOS-TCP did not implement a clean BSD API, but its own thing
+// with FreeRTOS_ prefix, is beyond me
+#define IPPROTO_TCP FREERTOS_IPPROTO_TCP
+#define IPPROTO_UDP FREERTOS_IPPROTO_UDP
+#define AF_INET FREERTOS_AF_INET
+#define SOCK_STREAM FREERTOS_SOCK_STREAM
+#define SOCK_DGRAM FREERTOS_SOCK_DGRAM
+#define SO_BROADCAST 0
+#define SO_ERROR 0
+#define SOL_SOCKET 0
+#define SO_REUSEADDR 0
+#define sockaddr_in freertos_sockaddr
+#define sockaddr freertos_sockaddr
+#define accept(a, b, c) FreeRTOS_accept((a), (b), (c))
+#define connect(a, b, c) FreeRTOS_connect((a), (b), (c))
+#define bind(a, b, c) FreeRTOS_bind((a), (b), (c))
+#define listen(a, b) FreeRTOS_listen((a), (b))
+#define socket(a, b, c) FreeRTOS_socket((a), (b), (c))
+#define send(a, b, c, d) FreeRTOS_send((a), (b), (c), (d))
+#define recv(a, b, c, d) FreeRTOS_recv((a), (b), (c), (d))
+#define setsockopt(a, b, c, d, e) FreeRTOS_setsockopt((a), (b), (c), (d), (e))
+#define sendto(a, b, c, d, e, f) FreeRTOS_sendto((a), (b), (c), (d), (e), (f))
+#define recvfrom(a, b, c, d, e, f) \
+  FreeRTOS_recvfrom((a), (b), (c), (d), (e), (f))
+#define closesocket(x) FreeRTOS_closesocket(x)
+#define gethostbyname(x) FreeRTOS_gethostbyname(x)
+#define getsockname(a, b, c) (-1)
+#define getpeername(a, b, c) 0
+
+// Re-route calloc/free to the FreeRTOS's functions, don't use stdlib
+static inline void *mg_calloc(int cnt, size_t size) {
+  void *p = pvPortMalloc(cnt * size);
+  if (p != NULL) memset(p, 0, size * cnt);
+  return p;
+}
+#define calloc(a, b) mg_calloc((a), (b))
+#define free(a) vPortFree(a)
+#define malloc(a) pvPortMalloc(a)
+#define mkdir(a, b) (-1)
+
+#if !defined(__GNUC__)
+// copied from GCC on ARM; for some reason useconds are signed
+struct timeval {
+  time_t tv_sec;
+  long tv_usec;
+};
+#endif
+
+#ifndef EINPROGRESS
+#define EINPROGRESS pdFREERTOS_ERRNO_EINPROGRESS
+#endif
+#ifndef EWOULDBLOCK
+#define EWOULDBLOCK pdFREERTOS_ERRNO_EWOULDBLOCK
+#endif
+#ifndef EAGAIN
+#define EAGAIN pdFREERTOS_ERRNO_EAGAIN
+#endif
+#ifndef EINTR
+#define EINTR pdFREERTOS_ERRNO_EINTR
+#endif
+
+#endif  // MG_ARCH == MG_ARCH_FREERTOS_TCP
+
+
+#if MG_ARCH == MG_ARCH_NEWLIB
+#define _POSIX_TIMERS
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+#define MG_PATH_MAX 100
+#define MG_ENABLE_SOCKET 0
+#define MG_ENABLE_DIRLIST 0
+
+#endif
+
+
+#if MG_ARCH == MG_ARCH_RP2040
+#include <errno.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <pico/stdlib.h>
+int mkdir(const char *, mode_t);
+#endif
+
+
+#if MG_ARCH == MG_ARCH_RTX
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <rl_net.h>
+
+#define MG_ENABLE_CUSTOM_MILLIS 1
+typedef int socklen_t;
+#define closesocket(x) closesocket(x)
+#define mkdir(a, b) (-1)
+#define EWOULDBLOCK BSD_EWOULDBLOCK
+#define EAGAIN BSD_EWOULDBLOCK
+#define EINPROGRESS BSD_EWOULDBLOCK
+#define EINTR BSD_EWOULDBLOCK
+#define ECONNRESET BSD_ECONNRESET
+#define EPIPE BSD_ECONNRESET
+#define TCP_NODELAY SO_KEEPALIVE
+
+#endif
+
+
+#if MG_ARCH == MG_ARCH_RTX_LWIP
+
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#if defined(__GNUC__)
+#include <sys/stat.h>
+#include <sys/time.h>
+#else
+struct timeval {
+  time_t tv_sec;
+  long tv_usec;
+};
+#endif
+
+#include <lwip/sockets.h>
+
+#if LWIP_SOCKET != 1
+// Sockets support disabled in LWIP by default
+#error Set LWIP_SOCKET variable to 1 (in lwipopts.h)
+#endif
+
+#define mkdir(a, b) (-1)
+
+#ifndef MG_IO_SIZE
+#define MG_IO_SIZE 512
+#endif
+
+#ifndef MG_PATH_MAX
+#define MG_PATH_MAX 128
+#endif
+
+
+#endif
+
+
+#if MG_ARCH == MG_ARCH_TIRTOS
+
+#include <stdlib.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <time.h>
+#include <errno.h>
+
+#include <sys/socket.h>
+
+extern int SockStatus(SOCKET hSock, int request, int *results );
+extern int SockSet(SOCKET hSock, int Type, int Prop, void *pbuf, int size);
+
+#endif
+
+
+#if MG_ARCH == MG_ARCH_UNIX
+
+#define _DARWIN_UNLIMITED_SELECT 1  // No limit on file descriptors
+
+#if defined(__APPLE__)
+#include <mach/mach_time.h>
+#endif
+
+#if !defined(MG_ENABLE_POLL) && (defined(__linux__) || defined(__APPLE__))
+#define MG_ENABLE_POLL 1
+#endif
+
+#include <arpa/inet.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined(MG_ENABLE_POLL) && MG_ENABLE_POLL
+#include <poll.h>
+#else
+#include <sys/select.h>
+#endif
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+#ifndef MG_ENABLE_DIRLIST
+#define MG_ENABLE_DIRLIST 1
+#endif
+
+#endif
+
+
+#if MG_ARCH == MG_ARCH_WIN32
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#ifndef _CRT_SECURE_NO_WARNINGS
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#ifndef _WINSOCK_DEPRECATED_NO_WARNINGS
+#define _WINSOCK_DEPRECATED_NO_WARNINGS
+#endif
+
+#include <ctype.h>
+#include <direct.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+
+#if defined(_MSC_VER) && _MSC_VER < 1700
+#define __func__ ""
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+typedef unsigned char uint8_t;
+typedef char int8_t;
+typedef unsigned short uint16_t;
+typedef short int16_t;
+typedef unsigned int uint32_t;
+typedef int int32_t;
+typedef enum { false = 0, true = 1 } bool;
+#else
+#include <stdbool.h>
+#include <stdint.h>
+#include <ws2tcpip.h>
+#endif
+
+#include <process.h>
+#include <winerror.h>
+#include <winsock2.h>
+
+// Protect from calls like std::snprintf in app code
+// See https://github.com/cesanta/mongoose/issues/1047
+#ifndef __cplusplus
+#define snprintf _snprintf
+#define vsnprintf _vsnprintf
+#ifndef strdup  // For MSVC with _DEBUG, see #1359
+#define strdup(x) _strdup(x)
+#endif
+#endif
+
+typedef int socklen_t;
+#define MG_DIRSEP '\\'
+#ifndef PATH_MAX
+#define PATH_MAX MAX_PATH
+#endif
+#ifndef EINPROGRESS
+#define EINPROGRESS WSAEINPROGRESS
+#endif
+#ifndef EWOULDBLOCK
+#define EWOULDBLOCK WSAEWOULDBLOCK
+#endif
+
+#define realpath(a, b) _fullpath((b), (a), MG_PATH_MAX)
+#define sleep(x) Sleep(x)
+#define mkdir(a, b) _mkdir(a)
+
+#ifndef va_copy
+#ifdef __va_copy
+#define va_copy __va_copy
+#else
+#define va_copy(x, y) (x) = (y)
+#endif
+#endif
+#ifndef S_ISDIR
+#define S_ISDIR(x) (((x) &_S_IFMT) == _S_IFDIR)
+#endif
+
+#ifndef MG_ENABLE_DIRLIST
+#define MG_ENABLE_DIRLIST 1
+#endif
+
+#endif
+
+
+#if MG_ARCH == MG_ARCH_ZEPHYR
+
+#include <zephyr.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <net/socket.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <time.h>
+
+#define MG_PUTCHAR(x) printk("%c", x)
+#define strerror(x) zsock_gai_strerror(x)
+#define FD_CLOEXEC 0
+#define F_SETFD 0
+#define MG_ENABLE_SSI 0
+
+int rand(void);
+int sscanf(const char *, const char *, ...);
+
+#endif
+
+
+#ifndef MG_ENABLE_LOG
+#define MG_ENABLE_LOG 1
+#endif
+
+#ifndef MG_ENABLE_MIP
+#define MG_ENABLE_MIP 0
+#endif
+
+#ifndef MG_ENABLE_POLL
+#define MG_ENABLE_POLL 0
+#endif
+
+#ifndef MG_ENABLE_FATFS
+#define MG_ENABLE_FATFS 0
+#endif
+
+#ifndef MG_ENABLE_SOCKET
+#define MG_ENABLE_SOCKET 1
+#endif
+
+#ifndef MG_ENABLE_MBEDTLS
+#define MG_ENABLE_MBEDTLS 0
+#endif
+
+#ifndef MG_ENABLE_OPENSSL
+#define MG_ENABLE_OPENSSL 0
+#endif
+
+#ifndef MG_ENABLE_CUSTOM_TLS
+#define MG_ENABLE_CUSTOM_TLS 0
+#endif
+
+#ifndef MG_ENABLE_SSI
+#define MG_ENABLE_SSI 0
+#endif
+
+#ifndef MG_ENABLE_IPV6
+#define MG_ENABLE_IPV6 0
+#endif
+
+#ifndef MG_ENABLE_MD5
+#define MG_ENABLE_MD5 0
+#endif
+
+// Set MG_ENABLE_WINSOCK=0 for Win32 builds with external IP stack (like LWIP)
+#ifndef MG_ENABLE_WINSOCK
+#define MG_ENABLE_WINSOCK 1
+#endif
+
+#ifndef MG_ENABLE_DIRLIST
+#define MG_ENABLE_DIRLIST 0
+#endif
+
+#ifndef MG_ENABLE_CUSTOM_RANDOM
+#define MG_ENABLE_CUSTOM_RANDOM 0
+#endif
+
+#ifndef MG_ENABLE_CUSTOM_MILLIS
+#define MG_ENABLE_CUSTOM_MILLIS 0
+#endif
+
+#ifndef MG_ENABLE_PACKED_FS
+#define MG_ENABLE_PACKED_FS 0
+#endif
+
+// Granularity of the send/recv IO buffer growth
+#ifndef MG_IO_SIZE
+#define MG_IO_SIZE 2048
+#endif
+
+// Maximum size of the recv IO buffer
+#ifndef MG_MAX_RECV_SIZE
+#define MG_MAX_RECV_SIZE (3 * 1024 * 1024)
+#endif
+
+#ifndef MG_MAX_HTTP_HEADERS
+#define MG_MAX_HTTP_HEADERS 40
+#endif
+
+#ifndef MG_HTTP_INDEX
+#define MG_HTTP_INDEX "index.html"
+#endif
+
+#ifndef MG_PATH_MAX
+#ifdef PATH_MAX
+#define MG_PATH_MAX PATH_MAX
+#else
+#define MG_PATH_MAX 128
+#endif
+#endif
+
+#ifndef MG_SOCK_LISTEN_BACKLOG_SIZE
+#define MG_SOCK_LISTEN_BACKLOG_SIZE 3
+#endif
+
+#ifndef MG_DIRSEP
+#define MG_DIRSEP '/'
+#endif
+
+#ifndef MG_ENABLE_FILE
+#if defined(FOPEN_MAX)
+#define MG_ENABLE_FILE 1
+#else
+#define MG_ENABLE_FILE 0
+#endif
+#endif
+
+
+
+
+struct mg_str {
+  const char *ptr;  // Pointer to string data
+  size_t len;       // String len
+};
+
+#define MG_NULL_STR \
+  { NULL, 0 }
+
+#define MG_C_STR(a) \
+  { (a), sizeof(a) - 1 }
+
+// Using macro to avoid shadowing C++ struct constructor, see #1298
+#define mg_str(s) mg_str_s(s)
+
+struct mg_str mg_str(const char *s);
+struct mg_str mg_str_n(const char *s, size_t n);
+int mg_lower(const char *s);
+int mg_ncasecmp(const char *s1, const char *s2, size_t len);
+int mg_casecmp(const char *s1, const char *s2);
+int mg_vcmp(const struct mg_str *s1, const char *s2);
+int mg_vcasecmp(const struct mg_str *str1, const char *str2);
+int mg_strcmp(const struct mg_str str1, const struct mg_str str2);
+struct mg_str mg_strstrip(struct mg_str s);
+struct mg_str mg_strdup(const struct mg_str s);
+const char *mg_strstr(const struct mg_str haystack, const struct mg_str needle);
+bool mg_match(struct mg_str str, struct mg_str pattern, struct mg_str *caps);
+bool mg_globmatch(const char *pattern, size_t plen, const char *s, size_t n);
+bool mg_commalist(struct mg_str *s, struct mg_str *k, struct mg_str *v);
+bool mg_split(struct mg_str *s, struct mg_str *k, struct mg_str *v, char delim);
+char *mg_hex(const void *buf, size_t len, char *dst);
+void mg_unhex(const char *buf, size_t len, unsigned char *to);
+unsigned long mg_unhexn(const char *s, size_t len);
+int mg_check_ip_acl(struct mg_str acl, uint32_t remote_ip);
+int64_t mg_to64(struct mg_str str);
+uint64_t mg_tou64(struct mg_str str);
+size_t mg_lld(char *buf, int64_t val, bool is_signed, bool is_hex);
+double mg_atod(const char *buf, int len, int *numlen);
+size_t mg_dtoa(char *buf, size_t len, double d, int width);
+char *mg_remove_double_dots(char *s);
+
+typedef void (*mg_pc_t)(char, void *);                  // Custom putchar
+typedef size_t (*mg_pm_t)(mg_pc_t, void *, va_list *);  // %M printer
+void mg_putchar_realloc(char ch, void *param);          // Print to malloced str
+void mg_putchar_iobuf(char ch, void *param);            // Print to iobuf
+
+size_t mg_vrprintf(void (*)(char, void *), void *, const char *fmt, va_list *);
+size_t mg_rprintf(void (*fn)(char, void *), void *, const char *fmt, ...);
+size_t mg_vsnprintf(char *buf, size_t len, const char *fmt, va_list *ap);
+size_t mg_snprintf(char *, size_t, const char *fmt, ...);
+size_t mg_asprintf(char **, size_t, const char *fmt, ...);
+size_t mg_vasprintf(char **buf, size_t size, const char *fmt, va_list ap);
+char *mg_mprintf(const char *fmt, ...);
+char *mg_vmprintf(const char *fmt, va_list ap);
+
+
+
+
+
+enum { MG_LL_NONE, MG_LL_ERROR, MG_LL_INFO, MG_LL_DEBUG, MG_LL_VERBOSE };
+void mg_log(const char *fmt, ...);
+bool mg_log_prefix(int ll, const char *file, int line, const char *fname);
+void mg_log_set(const char *spec);
+void mg_hexdump(const void *buf, size_t len);
+void mg_log_set_fn(void (*logfunc)(unsigned char ch));
+
+#if MG_ENABLE_LOG
+#define MG_LOG(level, args)                                                \
+  do {                                                                     \
+    if (mg_log_prefix((level), __FILE__, __LINE__, __func__)) mg_log args; \
+  } while (0)
+#else
+#define MG_LOG(level, args) \
+  do {                      \
+    if (0) mg_log args;     \
+  } while (0)
+#endif
+
+#define MG_ERROR(args) MG_LOG(MG_LL_ERROR, args)
+#define MG_INFO(args) MG_LOG(MG_LL_INFO, args)
+#define MG_DEBUG(args) MG_LOG(MG_LL_DEBUG, args)
+#define MG_VERBOSE(args) MG_LOG(MG_LL_VERBOSE, args)
+
+
+
+
+struct mg_timer {
+  unsigned long id;         // Timer ID
+  uint64_t period_ms;       // Timer period in milliseconds
+  uint64_t prev_ms;         // Timestamp of a previous poll
+  uint64_t expire;          // Expiration timestamp in milliseconds
+  unsigned flags;           // Possible flags values below
+#define MG_TIMER_ONCE 0     // Call function once
+#define MG_TIMER_REPEAT 1   // Call function periodically
+#define MG_TIMER_RUN_NOW 2  // Call immediately when timer is set
+  void (*fn)(void *);       // Function to call
+  void *arg;                // Function argument
+  struct mg_timer *next;    // Linkage
+};
+
+void mg_timer_init(struct mg_timer **head, struct mg_timer *timer,
+                   uint64_t milliseconds, unsigned flags, void (*fn)(void *),
+                   void *arg);
+void mg_timer_free(struct mg_timer **head, struct mg_timer *);
+void mg_timer_poll(struct mg_timer **head, uint64_t new_ms);
+
+
+
+
+
+enum { MG_FS_READ = 1, MG_FS_WRITE = 2, MG_FS_DIR = 4 };
+
+// Filesystem API functions
+// st() returns MG_FS_* flags and populates file size and modification time
+// ls() calls fn() for every directory entry, allowing to list a directory
+//
+// NOTE: UNIX-style shorthand names for the API functions are deliberately
+// chosen to avoid conflicts with some libraries that make macros for e.g.
+// stat(), write(), read() calls.
+struct mg_fs {
+  int (*st)(const char *path, size_t *size, time_t *mtime);  // stat file
+  void (*ls)(const char *path, void (*fn)(const char *, void *), void *);
+  void *(*op)(const char *path, int flags);             // Open file
+  void (*cl)(void *fd);                                 // Close file
+  size_t (*rd)(void *fd, void *buf, size_t len);        // Read file
+  size_t (*wr)(void *fd, const void *buf, size_t len);  // Write file
+  size_t (*sk)(void *fd, size_t offset);                // Set file position
+  bool (*mv)(const char *from, const char *to);         // Rename file
+  bool (*rm)(const char *path);                         // Delete file
+  bool (*mkd)(const char *path);                        // Create directory
+};
+
+extern struct mg_fs mg_fs_posix;   // POSIX open/close/read/write/seek
+extern struct mg_fs mg_fs_packed;  // Packed FS, see examples/device-dashboard
+extern struct mg_fs mg_fs_fat;     // FAT FS
+
+// File descriptor
+struct mg_fd {
+  void *fd;
+  struct mg_fs *fs;
+};
+
+struct mg_fd *mg_fs_open(struct mg_fs *fs, const char *path, int flags);
+void mg_fs_close(struct mg_fd *fd);
+char *mg_file_read(struct mg_fs *fs, const char *path, size_t *size);
+bool mg_file_write(struct mg_fs *fs, const char *path, const void *, size_t);
+bool mg_file_printf(struct mg_fs *fs, const char *path, const char *fmt, ...);
+
+
+
+
+
+
+void mg_random(void *buf, size_t len);
+char *mg_random_str(char *buf, size_t len);
+uint16_t mg_ntohs(uint16_t net);
+uint32_t mg_ntohl(uint32_t net);
+uint32_t mg_crc32(uint32_t crc, const char *buf, size_t len);
+uint64_t mg_millis(void);
+
+#define mg_htons(x) mg_ntohs(x)
+#define mg_htonl(x) mg_ntohl(x)
+
+// Linked list management macros
+#define LIST_ADD_HEAD(type_, head_, elem_) \
+  do {                                     \
+    (elem_)->next = (*head_);              \
+    *(head_) = (elem_);                    \
+  } while (0)
+
+#define LIST_ADD_TAIL(type_, head_, elem_) \
+  do {                                     \
+    type_ **h = head_;                     \
+    while (*h != NULL) h = &(*h)->next;    \
+    *h = (elem_);                          \
+  } while (0)
+
+#define LIST_DELETE(type_, head_, elem_)   \
+  do {                                     \
+    type_ **h = head_;                     \
+    while (*h != (elem_)) h = &(*h)->next; \
+    *h = (elem_)->next;                    \
+  } while (0)
+
+
+
+unsigned short mg_url_port(const char *url);
+int mg_url_is_ssl(const char *url);
+struct mg_str mg_url_host(const char *url);
+struct mg_str mg_url_user(const char *url);
+struct mg_str mg_url_pass(const char *url);
+const char *mg_url_uri(const char *url);
+
+
+
+
+struct mg_iobuf {
+  unsigned char *buf;  // Pointer to stored data
+  size_t size;         // Total size available
+  size_t len;          // Current number of bytes
+};
+
+int mg_iobuf_init(struct mg_iobuf *, size_t);
+int mg_iobuf_resize(struct mg_iobuf *, size_t);
+void mg_iobuf_free(struct mg_iobuf *);
+size_t mg_iobuf_add(struct mg_iobuf *, size_t, const void *, size_t, size_t);
+size_t mg_iobuf_del(struct mg_iobuf *, size_t ofs, size_t len);
+
+int mg_base64_update(unsigned char p, char *to, int len);
+int mg_base64_final(char *to, int len);
+int mg_base64_encode(const unsigned char *p, int n, char *to);
+int mg_base64_decode(const char *src, int n, char *dst);
+
+
+
+
+typedef struct {
+  uint32_t buf[4];
+  uint32_t bits[2];
+  unsigned char in[64];
+} mg_md5_ctx;
+
+void mg_md5_init(mg_md5_ctx *c);
+void mg_md5_update(mg_md5_ctx *c, const unsigned char *data, size_t len);
+void mg_md5_final(mg_md5_ctx *c, unsigned char[16]);
+
+
+
+
+typedef struct {
+  uint32_t state[5];
+  uint32_t count[2];
+  unsigned char buffer[64];
+} mg_sha1_ctx;
+
+void mg_sha1_init(mg_sha1_ctx *);
+void mg_sha1_update(mg_sha1_ctx *, const unsigned char *data, size_t len);
+void mg_sha1_final(unsigned char digest[20], mg_sha1_ctx *);
+
+
+struct mg_connection;
+typedef void (*mg_event_handler_t)(struct mg_connection *, int ev,
+                                   void *ev_data, void *fn_data);
+void mg_call(struct mg_connection *c, int ev, void *ev_data);
+void mg_error(struct mg_connection *c, const char *fmt, ...);
+
+enum {
+  MG_EV_ERROR,       // Error                        char *error_message
+  MG_EV_OPEN,        // Connection created           NULL
+  MG_EV_POLL,        // mg_mgr_poll iteration        uint64_t *milliseconds
+  MG_EV_RESOLVE,     // Host name is resolved        NULL
+  MG_EV_CONNECT,     // Connection established       NULL
+  MG_EV_ACCEPT,      // Connection accepted          NULL
+  MG_EV_READ,        // Data received from socket    struct mg_str *
+  MG_EV_WRITE,       // Data written to socket       long *bytes_written
+  MG_EV_CLOSE,       // Connection closed            NULL
+  MG_EV_HTTP_MSG,    // HTTP request/response        struct mg_http_message *
+  MG_EV_HTTP_CHUNK,  // HTTP chunk (partial msg)     struct mg_http_message *
+  MG_EV_WS_OPEN,     // Websocket handshake done     struct mg_http_message *
+  MG_EV_WS_MSG,      // Websocket msg, text or bin   struct mg_ws_message *
+  MG_EV_WS_CTL,      // Websocket control msg        struct mg_ws_message *
+  MG_EV_MQTT_CMD,    // MQTT low-level command       struct mg_mqtt_message *
+  MG_EV_MQTT_MSG,    // MQTT PUBLISH received        struct mg_mqtt_message *
+  MG_EV_MQTT_OPEN,   // MQTT CONNACK received        int *connack_status_code
+  MG_EV_SNTP_TIME,   // SNTP time received           uint64_t *milliseconds
+  MG_EV_USER,        // Starting ID for user events
+};
+
+
+
+
+
+
+
+
+struct mg_dns {
+  const char *url;          // DNS server URL
+  struct mg_connection *c;  // DNS server connection
+};
+
+struct mg_addr {
+  uint16_t port;    // TCP or UDP port in network byte order
+  uint32_t ip;      // IP address in network byte order
+  uint8_t ip6[16];  // IPv6 address
+  bool is_ip6;      // True when address is IPv6 address
+};
+
+struct mg_mgr {
+  struct mg_connection *conns;  // List of active connections
+  struct mg_dns dns4;           // DNS for IPv4
+  struct mg_dns dns6;           // DNS for IPv6
+  int dnstimeout;               // DNS resolve timeout in milliseconds
+  bool use_dns6;                // Use DNS6 server by default, see #1532
+  unsigned long nextid;         // Next connection ID
+  unsigned long timerid;        // Next timer ID
+  void *userdata;               // Arbitrary user data pointer
+  uint16_t mqtt_id;             // MQTT IDs for pub/sub
+  void *active_dns_requests;    // DNS requests in progress
+  struct mg_timer *timers;      // Active timers
+  void *priv;                   // Used by the MIP stack
+  size_t extraconnsize;         // Used by the MIP stack
+#if MG_ARCH == MG_ARCH_FREERTOS_TCP
+  SocketSet_t ss;  // NOTE(lsm): referenced from socket struct
+#endif
+};
+
+struct mg_connection {
+  struct mg_connection *next;  // Linkage in struct mg_mgr :: connections
+  struct mg_mgr *mgr;          // Our container
+  struct mg_addr loc;          // Local address
+  struct mg_addr rem;          // Remote address
+  void *fd;                    // Connected socket, or LWIP data
+  unsigned long id;            // Auto-incrementing unique connection ID
+  struct mg_iobuf recv;        // Incoming data
+  struct mg_iobuf send;        // Outgoing data
+  mg_event_handler_t fn;       // User-specified event handler function
+  void *fn_data;               // User-specified function parameter
+  mg_event_handler_t pfn;      // Protocol-specific handler function
+  void *pfn_data;              // Protocol-specific function parameter
+  char label[50];              // Arbitrary label
+  void *tls;                   // TLS specific data
+  unsigned is_listening : 1;   // Listening connection
+  unsigned is_client : 1;      // Outbound (client) connection
+  unsigned is_accepted : 1;    // Accepted (server) connection
+  unsigned is_resolving : 1;   // Non-blocking DNS resolution is in progress
+  unsigned is_connecting : 1;  // Non-blocking connect is in progress
+  unsigned is_tls : 1;         // TLS-enabled connection
+  unsigned is_tls_hs : 1;      // TLS handshake is in progress
+  unsigned is_udp : 1;         // UDP connection
+  unsigned is_websocket : 1;   // WebSocket connection
+  unsigned is_mqtt5 : 1;       // For MQTT connection, v5 indicator
+  unsigned is_hexdumping : 1;  // Hexdump in/out traffic
+  unsigned is_draining : 1;    // Send remaining data, then close and free
+  unsigned is_closing : 1;     // Close and free the connection immediately
+  unsigned is_full : 1;        // Stop reads, until cleared
+  unsigned is_readable : 1;    // Connection is ready to read
+  unsigned is_writable : 1;    // Connection is ready to write
+};
+
+void mg_mgr_poll(struct mg_mgr *, int ms);
+void mg_mgr_init(struct mg_mgr *);
+void mg_mgr_free(struct mg_mgr *);
+
+struct mg_connection *mg_listen(struct mg_mgr *, const char *url,
+                                mg_event_handler_t fn, void *fn_data);
+struct mg_connection *mg_connect(struct mg_mgr *, const char *url,
+                                 mg_event_handler_t fn, void *fn_data);
+struct mg_connection *mg_wrapfd(struct mg_mgr *mgr, int fd,
+                                mg_event_handler_t fn, void *fn_data);
+void mg_connect_resolved(struct mg_connection *);
+bool mg_send(struct mg_connection *, const void *, size_t);
+size_t mg_printf(struct mg_connection *, const char *fmt, ...);
+size_t mg_vprintf(struct mg_connection *, const char *fmt, va_list ap);
+char *mg_straddr(struct mg_addr *, char *, size_t);
+bool mg_aton(struct mg_str str, struct mg_addr *addr);
+char *mg_ntoa(const struct mg_addr *addr, char *buf, size_t len);
+int mg_mkpipe(struct mg_mgr *, mg_event_handler_t, void *, bool udp);
+
+// These functions are used to integrate with custom network stacks
+struct mg_connection *mg_alloc_conn(struct mg_mgr *);
+void mg_close_conn(struct mg_connection *c);
+bool mg_open_listener(struct mg_connection *c, const char *url);
+struct mg_timer *mg_timer_add(struct mg_mgr *mgr, uint64_t milliseconds,
+                              unsigned flags, void (*fn)(void *), void *arg);
+
+
+
+
+
+
+
+
+struct mg_http_header {
+  struct mg_str name;   // Header name
+  struct mg_str value;  // Header value
+};
+
+struct mg_http_message {
+  struct mg_str method, uri, query, proto;             // Request/response line
+  struct mg_http_header headers[MG_MAX_HTTP_HEADERS];  // Headers
+  struct mg_str body;                                  // Body
+  struct mg_str head;                                  // Request + headers
+  struct mg_str chunk;    // Chunk for chunked encoding,  or partial body
+  struct mg_str message;  // Request + headers + body
+};
+
+// Parameter for mg_http_serve_dir()
+struct mg_http_serve_opts {
+  const char *root_dir;       // Web root directory, must be non-NULL
+  const char *ssi_pattern;    // SSI file name pattern, e.g. #.shtml
+  const char *extra_headers;  // Extra HTTP headers to add in responses
+  const char *mime_types;     // Extra mime types, ext1=type1,ext2=type2,..
+  const char *page404;        // Path to the 404 page, or NULL by default
+  struct mg_fs *fs;           // Filesystem implementation. Use NULL for POSIX
+};
+
+// Parameter for mg_http_next_multipart
+struct mg_http_part {
+  struct mg_str name;      // Form field name
+  struct mg_str filename;  // Filename for file uploads
+  struct mg_str body;      // Part contents
+};
+
+int mg_http_parse(const char *s, size_t len, struct mg_http_message *);
+int mg_http_get_request_len(const unsigned char *buf, size_t buf_len);
+void mg_http_printf_chunk(struct mg_connection *cnn, const char *fmt, ...);
+void mg_http_write_chunk(struct mg_connection *c, const char *buf, size_t len);
+void mg_http_delete_chunk(struct mg_connection *c, struct mg_http_message *hm);
+struct mg_connection *mg_http_listen(struct mg_mgr *, const char *url,
+                                     mg_event_handler_t fn, void *fn_data);
+struct mg_connection *mg_http_connect(struct mg_mgr *, const char *url,
+                                      mg_event_handler_t fn, void *fn_data);
+void mg_http_serve_dir(struct mg_connection *, struct mg_http_message *hm,
+                       const struct mg_http_serve_opts *);
+void mg_http_serve_file(struct mg_connection *, struct mg_http_message *hm,
+                        const char *path, const struct mg_http_serve_opts *);
+void mg_http_reply(struct mg_connection *, int status_code, const char *headers,
+                   const char *body_fmt, ...);
+struct mg_str *mg_http_get_header(struct mg_http_message *, const char *name);
+struct mg_str mg_http_var(struct mg_str buf, struct mg_str name);
+int mg_http_get_var(const struct mg_str *, const char *name, char *, size_t);
+int mg_url_decode(const char *s, size_t n, char *to, size_t to_len, int form);
+size_t mg_url_encode(const char *s, size_t n, char *buf, size_t len);
+void mg_http_creds(struct mg_http_message *, char *, size_t, char *, size_t);
+bool mg_http_match_uri(const struct mg_http_message *, const char *glob);
+long mg_http_upload(struct mg_connection *c, struct mg_http_message *hm,
+                    struct mg_fs *fs, const char *path, size_t max_size);
+void mg_http_bauth(struct mg_connection *, const char *user, const char *pass);
+struct mg_str mg_http_get_header_var(struct mg_str s, struct mg_str v);
+size_t mg_http_next_multipart(struct mg_str, size_t, struct mg_http_part *);
+int mg_http_status(const struct mg_http_message *hm);
+
+
+void mg_http_serve_ssi(struct mg_connection *c, const char *root,
+                       const char *fullpath);
+
+
+
+
+
+
+struct mg_tls_opts {
+  const char *ca;         // CA certificate file. For both listeners and clients
+  const char *crl;        // Certificate Revocation List. For clients
+  const char *cert;       // Certificate
+  const char *certkey;    // Certificate key
+  const char *ciphers;    // Cipher list
+  struct mg_str srvname;  // If not empty, enables server name verification
+  struct mg_fs *fs;       // FS API for reading certificate files
+};
+
+void mg_tls_init(struct mg_connection *, const struct mg_tls_opts *);
+void mg_tls_free(struct mg_connection *);
+long mg_tls_send(struct mg_connection *, const void *buf, size_t len);
+long mg_tls_recv(struct mg_connection *, void *buf, size_t len);
+size_t mg_tls_pending(struct mg_connection *);
+void mg_tls_handshake(struct mg_connection *);
+
+
+
+
+
+
+
+#if MG_ENABLE_MBEDTLS
+#include <mbedtls/debug.h>
+#include <mbedtls/net_sockets.h>
+#include <mbedtls/ssl.h>
+
+struct mg_tls {
+  char *cafile;             // CA certificate path
+  mbedtls_x509_crt ca;      // Parsed CA certificate
+  mbedtls_x509_crt cert;    // Parsed certificate
+  mbedtls_ssl_context ssl;  // SSL/TLS context
+  mbedtls_ssl_config conf;  // SSL-TLS config
+  mbedtls_pk_context pk;    // Private key context
+};
+#endif
+
+
+#if MG_ENABLE_OPENSSL
+
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+
+struct mg_tls {
+  SSL_CTX *ctx;
+  SSL *ssl;
+};
+#endif
+
+
+#define WEBSOCKET_OP_CONTINUE 0
+#define WEBSOCKET_OP_TEXT 1
+#define WEBSOCKET_OP_BINARY 2
+#define WEBSOCKET_OP_CLOSE 8
+#define WEBSOCKET_OP_PING 9
+#define WEBSOCKET_OP_PONG 10
+
+
+
+struct mg_ws_message {
+  struct mg_str data;  // Websocket message data
+  uint8_t flags;       // Websocket message flags
+};
+
+struct mg_connection *mg_ws_connect(struct mg_mgr *, const char *url,
+                                    mg_event_handler_t fn, void *fn_data,
+                                    const char *fmt, ...);
+void mg_ws_upgrade(struct mg_connection *, struct mg_http_message *,
+                   const char *fmt, ...);
+size_t mg_ws_send(struct mg_connection *, const char *buf, size_t len, int op);
+size_t mg_ws_wrap(struct mg_connection *, size_t len, int op);
+size_t mg_ws_printf(struct mg_connection *c, int op, const char *fmt, ...);
+size_t mg_ws_vprintf(struct mg_connection *c, int op, const char *fmt, va_list);
+
+
+
+
+struct mg_connection *mg_sntp_connect(struct mg_mgr *mgr, const char *url,
+                                      mg_event_handler_t fn, void *fn_data);
+void mg_sntp_request(struct mg_connection *c);
+int64_t mg_sntp_parse(const unsigned char *buf, size_t len);
+
+
+
+
+
+#define MQTT_CMD_CONNECT 1
+#define MQTT_CMD_CONNACK 2
+#define MQTT_CMD_PUBLISH 3
+#define MQTT_CMD_PUBACK 4
+#define MQTT_CMD_PUBREC 5
+#define MQTT_CMD_PUBREL 6
+#define MQTT_CMD_PUBCOMP 7
+#define MQTT_CMD_SUBSCRIBE 8
+#define MQTT_CMD_SUBACK 9
+#define MQTT_CMD_UNSUBSCRIBE 10
+#define MQTT_CMD_UNSUBACK 11
+#define MQTT_CMD_PINGREQ 12
+#define MQTT_CMD_PINGRESP 13
+#define MQTT_CMD_DISCONNECT 14
+#define MQTT_CMD_AUTH 15
+
+enum { MQTT_OK, MQTT_INCOMPLETE, MQTT_MALFORMED };
+
+struct mg_mqtt_opts {
+  struct mg_str user;          // Username, can be empty
+  struct mg_str pass;          // Password, can be empty
+  struct mg_str client_id;     // Client ID
+  struct mg_str will_topic;    // Will topic
+  struct mg_str will_message;  // Will message
+  uint8_t will_qos;            // Will message quality of service
+  uint8_t version;             // Can be 4 (3.1.1), or 5. If 0, assume 4.
+  uint16_t keepalive;          // Keep-alive timer in seconds
+  bool will_retain;            // Retain last will
+  bool clean;                  // Use clean session, 0 or 1
+};
+
+struct mg_mqtt_message {
+  struct mg_str topic;  // Parsed topic
+  struct mg_str data;   // Parsed message
+  struct mg_str dgram;  // Whole MQTT datagram, including headers
+  uint16_t id;  // Set for PUBACK, PUBREC, PUBREL, PUBCOMP, SUBACK, PUBLISH
+  uint8_t cmd;  // MQTT command, one of MQTT_CMD_*
+  uint8_t qos;  // Quality of service
+  uint8_t ack;  // Connack return code. 0 - success
+};
+
+struct mg_connection *mg_mqtt_connect(struct mg_mgr *, const char *url,
+                                      const struct mg_mqtt_opts *opts,
+                                      mg_event_handler_t fn, void *fn_data);
+struct mg_connection *mg_mqtt_listen(struct mg_mgr *mgr, const char *url,
+                                     mg_event_handler_t fn, void *fn_data);
+void mg_mqtt_login(struct mg_connection *c, const struct mg_mqtt_opts *opts);
+void mg_mqtt_pub(struct mg_connection *c, struct mg_str topic,
+                 struct mg_str data, int qos, bool retain);
+void mg_mqtt_sub(struct mg_connection *, struct mg_str topic, int qos);
+int mg_mqtt_parse(const uint8_t *, size_t, uint8_t, struct mg_mqtt_message *);
+void mg_mqtt_send_header(struct mg_connection *, uint8_t cmd, uint8_t flags,
+                         uint32_t len);
+size_t mg_mqtt_next_sub(struct mg_mqtt_message *msg, struct mg_str *topic,
+                        uint8_t *qos, size_t pos);
+size_t mg_mqtt_next_unsub(struct mg_mqtt_message *msg, struct mg_str *topic,
+                          size_t pos);
+void mg_mqtt_ping(struct mg_connection *);
+void mg_mqtt_pong(struct mg_connection *);
+void mg_mqtt_disconnect(struct mg_connection *);
+
+
+
+
+
+// Mongoose sends DNS queries that contain only one question:
+// either A (IPv4) or AAAA (IPv6) address lookup.
+// Therefore, we expect zero or one answer.
+// If `resolved` is true, then `addr` contains resolved IPv4 or IPV6 address.
+struct mg_dns_message {
+  uint16_t txnid;       // Transaction ID
+  bool resolved;        // Resolve successful, addr is set
+  struct mg_addr addr;  // Resolved address
+  char name[256];       // Host name
+};
+
+struct mg_dns_header {
+  uint16_t txnid;  // Transaction ID
+  uint16_t flags;
+  uint16_t num_questions;
+  uint16_t num_answers;
+  uint16_t num_authority_prs;
+  uint16_t num_other_prs;
+};
+
+// DNS resource record
+struct mg_dns_rr {
+  uint16_t nlen;    // Name or pointer length
+  uint16_t atype;   // Address type
+  uint16_t aclass;  // Address class
+  uint16_t alen;    // Address length
+};
+
+void mg_resolve(struct mg_connection *, const char *url);
+void mg_resolve_cancel(struct mg_connection *);
+bool mg_dns_parse(const uint8_t *buf, size_t len, struct mg_dns_message *);
+size_t mg_dns_parse_rr(const uint8_t *buf, size_t len, size_t ofs,
+                       bool is_question, struct mg_dns_rr *);
+
+
+
+
+
+#ifndef MG_JSON_MAX_DEPTH
+#define MG_JSON_MAX_DEPTH 30
+#endif
+
+// Error return values - negative. Successful returns are >= 0
+enum { MG_JSON_TOO_DEEP = -1, MG_JSON_INVALID = -2, MG_JSON_NOT_FOUND = -3 };
+int mg_json_get(const char *buf, int len, const char *path, int *toklen);
+
+bool mg_json_get_num(struct mg_str json, const char *path, double *v);
+bool mg_json_get_bool(struct mg_str json, const char *path, bool *v);
+long mg_json_get_long(struct mg_str json, const char *path, long dflt);
+char *mg_json_get_str(struct mg_str json, const char *path);
+char *mg_json_get_hex(struct mg_str json, const char *path, int *len);
+char *mg_json_get_b64(struct mg_str json, const char *path, int *len);
+
+
+
+
+
+struct mip_driver {
+  void *data;                                       // Driver-specific data
+  void (*init)(void *data);                         // Initialise driver
+  size_t (*tx)(const void *, size_t, void *data);   // Transmit frame
+  size_t (*rx)(void *buf, size_t len, void *data);  // Receive frame (polling)
+  bool (*status)(void *data);                       // Up/down status
+  // Set receive callback for interrupt-driven drivers
+  void (*rxcb)(void (*fn)(void *buf, size_t len, void *rxdata), void *rxdata);
+};
+
+struct mip_ipcfg {
+  uint8_t mac[6];         // MAC address. Must not be 0
+  uint32_t ip, mask, gw;  // IP, netmask, GW. If IP is 0, DHCP is used
+};
+
+void mip_init(struct mg_mgr *, struct mip_ipcfg *, struct mip_driver *);
+
+extern struct mip_driver mip_driver_stm32;
+
+#ifdef __cplusplus
+}
+#endif
+#endif  // MONGOOSE_H