From 40a667ede98815aa08943b20ca6e30e5347957df Mon Sep 17 00:00:00 2001 From: Fadekraft Date: Sun, 24 Apr 2016 23:08:13 +0200 Subject: [PATCH] Improvements to c-library, ported libpng + zlib --- .gitignore | 1 + clib/include/setjmp.h | 47 +- clib/include/stdio.h | 2 +- clib/mscv/CLib.vcxproj | 2 + clib/mscv/CLib.vcxproj.filters | 3 + clib/mscv/CLib/CLib.tlog/cl.command.1.tlog | Bin 73074 -> 76056 bytes clib/mscv/CLib/atoi64.cod | 124 +- clib/mscv/CLib/cos.cod | 149 +- clib/mscv/CLib/cosf.cod | 18 +- clib/mscv/CLib/errstrings.cod | 258 +- clib/mscv/CLib/ldexp.cod | 41 +- clib/mscv/CLib/log.cod | 450 ++- clib/mscv/CLib/log10.cod | 134 +- clib/mscv/CLib/math.cod | 122 +- clib/mscv/CLib/memcpy.cod | 120 +- clib/mscv/CLib/memmove.cod | 160 +- clib/mscv/CLib/memset.cod | 164 +- clib/mscv/CLib/modf.cod | 183 +- clib/mscv/CLib/pow.cod | 1647 +++++----- clib/mscv/CLib/scalbn.cod | 161 +- clib/mscv/CLib/sin.cod | 175 +- clib/mscv/CLib/sinf.cod | 18 +- clib/mscv/CLib/stream.cod | 2760 +++++++++-------- clib/mscv/CLib/strpbrk.cod | 21 +- clib/mscv/CLib/strstr.cod | 849 +++--- clib/mscv/CLib/strtod.cod | 457 ++- clib/mscv/CLib/strtoi64.cod | 368 ++- clib/mscv/CLib/strtol.cod | 233 +- clib/mscv/CLib/strtold.cod | 337 +-- clib/mscv/CLib/strtoul.cod | 216 +- clib/mscv/CLib/strtoull.cod | 199 +- clib/mscv/CLib/tanh.cod | 62 +- clib/mscv/CLib/vfprintf.cod | 8 +- clib/src/stdio/fflush.c | 51 + install/Hdd/Shared/Includes/png.h | 3130 ++++++++++++++++++++ install/Hdd/Shared/Libraries/zlib.lib | Bin 0 -> 277672 bytes 36 files changed, 7963 insertions(+), 4707 deletions(-) create mode 100644 clib/src/stdio/fflush.c create mode 100644 install/Hdd/Shared/Includes/png.h create mode 100644 install/Hdd/Shared/Libraries/zlib.lib diff --git a/.gitignore b/.gitignore index b3528e596..92c533d2d 100644 --- a/.gitignore +++ b/.gitignore @@ -216,3 +216,4 @@ pip-log.txt #Mr Developer .mr.developer.cfg +*.cod diff --git a/clib/include/setjmp.h b/clib/include/setjmp.h index b81d8d678..e9e5898ef 100644 --- a/clib/include/setjmp.h +++ b/clib/include/setjmp.h @@ -1,28 +1,55 @@ -/* Saves registers & stack pointer & ip - * - */ +/* MollenOS +* +* Copyright 2011 - 2016, Philip Meulengracht +* +* This program is free software : you can redistribute it and / or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation ? , either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program.If not, see . +* +* +* MollenOS C Library - SetJmp & LongJmp +*/ #ifndef __SETJMP_INC__ #define __SETJMP_INC__ -//Includes +/* Includes */ +#include #include -//Defines -#define _JBLEN 16 +/* Definitions */ +#define _JBLEN 24 #define _JBTYPE int typedef _JBTYPE jmp_buf[_JBLEN]; +/* C++ Guard */ #ifdef __cplusplus extern "C" { #endif -//Functions -extern int setjmp(jmp_buf env); -extern void longjmp(jmp_buf env, int value); +/* Prototypes */ + +/* The save in time -> jump */ +_CRT_EXTERN int _setjmp(jmp_buf env); +_CRT_EXTERN int _setjmp3(jmp_buf env, int nb_args, ...); + +/* Shorthand */ +#define setjmp(env) _setjmp(env) + +/* Restore time-state -> jmp */ +_CRT_EXTERN void longjmp(jmp_buf env, int value); #ifdef __cplusplus } #endif -#endif +#endif //!__SETJMP_INC__ diff --git a/clib/include/stdio.h b/clib/include/stdio.h index 178d440f8..b62ebf154 100644 --- a/clib/include/stdio.h +++ b/clib/include/stdio.h @@ -100,6 +100,7 @@ _CRT_EXTERN int fclose(FILE * stream); _CRT_EXTERN FILE *fopen(const char * filename, const char * mode); _CRT_EXTERN FILE *freopen(const char * filename, const char * mode, FILE * stream); _CRT_EXTERN int remove(const char * filename); +_CRT_EXTERN int fflush(FILE * stream); //Rename //tmpfile @@ -107,7 +108,6 @@ _CRT_EXTERN int remove(const char * filename); //extern void setbuf (FILE * stream, char * buffer); //extern int setvbuf(FILE * stream, char * buffer, int mode, size_t size); -//extern int fflush(FILE * stream); /******************************* * Formatted IO * diff --git a/clib/mscv/CLib.vcxproj b/clib/mscv/CLib.vcxproj index 45feda554..1f4dd129a 100644 --- a/clib/mscv/CLib.vcxproj +++ b/clib/mscv/CLib.vcxproj @@ -42,6 +42,7 @@ + @@ -330,6 +331,7 @@ OnlyExplicitInline Default false + NoExtensions Windows diff --git a/clib/mscv/CLib.vcxproj.filters b/clib/mscv/CLib.vcxproj.filters index 2b3fac804..4a1d959b0 100644 --- a/clib/mscv/CLib.vcxproj.filters +++ b/clib/mscv/CLib.vcxproj.filters @@ -357,6 +357,9 @@ Source\string + + Source\stdio\File + diff --git a/clib/mscv/CLib/CLib.tlog/cl.command.1.tlog b/clib/mscv/CLib/CLib.tlog/cl.command.1.tlog index c4a1f87b66d4ddf84fc3752c17e9b4d8f5589c64..7aae22344ba9dd9f362e8827a9f5ee737d8ea1e5 100644 GIT binary patch literal 76056 zcmeI5S#R4`5QXQtK>tJ0_a<=@IECMAZ5E;}61@dRgH&nS0B#bv0h08`w>@)dn!Hz( z9f(6t9u5kLT1Z(^zl_eDnLGUN-(RIC2XZMVvXX%;aeXNZIhL_Za9QA9U*_27M5cIt zCRx~Hgy%Bsbs|UDV~RZ{_)njohv$3YXnn4S*UZ8`hvA3^c;tKeP9Dlye!%q$c^kIx zf<_nANo4__)9sLUt}NK$MSR7 zdnA9|95)SnJd_dMcm7Hv`4aYdE+6n7uETBJuH{dBQ)4;2eU&%Z;{cay`5n)`mA|pg zKhqkIe+ozFkuT+AZ zjvhb7v3vNOkK_UV|Ml@2`SBxp9bPBH^ZI(9aQ}%s#eVyh`+DTl=>8+@QQiMBzDvFT zO5Wjeg>UO0djp zsE+g3`^lS3$3%5c^bmPu{2oX(scuU3CRN>&t@WJ|*gi!rIbqDE4l&aq^<;HV_!zFp z40O{KIUwC;bZ=7CJ=qgfeyK`cpsG%?ckSKS)Y_X=d5}GaDk(BpYHe!mrdoS~3Q0+n z7twp6V~4dF)@E#KGda~&s=6mzJM#J!zmd_J(Yk50PMPYS>IJAiqXJ>ZXqGX?M0HQ} z3Oym}@g30#VZOL?um5JgSjUwI-P-5JjFG(|R=pwGOIH%*MRZxmr>>^1ZmO$urc0)} zr#cIjm}5q2Dr+-koif!G)%iL|t-+k)x1xt_*-OZ1&1k(_w7!d~ZpqF)$|cqnP*+n| zH`CQQ)tf|hOSE==>ne6#?M|l2v<1_3Om$23Dy;m<-MtAl2;IHL?p_|Pw{hh`cLsGm zWz1&Q*f49Xk{vVE71hNWT~#8Nw<~tpea$Yu-6t>=Rhj$Q>W=aZT_IyAZC#zNbE6K! z8XBEILgh{6-AsAw+=ct-@*sT}Sl8c}0V$_eX{c4Il-H5vL-+tOy{sV7=cdoSo6jB7 z9aH5+wyKjk6$%}c#tuqKcS@EI;X^3#L#%^fosuiYnywg&3Ew2kk8quH%nlP0Zclhj zmJi`Nts%pF9nCW7q|iyRb5e$35=hFH59K<~Qo996I0?5TJmt!V?ges8?Jm#gq%hYs z&Nb`U@}XR3rX9kkXAEZyw~XN_SAKNsI^|Q=dKklvW4IEYvgJp4s+m~xVa>;)=A)FS zZ23`s78E(v3VlOc-%u$}+47-WyHW=7jC!1%DW;t%DOY}Ur`{!%3YCh5Qc=QFwtOhp zo^@TpMo)#FilwKLa^*w!S@6a6y^wG6ZOQj0SssLIO*8ETqeh`dX|7S~$nqhal}$Z! zI;Ya>j0H<4e)o<-V5V6<9PEpzKt%ASiU0X@=+MgFVVwc9nI_6@}WGRU^`8(Jl&Jf+KnbUjaN zy>?>$$^5f<{<)nmAKHh^L79Vsfi`l`Q)GN~PM#0xb?<~RoiW`arq{9ML-{s;lcbY$ z3(~jo&jNHbNJLbxh?g{5mu)1$l-7jOe@?9m%hwvj*g!1|NJ>7;I=QOTVpV6Mz*DZg z=#GCuSl?lNr%8RMq&w!yhwkTy+pO$xJ*V9Ypn~sBvU~_%LY>U$57Id?c1}{Rx}-Z_ zg+B_Fd37my#x`b_7MbOCt~}`;%f38ec1d5*z!yvjkJ<91oKxQz!`q1AC09OltM5IB z2B$kncd)rTSjO*^D<8V`6HPG(;27PpB%Fj>5?;raFXdCLs3Ya1yba2$Z23~YkPA}I zY|}K`EMj?;Eld6J$__or&1YOz->FsfZW3WKXKELUOVRnq*rV9S$o zopjMB0s36)aG{DTuG1l@}`}>B4c`6F}-BV zn{uwbAmwdQUb5v+IrC6*-X7;AUH+t(|LUmFsnBf|dUdU)H|Zx_H_9mhtxN&XT(nBp zw?I0hI`vCi`bAkU`SPUw9OrIXqFPW?uc%G~g*8ZqAh delta 1481 zcmYjQVQ5=b6z0b8cxKPXYZhZCZ48vnGByc1!dT0Qqm((S4Ho*tg_1F0WyV+n3&VA@ zj#9f4V(lTkF>0x<;Dit(XSOwt^5(|WF3hxyDbY(*AqV2S=S3LrDy{##fJmxe!Gl^wnTX}z%Zn@ z+YwZ^Dp1l@D7N&1r5o^R-Kw(B3gnZH4Kj$o>c*u`npI@sux>8vEC&9rc^lc;DTh?7>ja9@_==Bh(o8!|G8H4Kq0NrUtRk;}AZ^jR}YxGlcQLJ5HF0 z8PKzqqe6){NY&=I4M8s_G|>AB!VO$~Mkc~yV|_ZTCgyDHw}b~mJxREALISr=7~oss z6SyFIQZ}7E>4weINl2fvu>Cz6JAKNHo2P?}GI1pR;_&2qWt_8CcueUc!OQeib^;2R&dGVC6w9R$W+wsISbZa)I<{fzFGeM+t zLRs4N#uN=#%<35Ug8l~2@SiW+7zU@wdHFJ3kKi<^ykFC28nLM zh52hP+;xNW$?pV2mIFU{uzGVZXNgROcu}Jl(F-L@r>YA11r4G<<{lF;zd+BB({c1R zZAS_fJo6LJmQxJlOZ2vRH1>-I6A$|#RMw%ji#(QTC|-bKS)Ov&3&x5L);(S&t+B%0 zIc0oBgDVS3@ZVFRd|!vr-zBAdUrF;5uQFy@I`f#(M#^Zxl1S-e%T+3wu|_s% gF8SH4Bm|on-8jAv(`sVI%nLijjP%FNsU6JwFZ=C+cmMzZ diff --git a/clib/mscv/CLib/atoi64.cod b/clib/mscv/CLib/atoi64.cod index c63a8b79e..692a0751e 100644 --- a/clib/mscv/CLib/atoi64.cod +++ b/clib/mscv/CLib/atoi64.cod @@ -15,7 +15,6 @@ EXTRN __ctype:BYTE ; File c:\users\philip\documents\github\mollenos\clib\src\string\atoi64.c ; COMDAT _atoi64 _TEXT SEGMENT -_acc$ = -12 ; size = 8 _neg$1$ = -4 ; size = 4 _acc$1$ = 8 ; size = 4 _nptr$ = 8 ; size = 4 @@ -25,47 +24,52 @@ _atoi64 PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp - 00003 83 ec 0c sub esp, 12 ; 0000000cH + 00003 51 push ecx ; 10 : char *s = (char *)nptr; - 00006 8b 4d 08 mov ecx, DWORD PTR _nptr$[ebp] - 00009 0f 57 c0 xorps xmm0, xmm0 + 00004 8b 4d 08 mov ecx, DWORD PTR _nptr$[ebp] + 00007 53 push ebx + 00008 56 push esi ; 11 : __int64 acc = 0; - 0000c 66 0f 13 45 f4 movlpd QWORD PTR _acc$[ebp], xmm0 + 00009 33 f6 xor esi, esi + 0000b 33 db xor ebx, ebx + 0000d 89 75 08 mov DWORD PTR _acc$1$[ebp], esi ; 12 : int neg = 0; - 00011 c7 45 fc 00 00 - 00 00 mov DWORD PTR _neg$1$[ebp], 0 + 00010 89 5d fc mov DWORD PTR _neg$1$[ebp], ebx ; 13 : ; 14 : if (nptr == NULL) - 00018 85 c9 test ecx, ecx - 0001a 75 08 jne SHORT $LN12@atoi64 + 00013 85 c9 test ecx, ecx + 00015 75 0a jne SHORT $LN12@atoi64 ; 15 : return 0; - 0001c 33 c0 xor eax, eax - 0001e 33 d2 xor edx, edx + 00017 5e pop esi + 00018 33 c0 xor eax, eax + 0001a 33 d2 xor edx, edx + 0001c 5b pop ebx ; 36 : } - 00020 8b e5 mov esp, ebp - 00022 5d pop ebp - 00023 c3 ret 0 + 0001d 8b e5 mov esp, ebp + 0001f 5d pop ebp + 00020 c3 ret 0 $LN12@atoi64: ; 16 : ; 17 : while(isspace((int)*s)) - 00024 0f b6 01 movzx eax, BYTE PTR [ecx] - 00027 f6 80 00 00 00 + 00021 0f b6 01 movzx eax, BYTE PTR [ecx] + 00024 f6 80 00 00 00 00 20 test BYTE PTR __ctype[eax], 32 ; 00000020H - 0002e 74 0e je SHORT $LN7@atoi64 + 0002b 74 11 je SHORT $LN7@atoi64 + 0002d 8d 49 00 npad 3 $LL8@atoi64: 00030 0f b6 41 01 movzx eax, BYTE PTR [ecx+1] @@ -91,7 +95,7 @@ $LN7@atoi64: ; 22 : s++; - 0004b eb 04 jmp SHORT $LN21@atoi64 + 0004b eb 04 jmp SHORT $LN20@atoi64 $LN6@atoi64: ; 23 : } @@ -99,7 +103,7 @@ $LN6@atoi64: 0004d 3c 2b cmp al, 43 ; 0000002bH 0004f 75 01 jne SHORT $LN13@atoi64 -$LN21@atoi64: +$LN20@atoi64: ; 25 : s++; @@ -111,76 +115,70 @@ $LN13@atoi64: 00052 8a 11 mov dl, BYTE PTR [ecx] 00054 0f b6 c2 movzx eax, dl - 00057 53 push ebx - 00058 8b 5d f8 mov ebx, DWORD PTR _acc$[ebp+4] - 0005b 56 push esi - 0005c f6 80 00 00 00 + 00057 f6 80 00 00 00 00 04 test BYTE PTR __ctype[eax], 4 - 00063 8b 75 f4 mov esi, DWORD PTR _acc$[ebp] - 00066 74 45 je SHORT $LN2@atoi64 - 00068 89 75 08 mov DWORD PTR _acc$1$[ebp], esi - 0006b 57 push edi - 0006c 8d 64 24 00 npad 4 + 0005e 74 3e je SHORT $LN2@atoi64 + 00060 57 push edi $LL3@atoi64: ; 28 : { ; 29 : acc = 10 * acc + ((int)*s - '0'); - 00070 0f be c2 movsx eax, dl + 00061 0f be c2 movsx eax, dl ; 30 : s++; - 00073 8d 49 01 lea ecx, DWORD PTR [ecx+1] - 00076 83 e8 30 sub eax, 48 ; 00000030H - 00079 99 cdq - 0007a 8b fa mov edi, edx - 0007c 8b d6 mov edx, esi - 0007e 8b f3 mov esi, ebx - 00080 0f a4 d6 02 shld esi, edx, 2 - 00084 c1 e2 02 shl edx, 2 - 00087 01 55 08 add DWORD PTR _acc$1$[ebp], edx - 0008a 8b 55 08 mov edx, DWORD PTR _acc$1$[ebp] - 0008d 13 de adc ebx, esi - 0008f 0f a4 d3 01 shld ebx, edx, 1 - 00093 03 d2 add edx, edx - 00095 03 c2 add eax, edx - 00097 8a 11 mov dl, BYTE PTR [ecx] - 00099 8b f0 mov esi, eax - 0009b 0f b6 c2 movzx eax, dl - 0009e 13 df adc ebx, edi - 000a0 89 75 08 mov DWORD PTR _acc$1$[ebp], esi - 000a3 f6 80 00 00 00 + 00064 8d 49 01 lea ecx, DWORD PTR [ecx+1] + 00067 83 e8 30 sub eax, 48 ; 00000030H + 0006a 99 cdq + 0006b 8b fa mov edi, edx + 0006d 8b d6 mov edx, esi + 0006f 8b f3 mov esi, ebx + 00071 0f a4 d6 02 shld esi, edx, 2 + 00075 c1 e2 02 shl edx, 2 + 00078 01 55 08 add DWORD PTR _acc$1$[ebp], edx + 0007b 8b 55 08 mov edx, DWORD PTR _acc$1$[ebp] + 0007e 13 de adc ebx, esi + 00080 0f a4 d3 01 shld ebx, edx, 1 + 00084 03 d2 add edx, edx + 00086 03 c2 add eax, edx + 00088 8a 11 mov dl, BYTE PTR [ecx] + 0008a 8b f0 mov esi, eax + 0008c 0f b6 c2 movzx eax, dl + 0008f 13 df adc ebx, edi + 00091 89 75 08 mov DWORD PTR _acc$1$[ebp], esi + 00094 f6 80 00 00 00 00 04 test BYTE PTR __ctype[eax], 4 - 000aa 75 c4 jne SHORT $LL3@atoi64 - 000ac 5f pop edi + 0009b 75 c4 jne SHORT $LL3@atoi64 + 0009d 5f pop edi $LN2@atoi64: ; 31 : } ; 32 : ; 33 : if (neg) - 000ad 83 7d fc 00 cmp DWORD PTR _neg$1$[ebp], 0 - 000b1 74 07 je SHORT $LN1@atoi64 + 0009e 83 7d fc 00 cmp DWORD PTR _neg$1$[ebp], 0 + 000a2 74 07 je SHORT $LN1@atoi64 ; 34 : acc *= -1; - 000b3 f7 de neg esi - 000b5 83 d3 00 adc ebx, 0 - 000b8 f7 db neg ebx + 000a4 f7 de neg esi + 000a6 83 d3 00 adc ebx, 0 + 000a9 f7 db neg ebx $LN1@atoi64: ; 35 : return acc; - 000ba 8b c6 mov eax, esi - 000bc 8b d3 mov edx, ebx - 000be 5e pop esi - 000bf 5b pop ebx + 000ab 8b c6 mov eax, esi + 000ad 8b d3 mov edx, ebx + 000af 5e pop esi + 000b0 5b pop ebx ; 36 : } - 000c0 8b e5 mov esp, ebp - 000c2 5d pop ebp - 000c3 c3 ret 0 + 000b1 8b e5 mov esp, ebp + 000b3 5d pop ebp + 000b4 c3 ret 0 _atoi64 ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/cos.cod b/clib/mscv/CLib/cos.cod index 8d2eb48a7..a8a9f821f 100644 --- a/clib/mscv/CLib/cos.cod +++ b/clib/mscv/CLib/cos.cod @@ -33,20 +33,9 @@ PUBLIC __real@3fe0000000000000 PUBLIC __real@3fe45f306dc9c883 PUBLIC __real@3ff0000000000000 PUBLIC __real@3ff921fb54442d18 -PUBLIC __xmm@7fffffffffffffff7fffffffffffffff -PUBLIC __xmm@80000000000000008000000000000000 -EXTRN __libm_sse2_exp_precise:PROC +EXTRN __CIexp:PROC +EXTRN __ftol2_sse:PROC EXTRN __fltused:DWORD -; COMDAT __xmm@80000000000000008000000000000000 -CONST SEGMENT -__xmm@80000000000000008000000000000000 DB 00H, 00H, 00H, 00H, 00H, 00H, 00H - DB 080H, 00H, 00H, 00H, 00H, 00H, 00H, 00H, 080H -CONST ENDS -; COMDAT __xmm@7fffffffffffffff7fffffffffffffff -CONST SEGMENT -__xmm@7fffffffffffffff7fffffffffffffff DB 0ffH, 0ffH, 0ffH, 0ffH, 0ffH, 0ffH - DB 0ffH, 07fH, 0ffH, 0ffH, 0ffH, 0ffH, 0ffH, 0ffH, 0ffH, 07fH -CONST ENDS ; COMDAT __real@3ff921fb54442d18 CONST SEGMENT __real@3ff921fb54442d18 DQ 03ff921fb54442d18r ; 1.5708 @@ -99,8 +88,9 @@ CONST ENDS ; File c:\users\philip\documents\github\mollenos\clib\src\math\cos.c ; COMDAT _cos _TEXT SEGMENT -tv241 = 8 ; size = 8 +tv243 = 8 ; size = 8 _x$ = 8 ; size = 8 +_quadrant$ = 12 ; size = 4 _cos PROC ; COMDAT ; 21 : { @@ -114,12 +104,12 @@ _cos PROC ; COMDAT ; 25 : /* Calculate the quadrant */ ; 26 : quadrant = (int)(x * (2./M_PI)); - 00003 f2 0f 10 4d 08 movsd xmm1, QWORD PTR _x$[ebp] - 00008 66 0f 28 c1 movapd xmm0, xmm1 - 0000c f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@3fe45f306dc9c883 - 00014 f2 0f 2c c0 cvttsd2si eax, xmm0 - 00018 66 0f 6e c0 movd xmm0, eax + 00003 dd 45 08 fld QWORD PTR _x$[ebp] + 00006 dd 05 00 00 00 + 00 fld QWORD PTR __real@3fe45f306dc9c883 + 0000c d8 c9 fmul ST(0), ST(1) + 0000e e8 00 00 00 00 call __ftol2_sse + 00013 89 45 0c mov DWORD PTR _quadrant$[ebp], eax ; 27 : ; 28 : /* Get offset inside quadrant */ @@ -128,27 +118,27 @@ _cos PROC ; COMDAT ; 31 : /* Normalize quadrant to [0..3] */ ; 32 : quadrant = quadrant & 0x3; - 0001c 83 e0 03 and eax, 3 - 0001f f3 0f e6 c0 cvtdq2pd xmm0, xmm0 + 00016 83 e0 03 and eax, 3 + 00019 db 45 0c fild DWORD PTR _quadrant$[ebp] + 0001c dd 5d 08 fstp QWORD PTR tv243[ebp] + 0001f dd 45 08 fld QWORD PTR tv243[ebp] + 00022 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3ff921fb54442d18 + 00028 de e9 fsubp ST(1), ST(0) ; 33 : ; 34 : /* Fixup value for the generic function */ ; 35 : x += cos_off_tbl[quadrant]; - 00023 f2 0f 10 14 c5 - 00 00 00 00 movsd xmm2, QWORD PTR _cos_off_tbl[eax*8] - 0002c f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@3ff921fb54442d18 - 00034 f2 0f 5c c8 subsd xmm1, xmm0 - 00038 f2 0f 58 d1 addsd xmm2, xmm1 + 0002a dc 04 c5 00 00 + 00 00 fadd QWORD PTR _cos_off_tbl[eax*8] ; 36 : ; 37 : /* Calculate the negative of the square of x */ ; 38 : x2 = - (x * x); - 0003c f2 0f 59 d2 mulsd xmm2, xmm2 - 00040 66 0f 57 15 00 - 00 00 00 xorpd xmm2, QWORD PTR __xmm@80000000000000008000000000000000 + 00031 dc c8 fmul ST(0), ST(0) + 00033 d9 e0 fchs ; 39 : ; 40 : /* This is an unrolled taylor series using iterations @@ -170,124 +160,119 @@ _cos PROC ; COMDAT ; 56 : result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16*17*18); ; 57 : result *= x2; - 00048 66 0f 28 c2 movapd xmm0, xmm2 - 0004c f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@3ca6827863b97d97 + 00035 dd 05 00 00 00 + 00 fld QWORD PTR __real@3ca6827863b97d97 + 0003b d8 c9 fmul ST(0), ST(1) ; 58 : #endif ; 59 : #if (PRECISION >= 8) ; 60 : result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16); - 00054 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3d2ae7f3e733b81f + 0003d dc 05 00 00 00 + 00 fadd QWORD PTR __real@3d2ae7f3e733b81f ; 61 : result *= x2; - 0005c f2 0f 59 c2 mulsd xmm0, xmm2 + 00043 d8 c9 fmul ST(0), ST(1) ; 62 : #endif ; 63 : #if (PRECISION >= 7) ; 64 : result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14); - 00060 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3da93974a8c07c9d + 00045 dc 05 00 00 00 + 00 fadd QWORD PTR __real@3da93974a8c07c9d ; 65 : result *= x2; - 00068 f2 0f 59 c2 mulsd xmm0, xmm2 + 0004b d8 c9 fmul ST(0), ST(1) ; 66 : #endif ; 67 : #if (PRECISION >= 6) ; 68 : result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12); - 0006c f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3e21eed8eff8d898 + 0004d dc 05 00 00 00 + 00 fadd QWORD PTR __real@3e21eed8eff8d898 ; 69 : result *= x2; - 00074 f2 0f 59 c2 mulsd xmm0, xmm2 + 00053 d8 c9 fmul ST(0), ST(1) ; 70 : #endif ; 71 : #if (PRECISION >= 5) ; 72 : result += 1./(1.*2*3*4*5*6*7*8*9*10); - 00078 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3e927e4fb7789f5c + 00055 dc 05 00 00 00 + 00 fadd QWORD PTR __real@3e927e4fb7789f5c ; 73 : result *= x2; - 00080 f2 0f 59 c2 mulsd xmm0, xmm2 + 0005b d8 c9 fmul ST(0), ST(1) ; 74 : #endif ; 75 : result += 1./(1.*2*3*4*5*6*7*8); - 00084 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3efa01a01a01a01a + 0005d dc 05 00 00 00 + 00 fadd QWORD PTR __real@3efa01a01a01a01a ; 76 : result *= x2; - 0008c f2 0f 59 c2 mulsd xmm0, xmm2 + 00063 d8 c9 fmul ST(0), ST(1) ; 77 : ; 78 : result += 1./(1.*2*3*4*5*6); - 00090 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3f56c16c16c16c17 + 00065 dc 05 00 00 00 + 00 fadd QWORD PTR __real@3f56c16c16c16c17 ; 79 : result *= x2; - 00098 f2 0f 59 c2 mulsd xmm0, xmm2 + 0006b d8 c9 fmul ST(0), ST(1) ; 80 : ; 81 : result += 1./(1.*2*3*4); - 0009c f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3fa5555555555555 + 0006d dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fa5555555555555 ; 82 : result *= x2; - 000a4 f2 0f 59 c2 mulsd xmm0, xmm2 + 00073 d8 c9 fmul ST(0), ST(1) ; 83 : ; 84 : result += 1./(1.*2); - 000a8 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3fe0000000000000 + 00075 dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fe0000000000000 ; 85 : result *= x2; - 000b0 f2 0f 59 c2 mulsd xmm0, xmm2 + 0007b de c9 fmulp ST(1), ST(0) ; 86 : ; 87 : result += 1; - 000b4 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3ff0000000000000 + 0007d dc 05 00 00 00 + 00 fadd QWORD PTR __real@3ff0000000000000 ; 88 : ; 89 : /* Apply correct sign */ ; 90 : result *= cos_sign_tbl[quadrant]; - 000bc f2 0f 59 04 c5 - 00 00 00 00 mulsd xmm0, QWORD PTR _cos_sign_tbl[eax*8] + 00083 dc 0c c5 00 00 + 00 00 fmul QWORD PTR _cos_sign_tbl[eax*8] ; 91 : ; 92 : return result; - - 000c5 f2 0f 11 45 08 movsd QWORD PTR tv241[ebp], xmm0 - 000ca dd 45 08 fld QWORD PTR tv241[ebp] - ; 93 : } - 000cd 5d pop ebp - 000ce c3 ret 0 + 0008a 5d pop ebp + 0008b c3 ret 0 _cos ENDP _TEXT ENDS ; Function compile flags: /Ogtp ; File c:\users\philip\documents\github\mollenos\clib\src\math\cos.c ; COMDAT _cosh _TEXT SEGMENT -tv129 = -8 ; size = 8 _x$ = 8 ; size = 8 _cosh PROC ; COMDAT @@ -295,31 +280,25 @@ _cosh PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp - 00003 83 ec 08 sub esp, 8 ; 101 : const double ebig = exp(fabs(x)); - 00006 f2 0f 10 45 08 movsd xmm0, QWORD PTR _x$[ebp] - 0000b 66 0f 54 05 00 - 00 00 00 andpd xmm0, QWORD PTR __xmm@7fffffffffffffff7fffffffffffffff - 00013 e8 00 00 00 00 call __libm_sse2_exp_precise + 00003 dd 45 08 fld QWORD PTR _x$[ebp] + 00006 d9 e1 fabs + 00008 e8 00 00 00 00 call __CIexp ; 102 : return (ebig + 1.0/ebig) / 2.0; - 00018 f2 0f 10 0d 00 - 00 00 00 movsd xmm1, QWORD PTR __real@3ff0000000000000 - 00020 f2 0f 5e c8 divsd xmm1, xmm0 - 00024 f2 0f 58 c8 addsd xmm1, xmm0 - 00028 f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@3fe0000000000000 - 00030 f2 0f 11 4d f8 movsd QWORD PTR tv129[ebp], xmm1 - 00035 dd 45 f8 fld QWORD PTR tv129[ebp] + 0000d d9 e8 fld1 + 0000f d8 f1 fdiv ST(0), ST(1) + 00011 de c1 faddp ST(1), ST(0) + 00013 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3fe0000000000000 ; 103 : } - 00038 8b e5 mov esp, ebp - 0003a 5d pop ebp - 0003b c3 ret 0 + 00019 5d pop ebp + 0001a c3 ret 0 _cosh ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/cosf.cod b/clib/mscv/CLib/cosf.cod index 35a8213a8..a7ecb1f36 100644 --- a/clib/mscv/CLib/cosf.cod +++ b/clib/mscv/CLib/cosf.cod @@ -10,13 +10,13 @@ INCLUDELIB MSVCRT INCLUDELIB OLDNAMES PUBLIC _cosf -EXTRN __libm_sse2_cos_precise:PROC +EXTRN __CIcos:PROC EXTRN __fltused:DWORD ; Function compile flags: /Ogtp ; File c:\users\philip\documents\github\mollenos\clib\src\math\cosf.c ; COMDAT _cosf _TEXT SEGMENT -tv70 = 8 ; size = 4 +tv72 = 8 ; size = 4 __X$ = 8 ; size = 4 _cosf PROC ; COMDAT @@ -24,20 +24,18 @@ _cosf PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp - 00003 f3 0f 10 45 08 movss xmm0, DWORD PTR __X$[ebp] ; 12 : return ((float)cos((double)_X)); - 00008 0f 5a c0 cvtps2pd xmm0, xmm0 - 0000b e8 00 00 00 00 call __libm_sse2_cos_precise - 00010 f2 0f 5a c0 cvtsd2ss xmm0, xmm0 - 00014 f3 0f 11 45 08 movss DWORD PTR tv70[ebp], xmm0 - 00019 d9 45 08 fld DWORD PTR tv70[ebp] + 00003 d9 45 08 fld DWORD PTR __X$[ebp] + 00006 e8 00 00 00 00 call __CIcos + 0000b d9 5d 08 fstp DWORD PTR tv72[ebp] + 0000e d9 45 08 fld DWORD PTR tv72[ebp] ; 13 : } - 0001c 5d pop ebp - 0001d c3 ret 0 + 00011 5d pop ebp + 00012 c3 ret 0 _cosf ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/errstrings.cod b/clib/mscv/CLib/errstrings.cod index be8887379..5bd47565c 100644 --- a/clib/mscv/CLib/errstrings.cod +++ b/clib/mscv/CLib/errstrings.cod @@ -11,19 +11,16 @@ INCLUDELIB OLDNAMES PUBLIC __errstrings _BSS SEGMENT -$SG1744 DB 01H DUP (?) $SG1747 DB 01H DUP (?) -$SG1748 DB 01H DUP (?) -$SG1749 DB 01H DUP (?) $SG1750 DB 01H DUP (?) $SG1751 DB 01H DUP (?) -$SG1756 DB 01H DUP (?) +$SG1752 DB 01H DUP (?) +$SG1753 DB 01H DUP (?) +$SG1754 DB 01H DUP (?) +$SG1759 DB 01H DUP (?) _BSS ENDS _DATA SEGMENT -__errstrings DD FLAT:$SG1635 - DD FLAT:$SG1636 - DD FLAT:$SG1637 - DD FLAT:$SG1638 +__errstrings DD FLAT:$SG1638 DD FLAT:$SG1639 DD FLAT:$SG1640 DD FLAT:$SG1641 @@ -148,217 +145,220 @@ __errstrings DD FLAT:$SG1635 DD FLAT:$SG1760 DD FLAT:$SG1761 DD FLAT:$SG1762 -$SG1635 DB 'No Error', 00H + DD FLAT:$SG1763 + DD FLAT:$SG1764 + DD FLAT:$SG1765 +$SG1638 DB 'No Error', 00H ORG $+3 -$SG1636 DB 'Not super-user', 00H +$SG1639 DB 'Not super-user', 00H ORG $+1 -$SG1637 DB 'No such file or directory', 00H +$SG1640 DB 'No such file or directory', 00H ORG $+2 -$SG1638 DB 'No such process', 00H -$SG1639 DB 'Interrupted system call', 00H -$SG1640 DB 'I/O error', 00H +$SG1641 DB 'No such process', 00H +$SG1642 DB 'Interrupted system call', 00H +$SG1643 DB 'I/O error', 00H ORG $+2 -$SG1641 DB 'No such device or address', 00H +$SG1644 DB 'No such device or address', 00H ORG $+2 -$SG1642 DB 'Arg list too long', 00H +$SG1645 DB 'Arg list too long', 00H ORG $+2 -$SG1643 DB 'Exec format error', 00H +$SG1646 DB 'Exec format error', 00H ORG $+2 -$SG1644 DB 'Bad file number', 00H -$SG1645 DB 'No children', 00H -$SG1646 DB 'No more processes', 00H +$SG1647 DB 'Bad file number', 00H +$SG1648 DB 'No children', 00H +$SG1649 DB 'No more processes', 00H ORG $+2 -$SG1647 DB 'Not enough core', 00H -$SG1648 DB 'Permission denied', 00H +$SG1650 DB 'Not enough core', 00H +$SG1651 DB 'Permission denied', 00H ORG $+2 -$SG1649 DB 'Bad address', 00H -$SG1650 DB 'Block device required', 00H +$SG1652 DB 'Bad address', 00H +$SG1653 DB 'Block device required', 00H ORG $+2 -$SG1651 DB 'Mount device busy', 00H +$SG1654 DB 'Mount device busy', 00H ORG $+2 -$SG1652 DB 'File exists', 00H -$SG1653 DB 'Cross-device link', 00H +$SG1655 DB 'File exists', 00H +$SG1656 DB 'Cross-device link', 00H ORG $+2 -$SG1654 DB 'No such device', 00H +$SG1657 DB 'No such device', 00H ORG $+1 -$SG1655 DB 'Not a directory', 00H -$SG1656 DB 'Is a directory', 00H +$SG1658 DB 'Not a directory', 00H +$SG1659 DB 'Is a directory', 00H ORG $+1 -$SG1657 DB 'Invalid argument', 00H +$SG1660 DB 'Invalid argument', 00H ORG $+3 -$SG1658 DB 'Too many open files in system', 00H +$SG1661 DB 'Too many open files in system', 00H ORG $+2 -$SG1659 DB 'Too many open files', 00H -$SG1660 DB 'Not a typewriter', 00H +$SG1662 DB 'Too many open files', 00H +$SG1663 DB 'Not a typewriter', 00H ORG $+3 -$SG1661 DB 'Text file busy', 00H +$SG1664 DB 'Text file busy', 00H ORG $+1 -$SG1662 DB 'File too large', 00H +$SG1665 DB 'File too large', 00H ORG $+1 -$SG1663 DB 'No space left on device', 00H -$SG1664 DB 'Illegal seek', 00H +$SG1666 DB 'No space left on device', 00H +$SG1667 DB 'Illegal seek', 00H ORG $+3 -$SG1665 DB 'Read only file system', 00H +$SG1668 DB 'Read only file system', 00H ORG $+2 -$SG1666 DB 'Too many links', 00H +$SG1669 DB 'Too many links', 00H ORG $+1 -$SG1667 DB 'Broken pipe', 00H -$SG1668 DB 'Math arg out of domain of func', 00H +$SG1670 DB 'Broken pipe', 00H +$SG1671 DB 'Math arg out of domain of func', 00H ORG $+1 -$SG1669 DB 'Math result not representable', 00H +$SG1672 DB 'Math result not representable', 00H ORG $+2 -$SG1670 DB 'No message of desired type', 00H +$SG1673 DB 'No message of desired type', 00H ORG $+1 -$SG1671 DB 'Identifier removed', 00H +$SG1674 DB 'Identifier removed', 00H ORG $+1 -$SG1672 DB 'Channel number out of range', 00H -$SG1673 DB 'Level 2 not synchronized', 00H +$SG1675 DB 'Channel number out of range', 00H +$SG1676 DB 'Level 2 not synchronized', 00H ORG $+3 -$SG1674 DB 'Level 3 halted', 00H +$SG1677 DB 'Level 3 halted', 00H ORG $+1 -$SG1675 DB 'Level 3 reset', 00H +$SG1678 DB 'Level 3 reset', 00H ORG $+2 -$SG1676 DB 'Link number out of range', 00H +$SG1679 DB 'Link number out of range', 00H ORG $+3 -$SG1677 DB 'Protocol driver not attached', 00H +$SG1680 DB 'Protocol driver not attached', 00H ORG $+3 -$SG1678 DB 'No CSI structure available', 00H +$SG1681 DB 'No CSI structure available', 00H ORG $+1 -$SG1679 DB 'Level 2 halted', 00H +$SG1682 DB 'Level 2 halted', 00H ORG $+1 -$SG1680 DB 'Deadlock condition', 00H +$SG1683 DB 'Deadlock condition', 00H ORG $+1 -$SG1681 DB 'No record locks available', 00H +$SG1684 DB 'No record locks available', 00H ORG $+2 -$SG1682 DB 'Invalid exchange', 00H +$SG1685 DB 'Invalid exchange', 00H ORG $+3 -$SG1683 DB 'Invalid request descriptor', 00H +$SG1686 DB 'Invalid request descriptor', 00H ORG $+1 -$SG1684 DB 'Exchange full', 00H +$SG1687 DB 'Exchange full', 00H ORG $+2 -$SG1685 DB 'No anode', 00H +$SG1688 DB 'No anode', 00H ORG $+3 -$SG1686 DB 'Invalid request code', 00H +$SG1689 DB 'Invalid request code', 00H ORG $+3 -$SG1687 DB 'Invalid slot', 00H +$SG1690 DB 'Invalid slot', 00H ORG $+3 -$SG1688 DB 'File locking deadlock error', 00H -$SG1689 DB 'Bad font file fmt', 00H +$SG1691 DB 'File locking deadlock error', 00H +$SG1692 DB 'Bad font file fmt', 00H ORG $+2 -$SG1690 DB 'Device not a stream', 00H -$SG1691 DB 'No data (for no delay io)', 00H +$SG1693 DB 'Device not a stream', 00H +$SG1694 DB 'No data (for no delay io)', 00H ORG $+2 -$SG1692 DB 'Timer expired', 00H +$SG1695 DB 'Timer expired', 00H ORG $+2 -$SG1693 DB 'Out of streams resources', 00H +$SG1696 DB 'Out of streams resources', 00H ORG $+3 -$SG1694 DB 'Machine is not on the network', 00H +$SG1697 DB 'Machine is not on the network', 00H ORG $+2 -$SG1695 DB 'Package not installed', 00H +$SG1698 DB 'Package not installed', 00H ORG $+2 -$SG1696 DB 'The object is remote', 00H +$SG1699 DB 'The object is remote', 00H ORG $+3 -$SG1697 DB 'The link has been severed', 00H +$SG1700 DB 'The link has been severed', 00H ORG $+2 -$SG1698 DB 'Advertise error', 00H -$SG1699 DB 'Srmount error', 00H +$SG1701 DB 'Advertise error', 00H +$SG1702 DB 'Srmount error', 00H ORG $+2 -$SG1700 DB 'Communication error on send', 00H -$SG1701 DB 'Protocol error', 00H +$SG1703 DB 'Communication error on send', 00H +$SG1704 DB 'Protocol error', 00H ORG $+1 -$SG1702 DB 'Multihop attempted', 00H +$SG1705 DB 'Multihop attempted', 00H ORG $+1 -$SG1703 DB 'Inode is remote (not really error)', 00H +$SG1706 DB 'Inode is remote (not really error)', 00H ORG $+1 -$SG1704 DB 'Cross mount point (not really error)', 00H +$SG1707 DB 'Cross mount point (not really error)', 00H ORG $+3 -$SG1705 DB 'Trying to read unreadable message', 00H +$SG1708 DB 'Trying to read unreadable message', 00H ORG $+2 -$SG1706 DB 'Inappropriate file type or format', 00H +$SG1709 DB 'Inappropriate file type or format', 00H ORG $+2 -$SG1707 DB 'Given log. name not unique', 00H +$SG1710 DB 'Given log. name not unique', 00H ORG $+1 -$SG1708 DB 'f.d. invalid for this operation', 00H -$SG1709 DB 'Remote address changed', 00H +$SG1711 DB 'f.d. invalid for this operation', 00H +$SG1712 DB 'Remote address changed', 00H ORG $+1 -$SG1710 DB 'Can''t access a needed shared lib', 00H +$SG1713 DB 'Can''t access a needed shared lib', 00H ORG $+3 -$SG1711 DB 'Accessing a corrupted shared lib', 00H +$SG1714 DB 'Accessing a corrupted shared lib', 00H ORG $+3 -$SG1712 DB '.lib section in a.out corrupted', 00H -$SG1713 DB 'Attempting to link in too many libs', 00H -$SG1714 DB 'Attempting to exec a shared library', 00H -$SG1715 DB 'Function not implemented', 00H +$SG1715 DB '.lib section in a.out corrupted', 00H +$SG1716 DB 'Attempting to link in too many libs', 00H +$SG1717 DB 'Attempting to exec a shared library', 00H +$SG1718 DB 'Function not implemented', 00H ORG $+3 -$SG1716 DB 'No more files', 00H +$SG1719 DB 'No more files', 00H ORG $+2 -$SG1717 DB 'Directory not empty', 00H -$SG1718 DB 'File or path name too long', 00H +$SG1720 DB 'Directory not empty', 00H +$SG1721 DB 'File or path name too long', 00H ORG $+1 -$SG1719 DB 'Too many symbolic links', 00H -$SG1720 DB 'Operation not supported on transport endpoint', 00H +$SG1722 DB 'Too many symbolic links', 00H +$SG1723 DB 'Operation not supported on transport endpoint', 00H ORG $+2 -$SG1721 DB 'Protocol family not supported', 00H +$SG1724 DB 'Protocol family not supported', 00H ORG $+2 -$SG1722 DB 'Connection reset by peer', 00H +$SG1725 DB 'Connection reset by peer', 00H ORG $+3 -$SG1723 DB 'No buffer space available', 00H +$SG1726 DB 'No buffer space available', 00H ORG $+2 -$SG1724 DB 'Address family not supported by protocol family', 00H -$SG1725 DB 'Protocol wrong type for socket', 00H +$SG1727 DB 'Address family not supported by protocol family', 00H +$SG1728 DB 'Protocol wrong type for socket', 00H ORG $+1 -$SG1726 DB 'Socket operation on non-socket', 00H +$SG1729 DB 'Socket operation on non-socket', 00H ORG $+1 -$SG1727 DB 'Protocol not available', 00H +$SG1730 DB 'Protocol not available', 00H ORG $+1 -$SG1728 DB 'Can''t send after socket shutdown', 00H +$SG1731 DB 'Can''t send after socket shutdown', 00H ORG $+3 -$SG1729 DB 'Connection refused', 00H +$SG1732 DB 'Connection refused', 00H ORG $+1 -$SG1730 DB 'Address already in use', 00H +$SG1733 DB 'Address already in use', 00H ORG $+1 -$SG1731 DB 'Connection aborted', 00H +$SG1734 DB 'Connection aborted', 00H ORG $+1 -$SG1732 DB 'Network is unreachable', 00H +$SG1735 DB 'Network is unreachable', 00H ORG $+1 -$SG1733 DB 'Network interface is not configured', 00H -$SG1734 DB 'Connection timed out', 00H +$SG1736 DB 'Network interface is not configured', 00H +$SG1737 DB 'Connection timed out', 00H ORG $+3 -$SG1735 DB 'Host is down', 00H +$SG1738 DB 'Host is down', 00H ORG $+3 -$SG1736 DB 'Host is unreachable', 00H -$SG1737 DB 'Connection already in progress', 00H +$SG1739 DB 'Host is unreachable', 00H +$SG1740 DB 'Connection already in progress', 00H ORG $+1 -$SG1738 DB 'Socket already connected', 00H +$SG1741 DB 'Socket already connected', 00H ORG $+3 -$SG1739 DB 'Destination address required', 00H +$SG1742 DB 'Destination address required', 00H ORG $+3 -$SG1740 DB 'Message too long', 00H +$SG1743 DB 'Message too long', 00H ORG $+3 -$SG1741 DB 'Unknown protocol', 00H +$SG1744 DB 'Unknown protocol', 00H ORG $+3 -$SG1742 DB 'Socket type not supported', 00H +$SG1745 DB 'Socket type not supported', 00H ORG $+2 -$SG1743 DB 'Address not available', 00H +$SG1746 DB 'Address not available', 00H ORG $+2 -$SG1745 DB 'Socket is already connected', 00H -$SG1746 DB 'Socket is not connected', 00H -$SG1752 DB 'Not supported', 00H +$SG1748 DB 'Socket is already connected', 00H +$SG1749 DB 'Socket is not connected', 00H +$SG1755 DB 'Not supported', 00H ORG $+2 -$SG1753 DB 'No medium (in tape drive)', 00H +$SG1756 DB 'No medium (in tape drive)', 00H ORG $+2 -$SG1754 DB 'No such host or network path', 00H +$SG1757 DB 'No such host or network path', 00H ORG $+3 -$SG1755 DB 'Filename exists with different case', 00H -$SG1757 DB 'Value too large for defined data type', 00H +$SG1758 DB 'Filename exists with different case', 00H +$SG1760 DB 'Value too large for defined data type', 00H ORG $+2 -$SG1758 DB 'Operation canceled', 00H +$SG1761 DB 'Operation canceled', 00H ORG $+1 -$SG1759 DB 'State not recoverable', 00H +$SG1762 DB 'State not recoverable', 00H ORG $+2 -$SG1760 DB 'Previous owner died', 00H -$SG1761 DB 'Streams pipe error', 00H +$SG1763 DB 'Previous owner died', 00H +$SG1764 DB 'Streams pipe error', 00H ORG $+1 -$SG1762 DB 'Operation would block', 00H +$SG1765 DB 'Operation would block', 00H _DATA ENDS END diff --git a/clib/mscv/CLib/ldexp.cod b/clib/mscv/CLib/ldexp.cod index 603e72e31..59a9439f5 100644 --- a/clib/mscv/CLib/ldexp.cod +++ b/clib/mscv/CLib/ldexp.cod @@ -28,11 +28,13 @@ _ldexp PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp 00003 83 ec 10 sub esp, 16 ; 00000010H - 00006 66 0f 6e 45 10 movd xmm0, DWORD PTR _exp$[ebp] ; 11 : register double result; ; 12 : #ifndef __GNUC__ ; 13 : register double __dy = (double)exp; + + 00006 db 45 10 fild DWORD PTR _exp$[ebp] + ; 14 : #endif ; 15 : ; 16 : /* Check for value correctness @@ -40,21 +42,20 @@ _ldexp PROC ; COMDAT ; 18 : */ ; 19 : if (_isnan(value)) - 0000b 83 ec 08 sub esp, 8 - 0000e f3 0f e6 c0 cvtdq2pd xmm0, xmm0 - 00012 f2 0f 11 45 f8 movsd QWORD PTR ___dy$[ebp], xmm0 - 00017 f2 0f 10 45 08 movsd xmm0, QWORD PTR _value$[ebp] - 0001c f2 0f 11 04 24 movsd QWORD PTR [esp], xmm0 - 00021 e8 00 00 00 00 call __isnan - 00026 83 c4 08 add esp, 8 - 00029 85 c0 test eax, eax - 0002b 74 0b je SHORT $LN1@ldexp + 00009 83 ec 08 sub esp, 8 + 0000c dd 5d f8 fstp QWORD PTR ___dy$[ebp] + 0000f dd 45 08 fld QWORD PTR _value$[ebp] + 00012 dd 1c 24 fstp QWORD PTR [esp] + 00015 e8 00 00 00 00 call __isnan + 0001a 83 c4 08 add esp, 8 + 0001d 85 c0 test eax, eax + 0001f 74 0b je SHORT $LN1@ldexp ; 20 : { ; 21 : errno = EDOM; - 0002d e8 00 00 00 00 call ___errno - 00032 c7 00 21 00 00 + 00021 e8 00 00 00 00 call ___errno + 00026 c7 00 21 00 00 00 mov DWORD PTR [eax], 33 ; 00000021H $LN1@ldexp: @@ -78,31 +79,31 @@ $LN1@ldexp: ; 39 : { ; 40 : fld __dy - 00038 dd 45 f8 fld QWORD PTR ___dy$[ebp] + 0002c dd 45 f8 fld QWORD PTR ___dy$[ebp] ; 41 : fld value - 0003b dd 45 08 fld QWORD PTR _value$[ebp] + 0002f dd 45 08 fld QWORD PTR _value$[ebp] ; 42 : fscale - 0003e d9 fd fscale + 00032 d9 fd fscale ; 43 : fstp result - 00040 dd 5d f0 fstp QWORD PTR _result$[ebp] + 00034 dd 5d f0 fstp QWORD PTR _result$[ebp] ; 44 : } ; 45 : #endif /* !__GNUC__ */ ; 46 : return result; - 00043 dd 45 f0 fld QWORD PTR _result$[ebp] + 00037 dd 45 f0 fld QWORD PTR _result$[ebp] ; 47 : } - 00046 8b e5 mov esp, ebp - 00048 5d pop ebp - 00049 c3 ret 0 + 0003a 8b e5 mov esp, ebp + 0003c 5d pop ebp + 0003d c3 ret 0 _ldexp ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/log.cod b/clib/mscv/CLib/log.cod index 0cd4b8b28..b90812bb2 100644 --- a/clib/mscv/CLib/log.cod +++ b/clib/mscv/CLib/log.cod @@ -105,14 +105,7 @@ CONST ENDS ; File c:\users\philip\documents\github\mollenos\clib\src\math\log.c ; COMDAT _log _TEXT SEGMENT -_R$ = -8 ; size = 8 -tv378 = 8 ; size = 8 -tv367 = 8 ; size = 8 -tv353 = 8 ; size = 8 -tv346 = 8 ; size = 8 -tv341 = 8 ; size = 8 -tv335 = 8 ; size = 8 -_f$ = 8 ; size = 8 +_k$ = -4 ; size = 4 _x$ = 8 ; size = 8 _log PROC ; COMDAT @@ -120,6 +113,7 @@ _log PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp + 00003 51 push ecx ; 86 : double hfsq,f,s,z,R,w,t1,t2,dk; ; 87 : int k,hx,i,j; @@ -131,383 +125,351 @@ _log PROC ; COMDAT ; 93 : k=0; ; 94 : if (hx < 0x00100000) { /* x < 2**-1022 */ - 00003 8b 55 0c mov edx, DWORD PTR _x$[ebp+4] - 00006 83 ec 08 sub esp, 8 - 00009 33 c9 xor ecx, ecx - 0000b 81 fa 00 00 10 + 00004 8b 55 0c mov edx, DWORD PTR _x$[ebp+4] + 00007 33 c9 xor ecx, ecx + 00009 81 fa 00 00 10 00 cmp edx, 1048576 ; 00100000H - 00011 7d 49 jge SHORT $LN16@log + 0000f 7d 42 jge SHORT $LN19@log ; 95 : if (((hx&0x7fffffff)|lx)==0) - 00013 8b c2 mov eax, edx - 00015 25 ff ff ff 7f and eax, 2147483647 ; 7fffffffH - 0001a 0b 45 08 or eax, DWORD PTR _x$[ebp] - 0001d 75 10 jne SHORT $LN15@log + 00011 8b c2 mov eax, edx + 00013 25 ff ff ff 7f and eax, 2147483647 ; 7fffffffH + 00018 0b 45 08 or eax, DWORD PTR _x$[ebp] + 0001b 75 10 jne SHORT $LN15@log ; 96 : return -two54/zero; /* log(+-0)=-inf */ - 0001f dd 05 00 00 00 + 0001d dd 05 00 00 00 00 fld QWORD PTR __real@c350000000000000 - 00025 dc 35 00 00 00 + 00023 dc 35 00 00 00 00 fdiv QWORD PTR _zero ; 132 : } ; 133 : } - 0002b 8b e5 mov esp, ebp - 0002d 5d pop ebp - 0002e c3 ret 0 + 00029 8b e5 mov esp, ebp + 0002b 5d pop ebp + 0002c c3 ret 0 $LN15@log: ; 97 : if (hx<0) return (x-x)/zero; /* log(-#) = NaN */ - 0002f 85 d2 test edx, edx - 00031 79 0f jns SHORT $LN14@log - 00033 dd 45 08 fld QWORD PTR _x$[ebp] - 00036 dc e8 fsub ST(0), ST(0) - 00038 dc 35 00 00 00 + 0002d dd 45 08 fld QWORD PTR _x$[ebp] + 00030 85 d2 test edx, edx + 00032 79 0c jns SHORT $LN14@log + 00034 dc e8 fsub ST(0), ST(0) + 00036 dc 35 00 00 00 00 fdiv QWORD PTR _zero ; 132 : } ; 133 : } - 0003e 8b e5 mov esp, ebp - 00040 5d pop ebp - 00041 c3 ret 0 + 0003c 8b e5 mov esp, ebp + 0003e 5d pop ebp + 0003f c3 ret 0 $LN14@log: ; 98 : k -= 54; x *= two54; /* subnormal number, scale up x */ - 00042 f2 0f 10 45 08 movsd xmm0, QWORD PTR _x$[ebp] - 00047 b9 ca ff ff ff mov ecx, -54 ; ffffffcaH - 0004c f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@4350000000000000 - 00054 f2 0f 11 45 08 movsd QWORD PTR _x$[ebp], xmm0 - 00059 8b 55 0c mov edx, DWORD PTR _x$[ebp+4] + 00040 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@4350000000000000 + 00046 b9 ca ff ff ff mov ecx, -54 ; ffffffcaH + 0004b dd 55 08 fst QWORD PTR _x$[ebp] + 0004e 8b 55 0c mov edx, DWORD PTR _x$[ebp+4] + 00051 eb 03 jmp SHORT $LN16@log +$LN19@log: + 00053 dd 45 08 fld QWORD PTR _x$[ebp] $LN16@log: ; 99 : hx = __HI(x); /* high word of x */ ; 100 : } ; 101 : if (hx >= 0x7ff00000) return x+x; - 0005c 81 fa 00 00 f0 + 00056 81 fa 00 00 f0 7f cmp edx, 2146435072 ; 7ff00000H - 00062 7c 09 jl SHORT $LN13@log - 00064 dd 45 08 fld QWORD PTR _x$[ebp] - 00067 dc c0 fadd ST(0), ST(0) + 0005c 7c 06 jl SHORT $LN23@log + 0005e dc c0 fadd ST(0), ST(0) ; 132 : } ; 133 : } - 00069 8b e5 mov esp, ebp - 0006b 5d pop ebp - 0006c c3 ret 0 -$LN13@log: - 0006d 56 push esi + 00060 8b e5 mov esp, ebp + 00062 5d pop ebp + 00063 c3 ret 0 +$LN23@log: + 00064 56 push esi ; 102 : k += (hx>>20)-1023; - 0006e 8b f2 mov esi, edx - 00070 81 c1 01 fc ff + 00065 8b f2 mov esi, edx + 00067 81 c1 01 fc ff ff add ecx, -1023 ; fffffc01H ; 103 : hx &= 0x000fffff; - 00076 81 e2 ff ff 0f + 0006d 81 e2 ff ff 0f 00 and edx, 1048575 ; 000fffffH - 0007c c1 fe 14 sar esi, 20 ; 00000014H - 0007f 03 f1 add esi, ecx + 00073 c1 fe 14 sar esi, 20 ; 00000014H + 00076 03 f1 add esi, ecx + 00078 dd d8 fstp ST(0) ; 104 : i = (hx+0x95f64)&0x100000; - 00081 8d 8a 64 5f 09 + 0007a 8d 8a 64 5f 09 00 lea ecx, DWORD PTR [edx+614244] - 00087 81 e1 00 00 10 + 00080 81 e1 00 00 10 00 and ecx, 1048576 ; 00100000H ; 105 : __HI(x) = hx|(i^0x3ff00000); /* normalize x or x/2 */ - 0008d 8b c1 mov eax, ecx + 00086 8b c1 mov eax, ecx ; 106 : k += (i>>20); - 0008f c1 f9 14 sar ecx, 20 ; 00000014H - 00092 35 00 00 f0 3f xor eax, 1072693248 ; 3ff00000H - 00097 03 f1 add esi, ecx - 00099 0b c2 or eax, edx - 0009b 89 45 0c mov DWORD PTR _x$[ebp+4], eax + 00088 c1 f9 14 sar ecx, 20 ; 00000014H + 0008b 35 00 00 f0 3f xor eax, 1072693248 ; 3ff00000H + 00090 03 f1 add esi, ecx + 00092 0b c2 or eax, edx + 00094 89 75 fc mov DWORD PTR _k$[ebp], esi + 00097 89 45 0c mov DWORD PTR _x$[ebp+4], eax ; 107 : f = x-1.0; ; 108 : if((0x000fffff&(2+hx))<3) { /* |f| < 2**-20 */ - 0009e 8d 42 02 lea eax, DWORD PTR [edx+2] - 000a1 f2 0f 10 55 08 movsd xmm2, QWORD PTR _x$[ebp] - 000a6 25 ff ff 0f 00 and eax, 1048575 ; 000fffffH - 000ab f2 0f 5c 15 00 - 00 00 00 subsd xmm2, QWORD PTR __real@3ff0000000000000 - 000b3 f2 0f 11 55 08 movsd QWORD PTR _f$[ebp], xmm2 - 000b8 83 f8 03 cmp eax, 3 - 000bb 0f 8d b7 00 00 - 00 jge $LN7@log + 0009a 8d 42 02 lea eax, DWORD PTR [edx+2] + 0009d dd 45 08 fld QWORD PTR _x$[ebp] + 000a0 25 ff ff 0f 00 and eax, 1048575 ; 000fffffH + 000a5 dc 25 00 00 00 + 00 fsub QWORD PTR __real@3ff0000000000000 + 000ab 83 f8 03 cmp eax, 3 + 000ae 7d 63 jge SHORT $LN7@log ; 109 : if(f==zero) if(k==0) return zero; else {dk=(double)k; - 000c1 66 0f 2e 15 00 - 00 00 00 ucomisd xmm2, QWORD PTR _zero - 000c9 9f lahf - 000ca f6 c4 44 test ah, 68 ; 00000044H - 000cd 7a 3c jp SHORT $LN9@log - 000cf 85 f6 test esi, esi - 000d1 75 0b jne SHORT $LN10@log - 000d3 dd 05 00 00 00 + 000b0 dd 05 00 00 00 00 fld QWORD PTR _zero - 000d9 5e pop esi - -; 132 : } -; 133 : } - - 000da 8b e5 mov esp, ebp - 000dc 5d pop ebp - 000dd c3 ret 0 -$LN10@log: - 000de 66 0f 6e ce movd xmm1, esi - -; 109 : if(f==zero) if(k==0) return zero; else {dk=(double)k; - - 000e2 f3 0f e6 c9 cvtdq2pd xmm1, xmm1 - 000e6 5e pop esi + 000b6 dd e1 fucom ST(1) + 000b8 df e0 fnstsw ax + 000ba f6 c4 44 test ah, 68 ; 00000044H + 000bd 7a 26 jp SHORT $LN29@log + 000bf dd d9 fstp ST(1) + 000c1 85 f6 test esi, esi + 000c3 0f 84 21 01 00 + 00 je $LN20@log + 000c9 dd d8 fstp ST(0) + 000cb db 45 fc fild DWORD PTR _k$[ebp] + 000ce 5e pop esi ; 110 : return dk*ln2_hi+dk*ln2_lo;} - 000e7 66 0f 28 c1 movapd xmm0, xmm1 - 000eb f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@3fe62e42fee00000 - 000f3 f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@3dea39ef35793c76 - 000fb f2 0f 58 c1 addsd xmm0, xmm1 - 000ff f2 0f 11 45 08 movsd QWORD PTR tv378[ebp], xmm0 - 00104 dd 45 08 fld QWORD PTR tv378[ebp] + 000cf dd 05 00 00 00 + 00 fld QWORD PTR __real@3dea39ef35793c76 + 000d5 d8 c9 fmul ST(0), ST(1) + 000d7 d9 c9 fxch ST(1) + 000d9 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3fe62e42fee00000 + 000df de c1 faddp ST(1), ST(0) ; 132 : } ; 133 : } - 00107 8b e5 mov esp, ebp - 00109 5d pop ebp - 0010a c3 ret 0 -$LN9@log: + 000e1 8b e5 mov esp, ebp + 000e3 5d pop ebp + 000e4 c3 ret 0 +$LN29@log: + 000e5 dd d8 fstp ST(0) ; 111 : R = f*f*(0.5-0.33333333333333333*f); - 0010b f2 0f 10 1d 00 - 00 00 00 movsd xmm3, QWORD PTR __real@3fe0000000000000 - 00113 66 0f 28 c2 movapd xmm0, xmm2 - 00117 f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@3fd5555555555555 - 0011f f2 0f 5c d8 subsd xmm3, xmm0 - 00123 66 0f 28 c2 movapd xmm0, xmm2 - 00127 f2 0f 59 c2 mulsd xmm0, xmm2 - 0012b f2 0f 59 d8 mulsd xmm3, xmm0 - 0012f f2 0f 11 5d f8 movsd QWORD PTR _R$[ebp], xmm3 + 000e7 dd 05 00 00 00 + 00 fld QWORD PTR __real@3fd5555555555555 + 000ed d8 c9 fmul ST(0), ST(1) + 000ef dc 2d 00 00 00 + 00 fsubr QWORD PTR __real@3fe0000000000000 + 000f5 d9 c1 fld ST(1) + 000f7 d8 ca fmul ST(0), ST(2) + 000f9 de c9 fmulp ST(1), ST(0) ; 112 : if(k==0) return f-R; else {dk=(double)k; - 00134 85 f6 test esi, esi - 00136 75 0b jne SHORT $LN8@log - 00138 dd 45 08 fld QWORD PTR _f$[ebp] - 0013b dc 65 f8 fsub QWORD PTR _R$[ebp] - 0013e 5e pop esi - -; 132 : } -; 133 : } - - 0013f 8b e5 mov esp, ebp - 00141 5d pop ebp - 00142 c3 ret 0 -$LN8@log: - 00143 66 0f 6e c6 movd xmm0, esi - -; 112 : if(k==0) return f-R; else {dk=(double)k; - - 00147 f3 0f e6 c0 cvtdq2pd xmm0, xmm0 - 0014b 5e pop esi + 000fb 85 f6 test esi, esi + 000fd 0f 84 c0 00 00 + 00 je $LN48@log + 00103 db 45 fc fild DWORD PTR _k$[ebp] ; 113 : return dk*ln2_hi-((R-dk*ln2_lo)-f);} - 0014c 66 0f 28 c8 movapd xmm1, xmm0 - 00150 f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@3dea39ef35793c76 - 00158 f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@3fe62e42fee00000 - 00160 f2 0f 5c d8 subsd xmm3, xmm0 - 00164 f2 0f 5c da subsd xmm3, xmm2 - 00168 f2 0f 5c cb subsd xmm1, xmm3 - 0016c f2 0f 11 4d 08 movsd QWORD PTR tv367[ebp], xmm1 - 00171 dd 45 08 fld QWORD PTR tv367[ebp] - -; 132 : } -; 133 : } - - 00174 8b e5 mov esp, ebp - 00176 5d pop ebp - 00177 c3 ret 0 + 00106 dd 05 00 00 00 + 00 fld QWORD PTR __real@3fe62e42fee00000 + 0010c d8 c9 fmul ST(0), ST(1) + 0010e e9 c7 00 00 00 jmp $LN46@log $LN7@log: ; 114 : } ; 115 : s = f/(2.0+f); - 00178 66 0f 28 c2 movapd xmm0, xmm2 - 0017c 66 0f 6e ee movd xmm5, esi - 00180 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@4000000000000000 - 00188 66 0f 28 f2 movapd xmm6, xmm2 + 00113 dd 05 00 00 00 + 00 fld QWORD PTR __real@4000000000000000 ; 116 : dk = (double)k; ; 117 : z = s*s; ; 118 : i = hx-0x6147a; - 0018c 8d 82 86 eb f9 + 00119 8d 82 86 eb f9 ff lea eax, DWORD PTR [edx-398458] + 0011f d8 c1 fadd ST(0), ST(1) ; 119 : w = z*z; ; 120 : j = 0x6b851-hx; - 00192 b9 51 b8 06 00 mov ecx, 440401 ; 0006b851H - 00197 2b ca sub ecx, edx + 00121 b9 51 b8 06 00 mov ecx, 440401 ; 0006b851H + 00126 2b ca sub ecx, edx ; 121 : t1= w*(Lg2+w*(Lg4+w*Lg6)); ; 122 : t2= z*(Lg1+w*(Lg3+w*(Lg5+w*Lg7))); ; 123 : i |= j; - 00199 0b c8 or ecx, eax - 0019b f2 0f 5e f0 divsd xmm6, xmm0 - 0019f f3 0f e6 ed cvtdq2pd xmm5, xmm5 - 001a3 66 0f 28 c6 movapd xmm0, xmm6 - 001a7 f2 0f 59 c6 mulsd xmm0, xmm6 - 001ab 66 0f 28 c8 movapd xmm1, xmm0 - 001af f2 0f 59 c8 mulsd xmm1, xmm0 - 001b3 66 0f 28 e1 movapd xmm4, xmm1 - 001b7 f2 0f 59 25 00 - 00 00 00 mulsd xmm4, QWORD PTR __real@3fc2f112df3e5244 - 001bf f2 0f 58 25 00 - 00 00 00 addsd xmm4, QWORD PTR __real@3fc7466496cb03de - 001c7 f2 0f 59 e1 mulsd xmm4, xmm1 - 001cb f2 0f 58 25 00 - 00 00 00 addsd xmm4, QWORD PTR __real@3fd2492494229359 - 001d3 f2 0f 59 e1 mulsd xmm4, xmm1 - 001d7 f2 0f 58 25 00 - 00 00 00 addsd xmm4, QWORD PTR __real@3fe5555555555593 - 001df f2 0f 59 e0 mulsd xmm4, xmm0 - 001e3 66 0f 28 c1 movapd xmm0, xmm1 - 001e7 f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@3fc39a09d078c69f - 001ef f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3fcc71c51d8e78af - 001f7 f2 0f 59 c1 mulsd xmm0, xmm1 - 001fb f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3fd999999997fa04 - 00203 f2 0f 59 c1 mulsd xmm0, xmm1 + 00128 0b c8 or ecx, eax + 0012a d8 f9 fdivr ST(0), ST(1) + 0012c db 45 fc fild DWORD PTR _k$[ebp] + 0012f d9 c1 fld ST(1) + 00131 d8 ca fmul ST(0), ST(2) + 00133 d9 c0 fld ST(0) + 00135 d8 c9 fmul ST(0), ST(1) + 00137 dd 05 00 00 00 + 00 fld QWORD PTR __real@3fc2f112df3e5244 + 0013d d8 c9 fmul ST(0), ST(1) + 0013f dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fc7466496cb03de + 00145 d8 c9 fmul ST(0), ST(1) + 00147 dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fd2492494229359 + 0014d d8 c9 fmul ST(0), ST(1) + 0014f dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fe5555555555593 + 00155 de ca fmulp ST(2), ST(0) + 00157 dd 05 00 00 00 + 00 fld QWORD PTR __real@3fc39a09d078c69f + 0015d d8 c9 fmul ST(0), ST(1) + 0015f dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fcc71c51d8e78af + 00165 d8 c9 fmul ST(0), ST(1) + 00167 dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fd999999997fa04 + 0016d de c9 fmulp ST(1), ST(0) ; 124 : R = t2+t1; - 00207 f2 0f 58 e0 addsd xmm4, xmm0 + 0016f de c1 faddp ST(1), ST(0) ; 125 : if(i>0) { - 0020b 7e 66 jle SHORT $LN6@log + 00171 7e 46 jle SHORT $LN6@log ; 126 : hfsq=0.5*f*f; - 0020d 66 0f 28 da movapd xmm3, xmm2 - 00211 f2 0f 59 1d 00 - 00 00 00 mulsd xmm3, QWORD PTR __real@3fe0000000000000 - 00219 f2 0f 59 da mulsd xmm3, xmm2 + 00173 d9 c3 fld ST(3) + 00175 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3fe0000000000000 + 0017b d8 cc fmul ST(0), ST(4) ; 127 : if(k==0) return f-(hfsq-s*(hfsq+R)); else - 0021d 66 0f 28 c3 movapd xmm0, xmm3 - 00221 f2 0f 58 c4 addsd xmm0, xmm4 - 00225 f2 0f 59 c6 mulsd xmm0, xmm6 - 00229 85 f6 test esi, esi - 0022b 75 15 jne SHORT $LN5@log - 0022d f2 0f 5c d8 subsd xmm3, xmm0 - 00231 5e pop esi - 00232 f2 0f 5c d3 subsd xmm2, xmm3 - 00236 f2 0f 11 55 08 movsd QWORD PTR tv353[ebp], xmm2 - 0023b dd 45 08 fld QWORD PTR tv353[ebp] + 0017d 85 f6 test esi, esi + 0017f 75 0f jne SHORT $LN5@log + 00181 dd da fstp ST(2) + 00183 d8 c1 fadd ST(0), ST(1) + 00185 5e pop esi + 00186 de ca fmulp ST(2), ST(0) + 00188 de e1 fsubrp ST(1), ST(0) + 0018a de e9 fsubp ST(1), ST(0) ; 132 : } ; 133 : } - 0023e 8b e5 mov esp, ebp - 00240 5d pop ebp - 00241 c3 ret 0 + 0018c 8b e5 mov esp, ebp + 0018e 5d pop ebp + 0018f c3 ret 0 $LN5@log: ; 128 : return dk*ln2_hi-((hfsq-(s*(hfsq+R)+dk*ln2_lo))-f); - 00242 66 0f 28 cd movapd xmm1, xmm5 - 00246 f2 0f 59 2d 00 - 00 00 00 mulsd xmm5, QWORD PTR __real@3dea39ef35793c76 - 0024e 5e pop esi - 0024f f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@3fe62e42fee00000 - 00257 f2 0f 58 c5 addsd xmm0, xmm5 - 0025b f2 0f 5c d8 subsd xmm3, xmm0 - 0025f f2 0f 5c da subsd xmm3, xmm2 - 00263 f2 0f 5c cb subsd xmm1, xmm3 - 00267 f2 0f 11 4d 08 movsd QWORD PTR tv346[ebp], xmm1 - 0026c dd 45 08 fld QWORD PTR tv346[ebp] + 00190 d9 c2 fld ST(2) + 00192 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3fe62e42fee00000 + 00198 d9 c1 fld ST(1) + 0019a de c3 faddp ST(3), ST(0) + 0019c d9 ca fxch ST(2) + 0019e 5e pop esi + 0019f de cc fmulp ST(4), ST(0) + 001a1 d9 ca fxch ST(2) + 001a3 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3dea39ef35793c76 + 001a9 de c3 faddp ST(3), ST(0) + 001ab d9 c9 fxch ST(1) + 001ad de e2 fsubrp ST(2), ST(0) + +; 131 : return dk*ln2_hi-((s*(f-R)-dk*ln2_lo)-f); + + 001af d9 c9 fxch ST(1) + 001b1 de e2 fsubrp ST(2), ST(0) + 001b3 de e1 fsubrp ST(1), ST(0) ; 132 : } ; 133 : } - 0026f 8b e5 mov esp, ebp - 00271 5d pop ebp - 00272 c3 ret 0 + 001b5 8b e5 mov esp, ebp + 001b7 5d pop ebp + 001b8 c3 ret 0 $LN6@log: ; 129 : } else { ; 130 : if(k==0) return f-s*(f-R); else - 00273 66 0f 28 c2 movapd xmm0, xmm2 - 00277 f2 0f 5c c4 subsd xmm0, xmm4 - 0027b f2 0f 59 c6 mulsd xmm0, xmm6 - 0027f 85 f6 test esi, esi - 00281 75 11 jne SHORT $LN2@log - 00283 f2 0f 5c d0 subsd xmm2, xmm0 - 00287 5e pop esi - 00288 f2 0f 11 55 08 movsd QWORD PTR tv341[ebp], xmm2 - 0028d dd 45 08 fld QWORD PTR tv341[ebp] + 001b9 85 f6 test esi, esi + 001bb 75 0d jne SHORT $LN2@log + 001bd dd d9 fstp ST(1) + 001bf d8 ea fsubr ST(0), ST(2) + 001c1 de c9 fmulp ST(1), ST(0) +$LN48@log: + 001c3 de e9 fsubp ST(1), ST(0) + 001c5 5e pop esi ; 132 : } ; 133 : } - 00290 8b e5 mov esp, ebp - 00292 5d pop ebp - 00293 c3 ret 0 + 001c6 8b e5 mov esp, ebp + 001c8 5d pop ebp + 001c9 c3 ret 0 $LN2@log: ; 131 : return dk*ln2_hi-((s*(f-R)-dk*ln2_lo)-f); - 00294 66 0f 28 cd movapd xmm1, xmm5 - 00298 f2 0f 59 2d 00 - 00 00 00 mulsd xmm5, QWORD PTR __real@3dea39ef35793c76 - 002a0 5e pop esi - 002a1 f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@3fe62e42fee00000 - 002a9 f2 0f 5c c5 subsd xmm0, xmm5 - 002ad f2 0f 5c c2 subsd xmm0, xmm2 - 002b1 f2 0f 5c c8 subsd xmm1, xmm0 - 002b5 f2 0f 11 4d 08 movsd QWORD PTR tv335[ebp], xmm1 - 002ba dd 45 08 fld QWORD PTR tv335[ebp] + 001ca d9 c1 fld ST(1) + 001cc dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3fe62e42fee00000 + 001d2 d9 c4 fld ST(4) + 001d4 de e2 fsubrp ST(2), ST(0) + 001d6 d9 c9 fxch ST(1) + 001d8 de cb fmulp ST(3), ST(0) +$LN46@log: + 001da d9 c9 fxch ST(1) + 001dc dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3dea39ef35793c76 + 001e2 de ea fsubp ST(2), ST(0) + 001e4 d9 c9 fxch ST(1) + 001e6 de e2 fsubrp ST(2), ST(0) + 001e8 de e1 fsubrp ST(1), ST(0) +$LN20@log: + 001ea 5e pop esi ; 132 : } ; 133 : } - 002bd 8b e5 mov esp, ebp - 002bf 5d pop ebp - 002c0 c3 ret 0 + 001eb 8b e5 mov esp, ebp + 001ed 5d pop ebp + 001ee c3 ret 0 _log ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/log10.cod b/clib/mscv/CLib/log10.cod index 4ea3387cf..f578d5513 100644 --- a/clib/mscv/CLib/log10.cod +++ b/clib/mscv/CLib/log10.cod @@ -24,7 +24,7 @@ PUBLIC __real@3fd34413509f6000 PUBLIC __real@3fdbcb7b1526e50e PUBLIC __real@4350000000000000 PUBLIC __real@c350000000000000 -EXTRN __libm_sse2_log_precise:PROC +EXTRN __CIlog:PROC EXTRN __fltused:DWORD ; COMDAT __real@c350000000000000 CONST SEGMENT @@ -50,7 +50,8 @@ CONST ENDS ; File c:\users\philip\documents\github\mollenos\clib\src\math\log10.c ; COMDAT _log10 _TEXT SEGMENT -tv211 = 8 ; size = 8 +_y$1$ = -8 ; size = 8 +tv216 = -4 ; size = 4 _x$ = 8 ; size = 8 _log10 PROC ; COMDAT @@ -70,127 +71,132 @@ _log10 PROC ; COMDAT ; 71 : if (hx < 0x00100000) { /* x < 2**-1022 */ 00003 8b 55 0c mov edx, DWORD PTR _x$[ebp+4] - 00006 33 c9 xor ecx, ecx - 00008 81 fa 00 00 10 + 00006 83 ec 08 sub esp, 8 + 00009 33 c9 xor ecx, ecx + 0000b 81 fa 00 00 10 00 cmp edx, 1048576 ; 00100000H - 0000e 7d 45 jge SHORT $LN4@log10 + 00011 7d 42 jge SHORT $LN7@log10 ; 72 : if (((hx&0x7fffffff)|lx)==0) - 00010 8b c2 mov eax, edx - 00012 25 ff ff ff 7f and eax, 2147483647 ; 7fffffffH - 00017 0b 45 08 or eax, DWORD PTR _x$[ebp] - 0001a 75 0e jne SHORT $LN3@log10 + 00013 8b c2 mov eax, edx + 00015 25 ff ff ff 7f and eax, 2147483647 ; 7fffffffH + 0001a 0b 45 08 or eax, DWORD PTR _x$[ebp] + 0001d 75 10 jne SHORT $LN3@log10 ; 73 : return -two54/zero; /* log(+-0)=-inf */ - 0001c dd 05 00 00 00 + 0001f dd 05 00 00 00 00 fld QWORD PTR __real@c350000000000000 - 00022 dc 35 00 00 00 + 00025 dc 35 00 00 00 00 fdiv QWORD PTR _zero ; 86 : } - 00028 5d pop ebp - 00029 c3 ret 0 + 0002b 8b e5 mov esp, ebp + 0002d 5d pop ebp + 0002e c3 ret 0 $LN3@log10: ; 74 : if (hx<0) return (x-x)/zero; /* log(-#) = NaN */ - 0002a 85 d2 test edx, edx - 0002c 79 0d jns SHORT $LN2@log10 - 0002e dd 45 08 fld QWORD PTR _x$[ebp] - 00031 dc e8 fsub ST(0), ST(0) - 00033 dc 35 00 00 00 + 0002f dd 45 08 fld QWORD PTR _x$[ebp] + 00032 85 d2 test edx, edx + 00034 79 0c jns SHORT $LN2@log10 + 00036 dc e8 fsub ST(0), ST(0) + 00038 dc 35 00 00 00 00 fdiv QWORD PTR _zero ; 86 : } - 00039 5d pop ebp - 0003a c3 ret 0 + 0003e 8b e5 mov esp, ebp + 00040 5d pop ebp + 00041 c3 ret 0 $LN2@log10: ; 75 : k -= 54; x *= two54; /* subnormal number, scale up x */ - 0003b f2 0f 10 45 08 movsd xmm0, QWORD PTR _x$[ebp] - 00040 b9 ca ff ff ff mov ecx, -54 ; ffffffcaH - 00045 f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@4350000000000000 - 0004d f2 0f 11 45 08 movsd QWORD PTR _x$[ebp], xmm0 - 00052 8b 55 0c mov edx, DWORD PTR _x$[ebp+4] + 00042 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@4350000000000000 + 00048 b9 ca ff ff ff mov ecx, -54 ; ffffffcaH + 0004d dd 55 08 fst QWORD PTR _x$[ebp] + 00050 8b 55 0c mov edx, DWORD PTR _x$[ebp+4] + 00053 eb 03 jmp SHORT $LN4@log10 +$LN7@log10: + 00055 dd 45 08 fld QWORD PTR _x$[ebp] $LN4@log10: ; 76 : hx = __HI(x); /* high word of x */ ; 77 : } ; 78 : if (hx >= 0x7ff00000) return x+x; - 00055 81 fa 00 00 f0 + 00058 81 fa 00 00 f0 7f cmp edx, 2146435072 ; 7ff00000H - 0005b 7c 07 jl SHORT $LN1@log10 - 0005d dd 45 08 fld QWORD PTR _x$[ebp] + 0005e 7c 06 jl SHORT $LN10@log10 00060 dc c0 fadd ST(0), ST(0) ; 86 : } - 00062 5d pop ebp - 00063 c3 ret 0 -$LN1@log10: + 00062 8b e5 mov esp, ebp + 00064 5d pop ebp + 00065 c3 ret 0 +$LN10@log10: ; 79 : k += (hx>>20)-1023; - 00064 8b c2 mov eax, edx - 00066 81 c1 01 fc ff + 00066 8b c2 mov eax, edx + 00068 81 c1 01 fc ff ff add ecx, -1023 ; fffffc01H - 0006c c1 f8 14 sar eax, 20 ; 00000014H + 0006e c1 f8 14 sar eax, 20 ; 00000014H + 00071 dd d8 fstp ST(0) + 00073 03 c1 add eax, ecx ; 80 : i = ((unsigned)k&0x80000000)>>31; ; 81 : hx = (hx&0x000fffff)|((0x3ff-i)<<20); - 0006f 81 e2 ff ff 0f + 00075 81 e2 ff ff 0f 00 and edx, 1048575 ; 000fffffH - 00075 03 c1 add eax, ecx - 00077 8b c8 mov ecx, eax - 00079 c1 e9 1f shr ecx, 31 ; 0000001fH - 0007c 56 push esi + 0007b 8b c8 mov ecx, eax + 0007d c1 e9 1f shr ecx, 31 ; 0000001fH ; 82 : y = (double)(k+i); - 0007d 8d 34 01 lea esi, DWORD PTR [ecx+eax] + 00080 03 c1 add eax, ecx + 00082 89 45 fc mov DWORD PTR tv216[ebp], eax ; 83 : __HI(x) = hx; - 00080 b8 ff 03 00 00 mov eax, 1023 ; 000003ffH - 00085 2b c1 sub eax, ecx - 00087 c1 e0 14 shl eax, 20 ; 00000014H - 0008a 0b c2 or eax, edx - 0008c 89 45 0c mov DWORD PTR _x$[ebp+4], eax + 00085 b8 ff 03 00 00 mov eax, 1023 ; 000003ffH + 0008a db 45 fc fild DWORD PTR tv216[ebp] + 0008d 2b c1 sub eax, ecx + 0008f c1 e0 14 shl eax, 20 ; 00000014H + 00092 0b c2 or eax, edx + 00094 89 45 0c mov DWORD PTR _x$[ebp+4], eax + 00097 dd 5d f8 fstp QWORD PTR _y$1$[ebp] ; 84 : z = y*log10_2lo + ivln10*log(x); - 0008f f2 0f 10 45 08 movsd xmm0, QWORD PTR _x$[ebp] - 00094 e8 00 00 00 00 call __libm_sse2_log_precise - 00099 f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@3fdbcb7b1526e50e - 000a1 66 0f 6e d6 movd xmm2, esi - 000a5 f3 0f e6 d2 cvtdq2pd xmm2, xmm2 - 000a9 5e pop esi - 000aa 66 0f 28 ca movapd xmm1, xmm2 + 0009a dd 45 08 fld QWORD PTR _x$[ebp] + 0009d e8 00 00 00 00 call __CIlog + 000a2 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3fdbcb7b1526e50e + 000a8 dd 45 f8 fld QWORD PTR _y$1$[ebp] + 000ab dd 05 00 00 00 + 00 fld QWORD PTR __real@3d59fef311f12b36 + 000b1 d8 c9 fmul ST(0), ST(1) + 000b3 de c2 faddp ST(2), ST(0) ; 85 : return z+y*log10_2hi; - 000ae f2 0f 59 15 00 - 00 00 00 mulsd xmm2, QWORD PTR __real@3fd34413509f6000 - 000b6 f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@3d59fef311f12b36 - 000be f2 0f 58 c1 addsd xmm0, xmm1 - 000c2 f2 0f 58 c2 addsd xmm0, xmm2 - 000c6 f2 0f 11 45 08 movsd QWORD PTR tv211[ebp], xmm0 - 000cb dd 45 08 fld QWORD PTR tv211[ebp] + 000b5 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3fd34413509f6000 + 000bb de c1 faddp ST(1), ST(0) ; 86 : } - 000ce 5d pop ebp - 000cf c3 ret 0 + 000bd 8b e5 mov esp, ebp + 000bf 5d pop ebp + 000c0 c3 ret 0 _log10 ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/math.cod b/clib/mscv/CLib/math.cod index 19ff202c8..c356fa4ac 100644 --- a/clib/mscv/CLib/math.cod +++ b/clib/mscv/CLib/math.cod @@ -19,22 +19,21 @@ PUBLIC __CIcos PUBLIC __CIlog PUBLIC __CIsin PUBLIC __CIsqrt +EXTRN __CIcos:PROC EXTRN __CIcosh:PROC +EXTRN __CIexp:PROC +EXTRN __CIlog:PROC +EXTRN __CIlog10:PROC +EXTRN __CIpow:PROC +EXTRN __CIsin:PROC EXTRN __CIsinh:PROC +EXTRN __CIsqrt:PROC EXTRN __CItanh:PROC -EXTRN __libm_sse2_cos_precise:PROC -EXTRN __libm_sse2_exp_precise:PROC -EXTRN __libm_sse2_log10_precise:PROC -EXTRN __libm_sse2_log_precise:PROC -EXTRN __libm_sse2_pow_precise:PROC -EXTRN __libm_sse2_sin_precise:PROC -EXTRN __libm_sse2_sqrt_precise:PROC EXTRN __fltused:DWORD ; Function compile flags: /Ogtp ; File c:\users\philip\documents\github\mollenos\clib\crt\math.c ; COMDAT __CIsqrt _TEXT SEGMENT -tv67 = -8 ; size = 8 _x$ = -8 ; size = 8 __CIsqrt PROC ; COMDAT @@ -42,33 +41,29 @@ __CIsqrt PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp - 00003 83 e4 f8 and esp, -8 ; fffffff8H - 00006 83 ec 08 sub esp, 8 + 00003 83 ec 08 sub esp, 8 ; 147 : FPU_DOUBLE(x); - 00009 dd 1c 24 fstp QWORD PTR _x$[esp+8] - 0000c 9b fwait + 00006 dd 5d f8 fstp QWORD PTR _x$[ebp] + 00009 9b fwait ; 148 : return sqrt(x); - 0000d f2 0f 10 04 24 movsd xmm0, QWORD PTR _x$[esp+8] - 00012 e8 00 00 00 00 call __libm_sse2_sqrt_precise - 00017 f2 0f 11 04 24 movsd QWORD PTR tv67[esp+8], xmm0 - 0001c dd 04 24 fld QWORD PTR tv67[esp+8] + 0000a dd 45 f8 fld QWORD PTR _x$[ebp] + 0000d e8 00 00 00 00 call __CIsqrt ; 149 : } - 0001f 8b e5 mov esp, ebp - 00021 5d pop ebp - 00022 c3 ret 0 + 00012 8b e5 mov esp, ebp + 00014 5d pop ebp + 00015 c3 ret 0 __CIsqrt ENDP _TEXT ENDS ; Function compile flags: /Ogtp ; File c:\users\philip\documents\github\mollenos\clib\crt\math.c ; COMDAT __CIsin _TEXT SEGMENT -tv67 = -8 ; size = 8 _x$ = -8 ; size = 8 __CIsin PROC ; COMDAT @@ -85,23 +80,20 @@ __CIsin PROC ; COMDAT ; 139 : return sin(x); - 0000a f2 0f 10 45 f8 movsd xmm0, QWORD PTR _x$[ebp] - 0000f e8 00 00 00 00 call __libm_sse2_sin_precise - 00014 f2 0f 11 45 f8 movsd QWORD PTR tv67[ebp], xmm0 - 00019 dd 45 f8 fld QWORD PTR tv67[ebp] + 0000a dd 45 f8 fld QWORD PTR _x$[ebp] + 0000d e8 00 00 00 00 call __CIsin ; 140 : } - 0001c 8b e5 mov esp, ebp - 0001e 5d pop ebp - 0001f c3 ret 0 + 00012 8b e5 mov esp, ebp + 00014 5d pop ebp + 00015 c3 ret 0 __CIsin ENDP _TEXT ENDS ; Function compile flags: /Ogtp ; File c:\users\philip\documents\github\mollenos\clib\crt\math.c ; COMDAT __CIlog _TEXT SEGMENT -tv67 = -8 ; size = 8 _x$ = -8 ; size = 8 __CIlog PROC ; COMDAT @@ -118,23 +110,20 @@ __CIlog PROC ; COMDAT ; 130 : return log(x); - 0000a f2 0f 10 45 f8 movsd xmm0, QWORD PTR _x$[ebp] - 0000f e8 00 00 00 00 call __libm_sse2_log_precise - 00014 f2 0f 11 45 f8 movsd QWORD PTR tv67[ebp], xmm0 - 00019 dd 45 f8 fld QWORD PTR tv67[ebp] + 0000a dd 45 f8 fld QWORD PTR _x$[ebp] + 0000d e8 00 00 00 00 call __CIlog ; 131 : } - 0001c 8b e5 mov esp, ebp - 0001e 5d pop ebp - 0001f c3 ret 0 + 00012 8b e5 mov esp, ebp + 00014 5d pop ebp + 00015 c3 ret 0 __CIlog ENDP _TEXT ENDS ; Function compile flags: /Ogtp ; File c:\users\philip\documents\github\mollenos\clib\crt\math.c ; COMDAT __CIcos _TEXT SEGMENT -tv67 = -8 ; size = 8 _x$ = -8 ; size = 8 __CIcos PROC ; COMDAT @@ -151,23 +140,20 @@ __CIcos PROC ; COMDAT ; 121 : return cos(x); - 0000a f2 0f 10 45 f8 movsd xmm0, QWORD PTR _x$[ebp] - 0000f e8 00 00 00 00 call __libm_sse2_cos_precise - 00014 f2 0f 11 45 f8 movsd QWORD PTR tv67[ebp], xmm0 - 00019 dd 45 f8 fld QWORD PTR tv67[ebp] + 0000a dd 45 f8 fld QWORD PTR _x$[ebp] + 0000d e8 00 00 00 00 call __CIcos ; 122 : } - 0001c 8b e5 mov esp, ebp - 0001e 5d pop ebp - 0001f c3 ret 0 + 00012 8b e5 mov esp, ebp + 00014 5d pop ebp + 00015 c3 ret 0 __CIcos ENDP _TEXT ENDS ; Function compile flags: /Ogtp ; File c:\users\philip\documents\github\mollenos\clib\crt\math.c ; COMDAT __CIlog10 _TEXT SEGMENT -tv67 = -8 ; size = 8 _x$ = -8 ; size = 8 __CIlog10 PROC ; COMDAT @@ -184,23 +170,20 @@ __CIlog10 PROC ; COMDAT ; 103 : return log10(x); - 0000a f2 0f 10 45 f8 movsd xmm0, QWORD PTR _x$[ebp] - 0000f e8 00 00 00 00 call __libm_sse2_log10_precise - 00014 f2 0f 11 45 f8 movsd QWORD PTR tv67[ebp], xmm0 - 00019 dd 45 f8 fld QWORD PTR tv67[ebp] + 0000a dd 45 f8 fld QWORD PTR _x$[ebp] + 0000d e8 00 00 00 00 call __CIlog10 ; 104 : } - 0001c 8b e5 mov esp, ebp - 0001e 5d pop ebp - 0001f c3 ret 0 + 00012 8b e5 mov esp, ebp + 00014 5d pop ebp + 00015 c3 ret 0 __CIlog10 ENDP _TEXT ENDS ; Function compile flags: /Ogtp ; File c:\users\philip\documents\github\mollenos\clib\crt\math.c ; COMDAT __CIexp _TEXT SEGMENT -tv67 = -8 ; size = 8 _x$ = -8 ; size = 8 __CIexp PROC ; COMDAT @@ -217,16 +200,14 @@ __CIexp PROC ; COMDAT ; 94 : return exp(x); - 0000a f2 0f 10 45 f8 movsd xmm0, QWORD PTR _x$[ebp] - 0000f e8 00 00 00 00 call __libm_sse2_exp_precise - 00014 f2 0f 11 45 f8 movsd QWORD PTR tv67[ebp], xmm0 - 00019 dd 45 f8 fld QWORD PTR tv67[ebp] + 0000a dd 45 f8 fld QWORD PTR _x$[ebp] + 0000d e8 00 00 00 00 call __CIexp ; 95 : } - 0001c 8b e5 mov esp, ebp - 0001e 5d pop ebp - 0001f c3 ret 0 + 00012 8b e5 mov esp, ebp + 00014 5d pop ebp + 00015 c3 ret 0 __CIexp ENDP _TEXT ENDS ; Function compile flags: /Ogtp @@ -323,9 +304,8 @@ _TEXT ENDS ; File c:\users\philip\documents\github\mollenos\clib\crt\math.c ; COMDAT __CIpow _TEXT SEGMENT -tv68 = -16 ; size = 8 -_y$ = -16 ; size = 8 -_x$ = -8 ; size = 8 +_x$ = -16 ; size = 8 +_y$ = -8 ; size = 8 __CIpow PROC ; COMDAT ; 11 : { @@ -336,24 +316,22 @@ __CIpow PROC ; COMDAT ; 12 : FPU_DOUBLES(x, y); - 00006 dd 5d f8 fstp QWORD PTR _x$[ebp] + 00006 dd 5d f0 fstp QWORD PTR _x$[ebp] 00009 9b fwait - 0000a dd 5d f0 fstp QWORD PTR _y$[ebp] + 0000a dd 5d f8 fstp QWORD PTR _y$[ebp] 0000d 9b fwait ; 13 : return pow(x, y); - 0000e f2 0f 10 45 f8 movsd xmm0, QWORD PTR _x$[ebp] - 00013 f2 0f 10 4d f0 movsd xmm1, QWORD PTR _y$[ebp] - 00018 e8 00 00 00 00 call __libm_sse2_pow_precise - 0001d f2 0f 11 45 f0 movsd QWORD PTR tv68[ebp], xmm0 - 00022 dd 45 f0 fld QWORD PTR tv68[ebp] + 0000e dd 45 f0 fld QWORD PTR _x$[ebp] + 00011 dd 45 f8 fld QWORD PTR _y$[ebp] + 00014 e8 00 00 00 00 call __CIpow ; 14 : } - 00025 8b e5 mov esp, ebp - 00027 5d pop ebp - 00028 c3 ret 0 + 00019 8b e5 mov esp, ebp + 0001b 5d pop ebp + 0001c c3 ret 0 __CIpow ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/memcpy.cod b/clib/mscv/CLib/memcpy.cod index e5bff9e65..066072888 100644 --- a/clib/mscv/CLib/memcpy.cod +++ b/clib/mscv/CLib/memcpy.cod @@ -145,15 +145,18 @@ _memcpy PROC ; COMDAT ; 60 : { ; 61 : #ifdef _MSC_VER ; 62 : int cpuinfo[4] = { 0 }; + + 0001c 33 c0 xor eax, eax + ; 63 : __cpuid(cpuinfo, 1); - 0001c 8d 7d f0 lea edi, DWORD PTR _cpuinfo$1[ebp] - 0001f 89 75 fc mov DWORD PTR _cpuinfo$1[ebp+12], esi - 00022 b8 01 00 00 00 mov eax, 1 - 00027 33 c9 xor ecx, ecx - 00029 0f a2 cpuid - 0002b 0f 57 c0 xorps xmm0, xmm0 - 0002e 66 0f d6 45 f4 movq QWORD PTR _cpuinfo$1[ebp+4], xmm0 + 0001e 8d 7d f0 lea edi, DWORD PTR _cpuinfo$1[ebp] + 00021 89 45 f4 mov DWORD PTR _cpuinfo$1[ebp+4], eax + 00024 33 c9 xor ecx, ecx + 00026 89 45 f8 mov DWORD PTR _cpuinfo$1[ebp+8], eax + 00029 89 45 fc mov DWORD PTR _cpuinfo$1[ebp+12], eax + 0002c b8 01 00 00 00 mov eax, 1 + 00031 0f a2 cpuid 00033 89 07 mov DWORD PTR [edi], eax 00035 89 5f 04 mov DWORD PTR [edi+4], ebx 00038 89 4f 08 mov DWORD PTR [edi+8], ecx @@ -234,79 +237,75 @@ $LN9@memcpy: ; 85 : if (!TOO_SMALL(count) && !UNALIGNED (src, dst)) 00086 8b 75 10 mov esi, DWORD PTR _count$[ebp] - 00089 8b 7d 08 mov edi, DWORD PTR _destination$[ebp] - 0008c 8b c7 mov eax, edi + 00089 8b 5d 08 mov ebx, DWORD PTR _destination$[ebp] + 0008c 8b c3 mov eax, ebx 0008e 8b 55 0c mov edx, DWORD PTR _source$[ebp] 00091 83 fe 10 cmp esi, 16 ; 00000010H - 00094 72 52 jb SHORT $LN17@memcpy - 00096 8b cf mov ecx, edi + 00094 72 4a jb SHORT $LN3@memcpy + 00096 8b cb mov ecx, ebx 00098 0b ca or ecx, edx 0009a f6 c1 03 test cl, 3 - 0009d 75 49 jne SHORT $LN17@memcpy + 0009d 75 41 jne SHORT $LN3@memcpy ; 86 : { ; 87 : aligned_dst = (long*)dst; + + 0009f 8b fe mov edi, esi + 000a1 c1 ef 04 shr edi, 4 +$LL6@memcpy: + ; 88 : aligned_src = (long*)src; ; 89 : ; 90 : /* Copy 4X long words at a time if possible. */ ; 91 : while (count >= BIGBLOCKSIZE) - - 0009f 8b da mov ebx, edx - 000a1 2b df sub ebx, edi - 000a3 8b fe mov edi, esi - 000a5 c1 ef 04 shr edi, 4 -$LL6@memcpy: - ; 92 : { ; 93 : *aligned_dst++ = *aligned_src++; - 000a8 8b 0a mov ecx, DWORD PTR [edx] + 000a4 8b 0a mov ecx, DWORD PTR [edx] ; 94 : *aligned_dst++ = *aligned_src++; ; 95 : *aligned_dst++ = *aligned_src++; ; 96 : *aligned_dst++ = *aligned_src++; ; 97 : count -= BIGBLOCKSIZE; - 000aa 83 ee 10 sub esi, 16 ; 00000010H - 000ad 89 08 mov DWORD PTR [eax], ecx - 000af 8b 4c 03 04 mov ecx, DWORD PTR [ebx+eax+4] - 000b3 89 48 04 mov DWORD PTR [eax+4], ecx - 000b6 8b 4a 08 mov ecx, DWORD PTR [edx+8] - 000b9 89 48 08 mov DWORD PTR [eax+8], ecx - 000bc 8b 4a 0c mov ecx, DWORD PTR [edx+12] - 000bf 83 c2 10 add edx, 16 ; 00000010H - 000c2 89 48 0c mov DWORD PTR [eax+12], ecx - 000c5 83 c0 10 add eax, 16 ; 00000010H - 000c8 4f dec edi - 000c9 75 dd jne SHORT $LL6@memcpy + 000a6 83 ee 10 sub esi, 16 ; 00000010H + 000a9 89 08 mov DWORD PTR [eax], ecx + 000ab 8b 4a 04 mov ecx, DWORD PTR [edx+4] + 000ae 89 48 04 mov DWORD PTR [eax+4], ecx + 000b1 8b 4a 08 mov ecx, DWORD PTR [edx+8] + 000b4 89 48 08 mov DWORD PTR [eax+8], ecx + 000b7 8b 4a 0c mov ecx, DWORD PTR [edx+12] + 000ba 83 c2 10 add edx, 16 ; 00000010H + 000bd 89 48 0c mov DWORD PTR [eax+12], ecx + 000c0 83 c0 10 add eax, 16 ; 00000010H + 000c3 4f dec edi + 000c4 75 de jne SHORT $LL6@memcpy ; 98 : } ; 99 : ; 100 : /* Copy one long word at a time if possible. */ ; 101 : while (count >= LITTLEBLOCKSIZE) - 000cb 83 fe 04 cmp esi, 4 - 000ce 72 15 jb SHORT $LN3@memcpy - 000d0 8b fe mov edi, esi - 000d2 c1 ef 02 shr edi, 2 + 000c6 83 fe 04 cmp esi, 4 + 000c9 72 15 jb SHORT $LN3@memcpy + 000cb 8b fe mov edi, esi + 000cd c1 ef 02 shr edi, 2 $LL4@memcpy: ; 102 : { ; 103 : *aligned_dst++ = *aligned_src++; - 000d5 8b 0a mov ecx, DWORD PTR [edx] + 000d0 8b 0a mov ecx, DWORD PTR [edx] ; 104 : count -= LITTLEBLOCKSIZE; - 000d7 83 ee 04 sub esi, 4 - 000da 89 08 mov DWORD PTR [eax], ecx - 000dc 83 c2 04 add edx, 4 - 000df 83 c0 04 add eax, 4 - 000e2 4f dec edi - 000e3 75 f0 jne SHORT $LL4@memcpy + 000d2 83 ee 04 sub esi, 4 + 000d5 89 08 mov DWORD PTR [eax], ecx + 000d7 83 c2 04 add edx, 4 + 000da 83 c0 04 add eax, 4 + 000dd 4f dec edi + 000de 75 f0 jne SHORT $LL4@memcpy $LN3@memcpy: - 000e5 8b 7d 08 mov edi, DWORD PTR _destination$[ebp] -$LN17@memcpy: ; 105 : } ; 106 : @@ -317,35 +316,34 @@ $LN17@memcpy: ; 111 : ; 112 : while (count--) - 000e8 85 f6 test esi, esi - 000ea 74 10 je SHORT $LN20@memcpy - 000ec 2b d0 sub edx, eax - 000ee 8b ff npad 2 + 000e0 85 f6 test esi, esi + 000e2 74 0e je SHORT $LN20@memcpy + 000e4 2b d0 sub edx, eax $LL2@memcpy: ; 113 : *dst++ = *src++; - 000f0 8a 0c 02 mov cl, BYTE PTR [edx+eax] - 000f3 8d 40 01 lea eax, DWORD PTR [eax+1] - 000f6 88 48 ff mov BYTE PTR [eax-1], cl - 000f9 4e dec esi - 000fa 75 f4 jne SHORT $LL2@memcpy + 000e6 8a 0c 02 mov cl, BYTE PTR [edx+eax] + 000e9 8d 40 01 lea eax, DWORD PTR [eax+1] + 000ec 88 48 ff mov BYTE PTR [eax-1], cl + 000ef 4e dec esi + 000f0 75 f4 jne SHORT $LL2@memcpy $LN20@memcpy: + 000f2 5f pop edi + 000f3 5e pop esi ; 114 : ; 115 : return destination; - 000fc 8b c7 mov eax, edi - 000fe 5f pop edi - 000ff 5e pop esi - 00100 5b pop ebx + 000f4 8b c3 mov eax, ebx + 000f6 5b pop ebx ; 116 : } ; 117 : } - 00101 8b e5 mov esp, ebp - 00103 5d pop ebp - 00104 c3 ret 0 + 000f7 8b e5 mov esp, ebp + 000f9 5d pop ebp + 000fa c3 ret 0 _memcpy ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/memmove.cod b/clib/mscv/CLib/memmove.cod index c1eb2f342..df1140adb 100644 --- a/clib/mscv/CLib/memmove.cod +++ b/clib/mscv/CLib/memmove.cod @@ -15,7 +15,6 @@ PUBLIC _memmove ; COMDAT _memmove _TEXT SEGMENT _destination$ = 8 ; size = 4 -tv597 = 12 ; size = 4 _source$ = 12 ; size = 4 _count$ = 16 ; size = 4 _memmove PROC ; COMDAT @@ -27,62 +26,57 @@ _memmove PROC ; COMDAT ; 12 : char *dst = (char *)destination; ; 13 : const char *src = (char *)source; + + 00003 8b 55 0c mov edx, DWORD PTR _source$[ebp] + 00006 53 push ebx + 00007 8b 5d 08 mov ebx, DWORD PTR _destination$[ebp] + 0000a 8b c3 mov eax, ebx + 0000c 56 push esi + ; 14 : long *aligned_dst; ; 15 : const long *aligned_src; ; 16 : ; 17 : if (src < dst && dst < src + count) - 00003 8b 4d 10 mov ecx, DWORD PTR _count$[ebp] - 00006 53 push ebx - 00007 8b 5d 08 mov ebx, DWORD PTR _destination$[ebp] - 0000a 8b d3 mov edx, ebx - 0000c 56 push esi - 0000d 8b 75 0c mov esi, DWORD PTR _source$[ebp] + 0000d 8b 75 10 mov esi, DWORD PTR _count$[ebp] 00010 57 push edi - 00011 3b f3 cmp esi, ebx - 00013 73 28 jae SHORT $LN11@memmove - 00015 8d 3c 0e lea edi, DWORD PTR [esi+ecx] + 00011 3b d3 cmp edx, ebx + 00013 73 26 jae SHORT $LN11@memmove + 00015 8d 3c 32 lea edi, DWORD PTR [edx+esi] 00018 3b df cmp ebx, edi - 0001a 73 21 jae SHORT $LN11@memmove + 0001a 73 1f jae SHORT $LN11@memmove ; 18 : { ; 19 : /* Destructive overlap...have to copy backwards */ ; 20 : src += count; ; 21 : dst += count; - 0001c 8d 34 0b lea esi, DWORD PTR [ebx+ecx] + 0001c 8d 14 33 lea edx, DWORD PTR [ebx+esi] ; 22 : while (count--) - 0001f 85 c9 test ecx, ecx - 00021 0f 84 85 00 00 - 00 je $LN45@memmove + 0001f 85 f6 test esi, esi + 00021 0f 84 7d 00 00 + 00 je $LN22@memmove $LL10@memmove: ; 23 : { ; 24 : *--dst = *--src; - 00027 8a 57 ff mov dl, BYTE PTR [edi-1] + 00027 8a 4f ff mov cl, BYTE PTR [edi-1] 0002a 8d 7f ff lea edi, DWORD PTR [edi-1] - 0002d 88 56 ff mov BYTE PTR [esi-1], dl - 00030 8d 76 ff lea esi, DWORD PTR [esi-1] - 00033 49 dec ecx + 0002d 88 4a ff mov BYTE PTR [edx-1], cl + 00030 8d 52 ff lea edx, DWORD PTR [edx-1] + 00033 4e dec esi 00034 75 f1 jne SHORT $LL10@memmove - -; 62 : } -; 63 : } -; 64 : -; 65 : return destination; - 00036 5f pop edi 00037 5e pop esi - 00038 8b c3 mov eax, ebx - 0003a 5b pop ebx + 00038 5b pop ebx ; 66 : } - 0003b 5d pop ebp - 0003c c3 ret 0 + 00039 5d pop ebp + 0003a c3 ret 0 $LN11@memmove: ; 25 : } @@ -94,75 +88,73 @@ $LN11@memmove: ; 31 : then punt into the byte copy loop. This should be rare. */ ; 32 : if (!TOO_SMALL(count) && !UNALIGNED (src, dst)) - 0003d 83 f9 10 cmp ecx, 16 ; 00000010H - 00040 72 53 jb SHORT $LN3@memmove - 00042 8b c3 mov eax, ebx - 00044 0b c6 or eax, esi - 00046 a8 03 test al, 3 - 00048 75 4b jne SHORT $LN3@memmove + 0003b 83 fe 10 cmp esi, 16 ; 00000010H + 0003e 72 50 jb SHORT $LN3@memmove + 00040 8b cb mov ecx, ebx + 00042 0b ca or ecx, edx + 00044 f6 c1 03 test cl, 3 + 00047 75 47 jne SHORT $LN3@memmove ; 33 : { ; 34 : aligned_dst = (long*)dst; + + 00049 8b fe mov edi, esi + 0004b c1 ef 04 shr edi, 4 + 0004e 8b ff npad 2 +$LL6@memmove: + ; 35 : aligned_src = (long*)src; ; 36 : ; 37 : /* Copy 4X long words at a time if possible. */ ; 38 : while (count >= BIGBLOCKSIZE) - - 0004a 8b c6 mov eax, esi - 0004c 8b f9 mov edi, ecx - 0004e 2b c3 sub eax, ebx - 00050 c1 ef 04 shr edi, 4 - 00053 8b d8 mov ebx, eax -$LL6@memmove: - ; 39 : { ; 40 : *aligned_dst++ = *aligned_src++; - 00055 8b 06 mov eax, DWORD PTR [esi] + 00050 8b 0a mov ecx, DWORD PTR [edx] ; 41 : *aligned_dst++ = *aligned_src++; ; 42 : *aligned_dst++ = *aligned_src++; ; 43 : *aligned_dst++ = *aligned_src++; ; 44 : count -= BIGBLOCKSIZE; - 00057 83 e9 10 sub ecx, 16 ; 00000010H - 0005a 89 02 mov DWORD PTR [edx], eax - 0005c 8b 44 13 04 mov eax, DWORD PTR [ebx+edx+4] - 00060 89 42 04 mov DWORD PTR [edx+4], eax - 00063 8b 46 08 mov eax, DWORD PTR [esi+8] - 00066 89 42 08 mov DWORD PTR [edx+8], eax - 00069 8b 46 0c mov eax, DWORD PTR [esi+12] - 0006c 83 c6 10 add esi, 16 ; 00000010H - 0006f 89 42 0c mov DWORD PTR [edx+12], eax - 00072 83 c2 10 add edx, 16 ; 00000010H - 00075 4f dec edi - 00076 75 dd jne SHORT $LL6@memmove + 00052 83 ee 10 sub esi, 16 ; 00000010H + 00055 89 08 mov DWORD PTR [eax], ecx + 00057 8b 4a 04 mov ecx, DWORD PTR [edx+4] + 0005a 89 48 04 mov DWORD PTR [eax+4], ecx + 0005d 8b 4a 08 mov ecx, DWORD PTR [edx+8] + 00060 89 48 08 mov DWORD PTR [eax+8], ecx + 00063 8b 4a 0c mov ecx, DWORD PTR [edx+12] + 00066 83 c2 10 add edx, 16 ; 00000010H + 00069 89 48 0c mov DWORD PTR [eax+12], ecx + 0006c 83 c0 10 add eax, 16 ; 00000010H + 0006f 4f dec edi + 00070 75 de jne SHORT $LL6@memmove ; 45 : } ; 46 : ; 47 : /* Copy one long word at a time if possible. */ ; 48 : while (count >= LITTLEBLOCKSIZE) - 00078 8b 5d 08 mov ebx, DWORD PTR _destination$[ebp] - 0007b 83 f9 04 cmp ecx, 4 - 0007e 72 15 jb SHORT $LN3@memmove - 00080 8b f9 mov edi, ecx - 00082 c1 ef 02 shr edi, 2 + 00072 83 fe 04 cmp esi, 4 + 00075 72 19 jb SHORT $LN3@memmove + 00077 8b fe mov edi, esi + 00079 c1 ef 02 shr edi, 2 + 0007c 8d 64 24 00 npad 4 $LL4@memmove: ; 49 : { ; 50 : *aligned_dst++ = *aligned_src++; - 00085 8b 06 mov eax, DWORD PTR [esi] + 00080 8b 0a mov ecx, DWORD PTR [edx] ; 51 : count -= LITTLEBLOCKSIZE; - 00087 83 e9 04 sub ecx, 4 - 0008a 89 02 mov DWORD PTR [edx], eax - 0008c 83 c6 04 add esi, 4 - 0008f 83 c2 04 add edx, 4 - 00092 4f dec edi - 00093 75 f0 jne SHORT $LL4@memmove + 00082 83 ee 04 sub esi, 4 + 00085 89 08 mov DWORD PTR [eax], ecx + 00087 83 c2 04 add edx, 4 + 0008a 83 c0 04 add eax, 4 + 0008d 4f dec edi + 0008e 75 f0 jne SHORT $LL4@memmove $LN3@memmove: ; 52 : } @@ -174,36 +166,36 @@ $LN3@memmove: ; 58 : ; 59 : while (count--) - 00095 85 c9 test ecx, ecx - 00097 74 13 je SHORT $LN45@memmove - 00099 2b f2 sub esi, edx - 0009b eb 03 8d 49 00 npad 5 + 00090 85 f6 test esi, esi + 00092 74 0e je SHORT $LN32@memmove + 00094 2b d0 sub edx, eax $LL2@memmove: ; 60 : { ; 61 : *dst++ = *src++; - 000a0 8a 04 16 mov al, BYTE PTR [esi+edx] - 000a3 8d 52 01 lea edx, DWORD PTR [edx+1] - 000a6 88 42 ff mov BYTE PTR [edx-1], al - 000a9 49 dec ecx - 000aa 75 f4 jne SHORT $LL2@memmove -$LN45@memmove: - 000ac 5f pop edi - 000ad 5e pop esi + 00096 8a 0c 02 mov cl, BYTE PTR [edx+eax] + 00099 8d 40 01 lea eax, DWORD PTR [eax+1] + 0009c 88 48 ff mov BYTE PTR [eax-1], cl + 0009f 4e dec esi + 000a0 75 f4 jne SHORT $LL2@memmove +$LN32@memmove: ; 62 : } ; 63 : } ; 64 : ; 65 : return destination; - 000ae 8b c3 mov eax, ebx - 000b0 5b pop ebx + 000a2 8b c3 mov eax, ebx +$LN22@memmove: + 000a4 5f pop edi + 000a5 5e pop esi + 000a6 5b pop ebx ; 66 : } - 000b1 5d pop ebp - 000b2 c3 ret 0 + 000a7 5d pop ebp + 000a8 c3 ret 0 _memmove ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/memset.cod b/clib/mscv/CLib/memset.cod index 23058cf61..1509e6126 100644 --- a/clib/mscv/CLib/memset.cod +++ b/clib/mscv/CLib/memset.cod @@ -14,7 +14,7 @@ PUBLIC _memset ; File c:\users\philip\documents\github\mollenos\clib\src\string\memset.c ; COMDAT _memset _TEXT SEGMENT -_buffer$1$ = -4 ; size = 4 +_d$1$ = -4 ; size = 4 _dest$ = 8 ; size = 4 _c$ = 12 ; size = 4 _count$ = 16 ; size = 4 @@ -28,140 +28,133 @@ _memset PROC ; COMDAT ; 15 : char *s = (char *)dest; - 00004 8b 45 08 mov eax, DWORD PTR _dest$[ebp] + 00004 8b 4d 08 mov ecx, DWORD PTR _dest$[ebp] + 00007 8b d1 mov edx, ecx + 00009 53 push ebx ; 16 : int i; ; 17 : unsigned long buffer; ; 18 : unsigned long *aligned_addr; ; 19 : unsigned int d = c & 0xff; /* To avoid sign extension, copy C to an - 00007 8b 4d 0c mov ecx, DWORD PTR _c$[ebp] + 0000a 8b 5d 0c mov ebx, DWORD PTR _c$[ebp] + 0000d 0f b6 c3 movzx eax, bl + 00010 89 45 fc mov DWORD PTR _d$1$[ebp], eax + 00013 56 push esi ; 20 : unsigned variable. */ ; 21 : ; 22 : while (UNALIGNED (s)) - 0000a 8b 55 10 mov edx, DWORD PTR _count$[ebp] - 0000d 53 push ebx - 0000e 8b d8 mov ebx, eax - 00010 56 push esi - 00011 0f b6 f1 movzx esi, cl - 00014 a8 03 test al, 3 - 00016 74 13 je SHORT $LN13@memset + 00014 8b 75 10 mov esi, DWORD PTR _count$[ebp] + 00017 f6 c1 03 test cl, 3 + 0001a 74 1a je SHORT $LN13@memset + 0001c 8d 64 24 00 npad 4 $LL14@memset: ; 23 : { ; 24 : if (count--) - 00018 8b c2 mov eax, edx - 0001a 4a dec edx - 0001b 85 c0 test eax, eax - 0001d 0f 84 86 00 00 + 00020 8b c6 mov eax, esi + 00022 4e dec esi + 00023 85 c0 test eax, eax + 00025 0f 84 87 00 00 00 je $LN12@memset ; 25 : *s++ = (char) c; - 00023 88 0b mov BYTE PTR [ebx], cl - 00025 43 inc ebx - 00026 f6 c3 03 test bl, 3 - 00029 75 ed jne SHORT $LL14@memset + 0002b 88 1a mov BYTE PTR [edx], bl + 0002d 42 inc edx + 0002e f6 c2 03 test dl, 3 + 00031 75 ed jne SHORT $LL14@memset + +; 39 : for (i = 32; i < LBLOCKSIZE * 8; i <<= 1) + + 00033 8b 45 fc mov eax, DWORD PTR _d$1$[ebp] $LN13@memset: - 0002b 57 push edi + 00036 57 push edi -; 26 : else -; 27 : return dest; ; 28 : } ; 29 : ; 30 : if (!TOO_SMALL (count)) - 0002c 83 fa 04 cmp edx, 4 - 0002f 72 57 jb SHORT $LN3@memset + 00037 83 fe 04 cmp esi, 4 + 0003a 72 4d jb SHORT $LN3@memset ; 34 : ; 35 : /* Store D into each char sized location in BUFFER so that ; 36 : we can set large blocks quickly. */ ; 37 : buffer = (d << 8) | d; - 00031 8b fe mov edi, esi - 00033 c1 e7 08 shl edi, 8 - 00036 0b fe or edi, esi + 0003c 8b f8 mov edi, eax + 0003e c1 e7 08 shl edi, 8 + 00041 0b f8 or edi, eax ; 38 : buffer |= (buffer << 16); - 00038 8b c7 mov eax, edi - 0003a c1 e0 10 shl eax, 16 ; 00000010H - 0003d 0b f8 or edi, eax - 0003f 89 7d fc mov DWORD PTR _buffer$1$[ebp], edi + 00043 8b c7 mov eax, edi + 00045 c1 e0 10 shl eax, 16 ; 00000010H + 00048 0b f8 or edi, eax -; 39 : for (i = 32; i < LBLOCKSIZE * 8; i <<= 1) ; 40 : buffer = (buffer << i) | buffer; ; 41 : ; 42 : /* Unroll the loop. */ ; 43 : while (count >= LBLOCKSIZE*4) - 00042 83 fa 10 cmp edx, 16 ; 00000010H - 00045 72 26 jb SHORT $LN20@memset + 0004a 83 fe 10 cmp esi, 16 ; 00000010H + 0004d 72 19 jb SHORT $LN20@memset ; 31 : { ; 32 : /* If we get this far, we know that n is large and s is word-aligned. */ ; 33 : aligned_addr = (unsigned long *) s; - 00047 8b f2 mov esi, edx - 00049 8b c7 mov eax, edi - 0004b c1 ee 04 shr esi, 4 - 0004e 8b fb mov edi, ebx - 00050 8b ce mov ecx, esi - 00052 81 e1 ff ff ff - 0f and ecx, 268435455 ; 0fffffffH - 00058 c1 e1 02 shl ecx, 2 - 0005b f3 ab rep stosd - -; 39 : for (i = 32; i < LBLOCKSIZE * 8; i <<= 1) -; 40 : buffer = (buffer << i) | buffer; -; 41 : -; 42 : /* Unroll the loop. */ -; 43 : while (count >= LBLOCKSIZE*4) - - 0005d 8b c6 mov eax, esi - 0005f c1 e0 04 shl eax, 4 - 00062 03 d8 add ebx, eax + 0004f 8b c6 mov eax, esi + 00051 c1 e8 04 shr eax, 4 $LL6@memset: ; 44 : { ; 45 : *aligned_addr++ = buffer; + + 00054 89 3a mov DWORD PTR [edx], edi + ; 46 : *aligned_addr++ = buffer; ; 47 : *aligned_addr++ = buffer; ; 48 : *aligned_addr++ = buffer; ; 49 : count -= 4*LBLOCKSIZE; - 00064 83 ea 10 sub edx, 16 ; 00000010H - 00067 4e dec esi - 00068 75 fa jne SHORT $LL6@memset - 0006a 8b 7d fc mov edi, DWORD PTR _buffer$1$[ebp] + 00056 83 ee 10 sub esi, 16 ; 00000010H + 00059 89 7a 04 mov DWORD PTR [edx+4], edi + 0005c 89 7a 08 mov DWORD PTR [edx+8], edi + 0005f 89 7a 0c mov DWORD PTR [edx+12], edi + 00062 83 c2 10 add edx, 16 ; 00000010H + 00065 48 dec eax + 00066 75 ec jne SHORT $LL6@memset $LN20@memset: ; 50 : } ; 51 : ; 52 : while (count >= LBLOCKSIZE) - 0006d 83 fa 04 cmp edx, 4 - 00070 72 16 jb SHORT $LN3@memset - 00072 8b f2 mov esi, edx - 00074 8b c7 mov eax, edi - 00076 c1 ee 02 shr esi, 2 - 00079 8b fb mov edi, ebx - 0007b 8b ce mov ecx, esi - 0007d f3 ab rep stosd - 0007f 8d 1c b3 lea ebx, DWORD PTR [ebx+esi*4] + 00068 83 fe 04 cmp esi, 4 + 0006b 72 1c jb SHORT $LN3@memset + 0006d 8b de mov ebx, esi + 0006f 8b c7 mov eax, edi + 00071 c1 eb 02 shr ebx, 2 + 00074 8b fa mov edi, edx + 00076 8b cb mov ecx, ebx + 00078 f3 ab rep stosd + 0007a 8d 14 9a lea edx, DWORD PTR [edx+ebx*4] + 0007d 8d 49 00 npad 3 $LL4@memset: ; 53 : { ; 54 : *aligned_addr++ = buffer; ; 55 : count -= LBLOCKSIZE; - 00082 83 ea 04 sub edx, 4 - 00085 4e dec esi - 00086 75 fa jne SHORT $LL4@memset + 00080 83 ee 04 sub esi, 4 + 00083 4b dec ebx + 00084 75 fa jne SHORT $LL4@memset + 00086 8b 5d 0c mov ebx, DWORD PTR _c$[ebp] $LN3@memset: ; 56 : } @@ -171,28 +164,27 @@ $LN3@memset: ; 60 : ; 61 : while (count--) - 00088 85 d2 test edx, edx - 0008a 74 1c je SHORT $LN2@memset - 0008c 0f b6 45 0c movzx eax, BYTE PTR _c$[ebp] - 00090 8b ca mov ecx, edx - 00092 8b f1 mov esi, ecx - 00094 69 c0 01 01 01 + 00089 85 f6 test esi, esi + 0008b 74 1b je SHORT $LN2@memset + 0008d 8a c3 mov al, bl + 0008f 8b ce mov ecx, esi + 00091 0f b6 c0 movzx eax, al + 00094 8b fa mov edi, edx + 00096 69 c0 01 01 01 01 imul eax, 16843009 ; 01010101H - 0009a c1 e9 02 shr ecx, 2 - 0009d 8b fb mov edi, ebx + 0009c c1 e9 02 shr ecx, 2 0009f f3 ab rep stosd 000a1 8b ce mov ecx, esi 000a3 83 e1 03 and ecx, 3 000a6 f3 aa rep stosb $LN2@memset: - 000a8 5f pop edi -$LN12@memset: ; 62 : *s++ = (char) c; ; 63 : ; 64 : return dest; - 000a9 8b 45 08 mov eax, DWORD PTR _dest$[ebp] + 000a8 8b 45 08 mov eax, DWORD PTR _dest$[ebp] + 000ab 5f pop edi 000ac 5e pop esi 000ad 5b pop ebx @@ -201,6 +193,20 @@ $LN12@memset: 000ae 8b e5 mov esp, ebp 000b0 5d pop ebp 000b1 c3 ret 0 +$LN12@memset: + 000b2 5e pop esi + +; 26 : else +; 27 : return dest; + + 000b3 8b c1 mov eax, ecx + 000b5 5b pop ebx + +; 65 : } + + 000b6 8b e5 mov esp, ebp + 000b8 5d pop ebp + 000b9 c3 ret 0 _memset ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/modf.cod b/clib/mscv/CLib/modf.cod index 71e03270b..7c984f69a 100644 --- a/clib/mscv/CLib/modf.cod +++ b/clib/mscv/CLib/modf.cod @@ -18,14 +18,14 @@ EXTRN __fltused:DWORD ; File c:\users\philip\documents\github\mollenos\clib\src\math\modf.c ; COMDAT _modf _TEXT SEGMENT -_iw_u$1 = -8 ; size = 8 -_iw_u$2 = -8 ; size = 8 -_iw_u$3 = -8 ; size = 8 -_ew_u$4 = -8 ; size = 8 +_iw_u$1 = 8 ; size = 8 +_iw_u$2 = 8 ; size = 8 +_gh_u$3 = 8 ; size = 8 +_iw_u$4 = 8 ; size = 8 _iw_u$5 = 8 ; size = 8 _gh_u$6 = 8 ; size = 8 _iw_u$7 = 8 ; size = 8 -_gh_u$8 = 8 ; size = 8 +_ew_u$8 = 8 ; size = 8 _x$ = 8 ; size = 8 _iptr$ = 16 ; size = 4 _modf PROC ; COMDAT @@ -34,178 +34,171 @@ _modf PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp - 00003 83 ec 08 sub esp, 8 ; 89 : __int32_t i0,i1,j_0; ; 90 : __uint32_t i; ; 91 : EXTRACT_WORDS(i0,i1,x); - 00006 f2 0f 10 45 08 movsd xmm0, QWORD PTR _x$[ebp] - 0000b f2 0f 11 45 f8 movsd QWORD PTR _ew_u$4[ebp], xmm0 + 00003 dd 45 08 fld QWORD PTR _x$[ebp] + 00006 dd 55 08 fst QWORD PTR _ew_u$8[ebp] ; 92 : j_0 = ((i0>>20)&0x7ff)-0x3ff; /* exponent of x */ - 00010 8b 55 fc mov edx, DWORD PTR _ew_u$4[ebp+4] - 00013 8b ca mov ecx, edx - 00015 c1 f9 14 sar ecx, 20 ; 00000014H - 00018 81 e1 ff 07 00 + 00009 8b 55 0c mov edx, DWORD PTR _ew_u$8[ebp+4] + 0000c 8b ca mov ecx, edx + 0000e c1 f9 14 sar ecx, 20 ; 00000014H + 00011 81 e1 ff 07 00 00 and ecx, 2047 ; 000007ffH - 0001e 81 e9 ff 03 00 + 00017 81 e9 ff 03 00 00 sub ecx, 1023 ; 000003ffH ; 93 : if(j_0<20) { /* integer part in high x */ - 00024 83 f9 14 cmp ecx, 20 ; 00000014H - 00027 7d 7c jge SHORT $LN37@modf + 0001d 83 f9 14 cmp ecx, 20 ; 00000014H + 00020 7d 63 jge SHORT $LN37@modf ; 94 : if(j_0<0) { /* |x|<1 */ - 00029 85 c9 test ecx, ecx - 0002b 79 23 jns SHORT $LN36@modf + 00022 85 c9 test ecx, ecx + 00024 79 1a jns SHORT $LN36@modf ; 95 : INSERT_WORDS(*iptr,i0&0x80000000U,0); /* *iptr = +-0 */ - 0002d 8b 45 10 mov eax, DWORD PTR _iptr$[ebp] - 00030 81 e2 00 00 00 + 00026 8b 45 10 mov eax, DWORD PTR _iptr$[ebp] + 00029 81 e2 00 00 00 80 and edx, -2147483648 ; 80000000H - -; 96 : return x; - - 00036 dd 45 08 fld QWORD PTR _x$[ebp] - 00039 89 55 fc mov DWORD PTR _iw_u$3[ebp+4], edx - 0003c c7 45 f8 00 00 - 00 00 mov DWORD PTR _iw_u$3[ebp], 0 - 00043 f2 0f 10 45 f8 movsd xmm0, QWORD PTR _iw_u$3[ebp] - 00048 f2 0f 11 00 movsd QWORD PTR [eax], xmm0 + 0002f 89 55 0c mov DWORD PTR _iw_u$7[ebp+4], edx + 00032 c7 45 08 00 00 + 00 00 mov DWORD PTR _iw_u$7[ebp], 0 + 00039 dd 45 08 fld QWORD PTR _iw_u$7[ebp] + 0003c dd 18 fstp QWORD PTR [eax] ; 127 : } ; 128 : } ; 129 : } - 0004c 8b e5 mov esp, ebp - 0004e 5d pop ebp - 0004f c3 ret 0 + 0003e 5d pop ebp + 0003f c3 ret 0 $LN36@modf: - 00050 56 push esi + 00040 56 push esi +; 96 : return x; ; 97 : } else { ; 98 : i = (0x000fffff)>>j_0; - 00051 be ff ff 0f 00 mov esi, 1048575 ; 000fffffH - 00056 d3 fe sar esi, cl + 00041 be ff ff 0f 00 mov esi, 1048575 ; 000fffffH + 00046 d3 fe sar esi, cl ; 99 : if(((i0&i)|i1)==0) { /* x is integral */ - 00058 8b c6 mov eax, esi - 0005a 23 c2 and eax, edx - 0005c 0b 45 f8 or eax, DWORD PTR _ew_u$4[ebp] + 00048 8b c6 mov eax, esi + 0004a 23 c2 and eax, edx + 0004c 0b 45 08 or eax, DWORD PTR _ew_u$8[ebp] ; 100 : __uint32_t high; ; 101 : *iptr = x; - 0005f 8b 45 10 mov eax, DWORD PTR _iptr$[ebp] - 00062 75 1f jne SHORT $LN23@modf + 0004f 8b 45 10 mov eax, DWORD PTR _iptr$[ebp] + 00052 75 19 jne SHORT $LN23@modf + 00054 dd 10 fst QWORD PTR [eax] ; 102 : GET_HIGH_WORD(high,x); - 00064 f2 0f 11 45 08 movsd QWORD PTR _gh_u$8[ebp], xmm0 + 00056 dd 5d 08 fstp QWORD PTR _gh_u$6[ebp] ; 103 : INSERT_WORDS(x,high&0x80000000U,0); /* return +-0 */ - 00069 81 65 0c 00 00 - 00 80 and DWORD PTR _gh_u$8[ebp+4], -2147483648 ; 80000000H - 00070 c7 45 08 00 00 - 00 00 mov DWORD PTR _iw_u$7[ebp], 0 + 00059 81 65 0c 00 00 + 00 80 and DWORD PTR _gh_u$6[ebp+4], -2147483648 ; 80000000H + 00060 c7 45 08 00 00 + 00 00 mov DWORD PTR _iw_u$5[ebp], 0 ; 104 : return x; - 00077 dd 45 08 fld QWORD PTR _iw_u$7[ebp] - 0007a f2 0f 11 00 movsd QWORD PTR [eax], xmm0 - 0007e 5e pop esi + 00067 dd 45 08 fld QWORD PTR _iw_u$5[ebp] + 0006a 5e pop esi ; 127 : } ; 128 : } ; 129 : } - 0007f 8b e5 mov esp, ebp - 00081 5d pop ebp - 00082 c3 ret 0 + 0006b 5d pop ebp + 0006c c3 ret 0 $LN23@modf: ; 105 : } else { ; 106 : INSERT_WORDS(*iptr,i0&(~i),0); + + 0006d f7 d6 not esi + 0006f c7 45 08 00 00 + 00 00 mov DWORD PTR _iw_u$4[ebp], 0 + 00076 23 f2 and esi, edx + 00078 89 75 0c mov DWORD PTR _iw_u$4[ebp+4], esi + 0007b dd 45 08 fld QWORD PTR _iw_u$4[ebp] + 0007e dd 10 fst QWORD PTR [eax] + ; 107 : return x - *iptr; - 00083 dd 45 08 fld QWORD PTR _x$[ebp] - 00086 f7 d6 not esi - 00088 23 f2 and esi, edx - 0008a c7 45 f8 00 00 - 00 00 mov DWORD PTR _iw_u$2[ebp], 0 - 00091 89 75 fc mov DWORD PTR _iw_u$2[ebp+4], esi - 00094 f2 0f 10 45 f8 movsd xmm0, QWORD PTR _iw_u$2[ebp] - 00099 dc 65 f8 fsub QWORD PTR _iw_u$2[ebp] - 0009c 5e pop esi - 0009d f2 0f 11 00 movsd QWORD PTR [eax], xmm0 + 00080 de e9 fsubp ST(1), ST(0) + 00082 5e pop esi ; 127 : } ; 128 : } ; 129 : } - 000a1 8b e5 mov esp, ebp - 000a3 5d pop ebp - 000a4 c3 ret 0 + 00083 5d pop ebp + 00084 c3 ret 0 $LN37@modf: ; 108 : } ; 109 : } ; 110 : } else if (j_0>51) { /* no fraction part */ - 000a5 83 f9 33 cmp ecx, 51 ; 00000033H - 000a8 7e 21 jle SHORT $LN19@modf -$LN44@modf: + 00085 83 f9 33 cmp ecx, 51 ; 00000033H + 00088 7e 1b jle SHORT $LN19@modf +$LN59@modf: ; 111 : __uint32_t high; ; 112 : *iptr = x*one; - 000aa 8b 45 10 mov eax, DWORD PTR _iptr$[ebp] + 0008a 8b 45 10 mov eax, DWORD PTR _iptr$[ebp] + 0008d dd 10 fst QWORD PTR [eax] ; 113 : GET_HIGH_WORD(high,x); - 000ad f2 0f 11 45 08 movsd QWORD PTR _gh_u$6[ebp], xmm0 + 0008f dd 5d 08 fstp QWORD PTR _gh_u$3[ebp] ; 114 : INSERT_WORDS(x,high&0x80000000U,0); /* return +-0 */ - 000b2 81 65 0c 00 00 - 00 80 and DWORD PTR _gh_u$6[ebp+4], -2147483648 ; 80000000H - 000b9 c7 45 08 00 00 - 00 00 mov DWORD PTR _iw_u$5[ebp], 0 + 00092 81 65 0c 00 00 + 00 80 and DWORD PTR _gh_u$3[ebp+4], -2147483648 ; 80000000H + 00099 c7 45 08 00 00 + 00 00 mov DWORD PTR _iw_u$2[ebp], 0 ; 115 : return x; - 000c0 dd 45 08 fld QWORD PTR _iw_u$5[ebp] - 000c3 f2 0f 11 00 movsd QWORD PTR [eax], xmm0 + 000a0 dd 45 08 fld QWORD PTR _iw_u$2[ebp] ; 127 : } ; 128 : } ; 129 : } - 000c7 8b e5 mov esp, ebp - 000c9 5d pop ebp - 000ca c3 ret 0 + 000a3 5d pop ebp + 000a4 c3 ret 0 $LN19@modf: ; 116 : } else { /* fraction part in low x */ ; 117 : i = ((__uint32_t)(0xffffffffU))>>(j_0-20); - 000cb 83 c1 ec add ecx, -20 ; ffffffecH - 000ce 83 c8 ff or eax, -1 - 000d1 d3 e8 shr eax, cl + 000a5 83 c1 ec add ecx, -20 ; ffffffecH + 000a8 83 c8 ff or eax, -1 + 000ab d3 e8 shr eax, cl ; 118 : if((i1&i)==0) { /* x is integral */ - 000d3 8b 4d f8 mov ecx, DWORD PTR _ew_u$4[ebp] - 000d6 85 c1 test eax, ecx - 000d8 74 d0 je SHORT $LN44@modf + 000ad 8b 4d 08 mov ecx, DWORD PTR _ew_u$8[ebp] + 000b0 85 c1 test eax, ecx + 000b2 74 d6 je SHORT $LN59@modf ; 119 : __uint32_t high; ; 120 : *iptr = x; @@ -214,25 +207,25 @@ $LN19@modf: ; 123 : return x; ; 124 : } else { ; 125 : INSERT_WORDS(*iptr,i0,i1&(~i)); + + 000b4 f7 d0 not eax + 000b6 89 55 0c mov DWORD PTR _iw_u$1[ebp+4], edx + 000b9 23 c1 and eax, ecx + 000bb 89 45 08 mov DWORD PTR _iw_u$1[ebp], eax + 000be 8b 45 10 mov eax, DWORD PTR _iptr$[ebp] + 000c1 dd 45 08 fld QWORD PTR _iw_u$1[ebp] + 000c4 dd 10 fst QWORD PTR [eax] + ; 126 : return x - *iptr; - 000da dd 45 08 fld QWORD PTR _x$[ebp] - 000dd f7 d0 not eax - 000df 23 c1 and eax, ecx - 000e1 89 55 fc mov DWORD PTR _iw_u$1[ebp+4], edx - 000e4 89 45 f8 mov DWORD PTR _iw_u$1[ebp], eax - 000e7 8b 45 10 mov eax, DWORD PTR _iptr$[ebp] - 000ea f2 0f 10 45 f8 movsd xmm0, QWORD PTR _iw_u$1[ebp] - 000ef dc 65 f8 fsub QWORD PTR _iw_u$1[ebp] - 000f2 f2 0f 11 00 movsd QWORD PTR [eax], xmm0 + 000c6 de e9 fsubp ST(1), ST(0) ; 127 : } ; 128 : } ; 129 : } - 000f6 8b e5 mov esp, ebp - 000f8 5d pop ebp - 000f9 c3 ret 0 + 000c8 5d pop ebp + 000c9 c3 ret 0 _modf ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/pow.cod b/clib/mscv/CLib/pow.cod index b9df1f949..5354813d9 100644 --- a/clib/mscv/CLib/pow.cod +++ b/clib/mscv/CLib/pow.cod @@ -48,6 +48,7 @@ _DATA SEGMENT _sccsid DB '@(#)e_pow.c 1.5 04/04/22 SMI', 00H _DATA ENDS PUBLIC _pow +PUBLIC __real@0000000000000000 PUBLIC __real@01a56e1fc2f8f359 PUBLIC __real@3c971547652b82fe PUBLIC __real@3e205c610ca86c39 @@ -79,21 +80,9 @@ PUBLIC __real@4008000000000000 PUBLIC __real@4340000000000000 PUBLIC __real@7e37e43c8800759c PUBLIC __real@bff0000000000000 -PUBLIC __xmm@7fffffffffffffff7fffffffffffffff -PUBLIC __xmm@80000000000000008000000000000000 EXTRN _scalbn:PROC -EXTRN __libm_sse2_sqrt_precise:PROC +EXTRN __CIsqrt:PROC EXTRN __fltused:DWORD -; COMDAT __xmm@80000000000000008000000000000000 -CONST SEGMENT -__xmm@80000000000000008000000000000000 DB 00H, 00H, 00H, 00H, 00H, 00H, 00H - DB 080H, 00H, 00H, 00H, 00H, 00H, 00H, 00H, 080H -CONST ENDS -; COMDAT __xmm@7fffffffffffffff7fffffffffffffff -CONST SEGMENT -__xmm@7fffffffffffffff7fffffffffffffff DB 0ffH, 0ffH, 0ffH, 0ffH, 0ffH, 0ffH - DB 0ffH, 07fH, 0ffH, 0ffH, 0ffH, 0ffH, 0ffH, 0ffH, 0ffH, 07fH -CONST ENDS ; COMDAT __real@bff0000000000000 CONST SEGMENT __real@bff0000000000000 DQ 0bff0000000000000r ; -1 @@ -218,31 +207,28 @@ CONST ENDS CONST SEGMENT __real@01a56e1fc2f8f359 DQ 001a56e1fc2f8f359r ; 1e-300 CONST ENDS +; COMDAT __real@0000000000000000 +CONST SEGMENT +__real@0000000000000000 DQ 00000000000000000r ; 0 +CONST ENDS ; Function compile flags: /Ogtp ; File c:\users\philip\documents\github\mollenos\clib\src\math\pow.c ; COMDAT _pow _TEXT SEGMENT -_n$1$ = -24 ; size = 4 -_j$2$ = -24 ; size = 4 -_j$1$ = -24 ; size = 4 -_t_h$1 = -24 ; size = 8 -_t1$ = -24 ; size = 8 -_t$ = -24 ; size = 8 -_z$ = -24 ; size = 8 -_s$ = -16 ; size = 8 -_t2$1$ = -8 ; size = 8 -tv1040 = -8 ; size = 8 -_y1$ = -8 ; size = 8 -_p_h$ = -8 ; size = 8 -tv211 = -8 ; size = 8 -tv204 = -8 ; size = 8 -tv197 = -8 ; size = 8 -tv192 = -8 ; size = 8 -tv144 = -8 ; size = 8 -tv141 = -8 ; size = 8 -_s_h$2 = -8 ; size = 8 -_ax$ = -8 ; size = 8 +_ss$1$ = -32 ; size = 8 +_p_h$ = -24 ; size = 8 +_s_h$1 = -24 ; size = 8 +_t_h$2 = -16 ; size = 8 +_ax$ = -16 ; size = 8 +_s$1$ = -8 ; size = 8 +_j$2$ = -4 ; size = 4 +_j$1$ = -4 ; size = 4 +_y1$ = 8 ; size = 8 +_t1$ = 8 ; size = 8 +_t$ = 8 ; size = 8 +_z$ = 8 ; size = 8 _x$ = 8 ; size = 8 +_n$ = 12 ; size = 4 _y$ = 16 ; size = 8 _pow PROC ; COMDAT @@ -250,7 +236,6 @@ _pow PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp - 00003 83 e4 f8 and esp, -8 ; fffffff8H ; 104 : double z,ax,z_h,z_l,p_h,p_l; ; 105 : double y1,t1,t2,r,s,t,u,v,w; @@ -263,34 +248,37 @@ _pow PROC ; COMDAT ; 112 : hy = __HI(y); ly = __LO(y); ; 113 : ix = hx&0x7fffffff; iy = hy&0x7fffffff; - 00006 8b 4d 0c mov ecx, DWORD PTR _x$[ebp+4] - 00009 83 ec 18 sub esp, 24 ; 00000018H - 0000c 8b d1 mov edx, ecx - 0000e 81 e2 ff ff ff + 00003 8b 4d 0c mov ecx, DWORD PTR _x$[ebp+4] + 00006 83 ec 20 sub esp, 32 ; 00000020H + 00009 8b d1 mov edx, ecx + 0000b 81 e2 ff ff ff 7f and edx, 2147483647 ; 7fffffffH - 00014 56 push esi - 00015 57 push edi - 00016 8b 7d 14 mov edi, DWORD PTR _y$[ebp+4] - 00019 8b f7 mov esi, edi - 0001b 81 e6 ff ff ff - 7f and esi, 2147483647 ; 7fffffffH + 00011 53 push ebx ; 114 : ; 115 : /* y==zero: x**0 = 1 */ ; 116 : if((iy|ly)==0) return one; - 00021 8b c6 mov eax, esi - 00023 0b 45 10 or eax, DWORD PTR _y$[ebp] - 00026 75 08 jne SHORT $LN60@pow + 00012 8b 5d 10 mov ebx, DWORD PTR _y$[ebp] + 00015 56 push esi + 00016 57 push edi + 00017 8b 7d 14 mov edi, DWORD PTR _y$[ebp+4] + 0001a 8b f7 mov esi, edi + 0001c 81 e6 ff ff ff + 7f and esi, 2147483647 ; 7fffffffH + 00022 8b c6 mov eax, esi + 00024 0b c3 or eax, ebx + 00026 75 09 jne SHORT $LN60@pow 00028 d9 e8 fld1 + 0002a 5f pop edi + 0002b 5e pop esi + 0002c 5b pop ebx ; 306 : } - 0002a 5f pop edi - 0002b 5e pop esi - 0002c 8b e5 mov esp, ebp - 0002e 5d pop ebp - 0002f c3 ret 0 + 0002d 8b e5 mov esp, ebp + 0002f 5d pop ebp + 00030 c3 ret 0 $LN60@pow: ; 117 : @@ -298,22 +286,22 @@ $LN60@pow: ; 119 : if(ix > 0x7ff00000 || ((ix==0x7ff00000)&&(lx!=0)) || ; 120 : iy > 0x7ff00000 || ((iy==0x7ff00000)&&(ly!=0))) - 00030 81 fa 00 00 f0 + 00031 81 fa 00 00 f0 7f cmp edx, 2146435072 ; 7ff00000H - 00036 0f 8f 8e 08 00 + 00037 0f 8f a0 06 00 00 jg $LN58@pow - 0003c 75 0a jne SHORT $LN57@pow - 0003e 83 7d 08 00 cmp DWORD PTR _x$[ebp], 0 - 00042 0f 85 82 08 00 + 0003d 75 0a jne SHORT $LN57@pow + 0003f 83 7d 08 00 cmp DWORD PTR _x$[ebp], 0 + 00043 0f 85 94 06 00 00 jne $LN58@pow $LN57@pow: - 00048 81 fe 00 00 f0 + 00049 81 fe 00 00 f0 7f cmp esi, 2146435072 ; 7ff00000H - 0004e 0f 8f 76 08 00 + 0004f 0f 8f 88 06 00 00 jg $LN58@pow - 00054 75 0a jne SHORT $LN59@pow - 00056 83 7d 10 00 cmp DWORD PTR _y$[ebp], 0 - 0005a 0f 85 6a 08 00 + 00055 75 08 jne SHORT $LN59@pow + 00057 85 db test ebx, ebx + 00059 0f 85 7e 06 00 00 jne $LN58@pow $LN59@pow: @@ -324,82 +312,124 @@ $LN59@pow: ; 126 : * yisint = 2 ... y is an even int ; 127 : */ ; 128 : yisint = 0; + + 0005f 33 db xor ebx, ebx + ; 129 : if(hx<0) { - 00060 85 c9 test ecx, ecx - 00062 0f 89 80 00 00 - 00 jns $LN80@pow + 00061 85 c9 test ecx, ecx + 00063 79 0d jns SHORT $LN48@pow ; 130 : if(iy>=0x43400000) yisint = 2; /* even integer y */ - 00068 81 fe 00 00 40 + 00065 81 fe 00 00 40 43 cmp esi, 1128267776 ; 43400000H - 0006e 7c 07 jl SHORT $LN55@pow - 00070 b9 02 00 00 00 mov ecx, 2 - 00075 eb 73 jmp SHORT $LN48@pow + 0006b 7c 32 jl SHORT $LN55@pow + 0006d bb 02 00 00 00 mov ebx, 2 +$LN48@pow: + +; 139 : } +; 140 : } +; 141 : } +; 142 : +; 143 : /* special value of y */ +; 144 : if(ly==0) { + + 00072 83 7d 10 00 cmp DWORD PTR _y$[ebp], 0 + 00076 0f 85 13 01 00 + 00 jne $LN77@pow +$LN75@pow: + +; 145 : if (iy==0x7ff00000) { /* y is +-inf */ + + 0007c 81 fe 00 00 f0 + 7f cmp esi, 2146435072 ; 7ff00000H + 00082 0f 85 b3 00 00 + 00 jne $LN42@pow + +; 146 : if(((ix-0x3ff00000)|lx)==0) + + 00088 8d 82 00 00 10 + c0 lea eax, DWORD PTR [edx-1072693248] + 0008e 0b 45 08 or eax, DWORD PTR _x$[ebp] + 00091 75 79 jne SHORT $LN45@pow + +; 147 : return y - y; /* inf**+-1 is NaN */ + + 00093 dd 45 10 fld QWORD PTR _y$[ebp] + 00096 5f pop edi + 00097 5e pop esi + 00098 dc e8 fsub ST(0), ST(0) + 0009a 5b pop ebx + +; 306 : } + + 0009b 8b e5 mov esp, ebp + 0009d 5d pop ebp + 0009e c3 ret 0 $LN55@pow: ; 131 : else if(iy>=0x3ff00000) { - 00077 81 fe 00 00 f0 + 0009f 81 fe 00 00 f0 3f cmp esi, 1072693248 ; 3ff00000H - 0007d 7c 69 jl SHORT $LN80@pow + 000a5 7c cb jl SHORT $LN48@pow ; 132 : k = (iy>>20)-0x3ff; /* exponent */ - 0007f 8b c6 mov eax, esi - 00081 c1 f8 14 sar eax, 20 ; 00000014H - 00084 2d ff 03 00 00 sub eax, 1023 ; 000003ffH + 000a7 8b c6 mov eax, esi + 000a9 c1 f8 14 sar eax, 20 ; 00000014H + 000ac 2d ff 03 00 00 sub eax, 1023 ; 000003ffH ; 133 : if(k>20) { - 00089 83 f8 14 cmp eax, 20 ; 00000014H - 0008c 7e 29 jle SHORT $LN52@pow + 000b1 83 f8 14 cmp eax, 20 ; 00000014H + 000b4 7e 25 jle SHORT $LN52@pow ; 134 : j = ly>>(52-k); - 0008e b9 34 00 00 00 mov ecx, 52 ; 00000034H - 00093 2b c8 sub ecx, eax - 00095 8b 45 10 mov eax, DWORD PTR _y$[ebp] - 00098 d3 e8 shr eax, cl - 0009a 89 44 24 08 mov DWORD PTR _j$1$[esp+32], eax + 000b6 b9 34 00 00 00 mov ecx, 52 ; 00000034H + 000bb 2b c8 sub ecx, eax + 000bd 8b 45 10 mov eax, DWORD PTR _y$[ebp] + 000c0 d3 e8 shr eax, cl + 000c2 89 45 fc mov DWORD PTR _j$1$[ebp], eax ; 135 : if((j<<(52-k))== (int)ly) yisint = 2-(j&1); - 0009e d3 e0 shl eax, cl - 000a0 3b 45 10 cmp eax, DWORD PTR _y$[ebp] - 000a3 75 43 jne SHORT $LN80@pow - 000a5 8b 4c 24 08 mov ecx, DWORD PTR _j$1$[esp+32] - 000a9 b8 02 00 00 00 mov eax, 2 - 000ae 83 e1 01 and ecx, 1 - 000b1 2b c1 sub eax, ecx + 000c5 d3 e0 shl eax, cl + 000c7 3b 45 10 cmp eax, DWORD PTR _y$[ebp] + 000ca 75 a6 jne SHORT $LN48@pow + 000cc 8b 45 fc mov eax, DWORD PTR _j$1$[ebp] + 000cf bb 02 00 00 00 mov ebx, 2 + 000d4 83 e0 01 and eax, 1 + 000d7 2b d8 sub ebx, eax ; 136 : } else if(ly==0) { - 000b3 8b c8 mov ecx, eax - 000b5 eb 33 jmp SHORT $LN48@pow + 000d9 eb 97 jmp SHORT $LN48@pow $LN52@pow: - 000b7 83 7d 10 00 cmp DWORD PTR _y$[ebp], 0 - 000bb 0f 85 19 01 00 - 00 jne $LN76@pow + 000db 8b 4d 10 mov ecx, DWORD PTR _y$[ebp] + 000de 85 c9 test ecx, ecx + 000e0 0f 85 a9 00 00 + 00 jne $LN77@pow ; 137 : j = iy>>(20-k); - 000c1 b9 14 00 00 00 mov ecx, 20 ; 00000014H - 000c6 2b c8 sub ecx, eax - 000c8 8b c6 mov eax, esi - 000ca d3 f8 sar eax, cl - 000cc 89 44 24 08 mov DWORD PTR _j$2$[esp+32], eax + 000e6 b9 14 00 00 00 mov ecx, 20 ; 00000014H + 000eb 2b c8 sub ecx, eax + 000ed 8b c6 mov eax, esi + 000ef d3 f8 sar eax, cl + 000f1 89 45 fc mov DWORD PTR _j$2$[ebp], eax ; 138 : if((j<<(20-k))==iy) yisint = 2-(j&1); - 000d0 d3 e0 shl eax, cl - 000d2 3b c6 cmp eax, esi - 000d4 75 20 jne SHORT $LN77@pow - 000d6 8b 4c 24 08 mov ecx, DWORD PTR _j$2$[esp+32] - 000da b8 02 00 00 00 mov eax, 2 - 000df 83 e1 01 and ecx, 1 - 000e2 2b c1 sub eax, ecx + 000f4 d3 e0 shl eax, cl + 000f6 3b c6 cmp eax, esi + 000f8 75 82 jne SHORT $LN75@pow + 000fa 8b 45 fc mov eax, DWORD PTR _j$2$[ebp] + 000fd bb 02 00 00 00 mov ebx, 2 + 00102 83 e0 01 and eax, 1 + 00105 2b d8 sub ebx, eax ; 139 : } ; 140 : } @@ -408,207 +438,145 @@ $LN52@pow: ; 143 : /* special value of y */ ; 144 : if(ly==0) { - 000e4 8b c8 mov ecx, eax - 000e6 eb 10 jmp SHORT $LN75@pow -$LN80@pow: - 000e8 33 c9 xor ecx, ecx -$LN48@pow: - 000ea 83 7d 10 00 cmp DWORD PTR _y$[ebp], 0 - 000ee 0f 85 e8 00 00 - 00 jne $LN81@pow - 000f4 eb 02 jmp SHORT $LN75@pow -$LN77@pow: - 000f6 33 c9 xor ecx, ecx -$LN75@pow: - -; 145 : if (iy==0x7ff00000) { /* y is +-inf */ - - 000f8 81 fe 00 00 f0 - 7f cmp esi, 2146435072 ; 7ff00000H - 000fe 75 7e jne SHORT $LN42@pow - -; 146 : if(((ix-0x3ff00000)|lx)==0) - - 00100 8d 82 00 00 10 - c0 lea eax, DWORD PTR [edx-1072693248] - 00106 0b 45 08 or eax, DWORD PTR _x$[ebp] - 00109 75 0b jne SHORT $LN45@pow - -; 147 : return y - y; /* inf**+-1 is NaN */ - - 0010b dd 45 10 fld QWORD PTR _y$[ebp] - 0010e dc e8 fsub ST(0), ST(0) - -; 306 : } - - 00110 5f pop edi - 00111 5e pop esi - 00112 8b e5 mov esp, ebp - 00114 5d pop ebp - 00115 c3 ret 0 + 00107 e9 70 ff ff ff jmp $LN75@pow $LN45@pow: ; 148 : else if (ix >= 0x3ff00000)/* (|x|>1)**+-inf = inf,0 */ - 00116 81 fa 00 00 f0 + 0010c 81 fa 00 00 f0 3f cmp edx, 1072693248 ; 3ff00000H - 0011c 7c 2c jl SHORT $LN43@pow + 00112 7c 17 jl SHORT $LN43@pow ; 149 : return (hy>=0)? y: zero; - 0011e 85 ff test edi, edi - 00120 78 15 js SHORT $LN63@pow - 00122 f2 0f 10 45 10 movsd xmm0, QWORD PTR _y$[ebp] - 00127 f2 0f 11 44 24 - 18 movsd QWORD PTR tv141[esp+32], xmm0 - 0012d dd 44 24 18 fld QWORD PTR tv141[esp+32] + 00114 85 ff test edi, edi + 00116 78 0a js SHORT $LN63@pow + 00118 dd 45 10 fld QWORD PTR _y$[ebp] + 0011b 5f pop edi + 0011c 5e pop esi + 0011d 5b pop ebx ; 306 : } - 00131 5f pop edi - 00132 5e pop esi - 00133 8b e5 mov esp, ebp - 00135 5d pop ebp - 00136 c3 ret 0 + 0011e 8b e5 mov esp, ebp + 00120 5d pop ebp + 00121 c3 ret 0 $LN63@pow: - 00137 0f 57 c0 xorps xmm0, xmm0 ; 149 : return (hy>=0)? y: zero; - 0013a f2 0f 11 44 24 - 18 movsd QWORD PTR tv141[esp+32], xmm0 - 00140 dd 44 24 18 fld QWORD PTR tv141[esp+32] + 00122 d9 ee fldz + 00124 5f pop edi + 00125 5e pop esi + 00126 5b pop ebx ; 306 : } - 00144 5f pop edi - 00145 5e pop esi - 00146 8b e5 mov esp, ebp - 00148 5d pop ebp - 00149 c3 ret 0 + 00127 8b e5 mov esp, ebp + 00129 5d pop ebp + 0012a c3 ret 0 $LN43@pow: ; 150 : else /* (|x|<1)**-,+inf = inf,0 */ ; 151 : return (hy<0)?-y: zero; - 0014a 85 ff test edi, edi - 0014c 79 1d jns SHORT $LN65@pow - 0014e f2 0f 10 45 10 movsd xmm0, QWORD PTR _y$[ebp] - 00153 66 0f 57 05 00 - 00 00 00 xorpd xmm0, QWORD PTR __xmm@80000000000000008000000000000000 - 0015b f2 0f 11 44 24 - 18 movsd QWORD PTR tv144[esp+32], xmm0 - 00161 dd 44 24 18 fld QWORD PTR tv144[esp+32] + 0012b 85 ff test edi, edi + 0012d 79 f3 jns SHORT $LN63@pow + 0012f dd 45 10 fld QWORD PTR _y$[ebp] + 00132 5f pop edi + 00133 5e pop esi + 00134 d9 e0 fchs + 00136 5b pop ebx ; 306 : } - 00165 5f pop edi - 00166 5e pop esi - 00167 8b e5 mov esp, ebp - 00169 5d pop ebp - 0016a c3 ret 0 -$LN65@pow: - 0016b 0f 57 c0 xorps xmm0, xmm0 - -; 150 : else /* (|x|<1)**-,+inf = inf,0 */ -; 151 : return (hy<0)?-y: zero; - - 0016e f2 0f 11 44 24 - 18 movsd QWORD PTR tv144[esp+32], xmm0 - 00174 dd 44 24 18 fld QWORD PTR tv144[esp+32] - -; 306 : } - - 00178 5f pop edi - 00179 5e pop esi - 0017a 8b e5 mov esp, ebp - 0017c 5d pop ebp - 0017d c3 ret 0 + 00137 8b e5 mov esp, ebp + 00139 5d pop ebp + 0013a c3 ret 0 $LN42@pow: ; 152 : } ; 153 : if(iy==0x3ff00000) { /* y is +-1 */ - 0017e 81 fe 00 00 f0 + 0013b 81 fe 00 00 f0 3f cmp esi, 1072693248 ; 3ff00000H - 00184 75 18 jne SHORT $LN39@pow + 00141 75 1a jne SHORT $LN39@pow ; 154 : if(hy<0) return one/x; else return x; - 00186 85 ff test edi, edi - 00188 79 0b jns SHORT $LN40@pow - 0018a d9 e8 fld1 - 0018c dc 75 08 fdiv QWORD PTR _x$[ebp] + 00143 85 ff test edi, edi + 00145 79 0c jns SHORT $LN40@pow + 00147 d9 e8 fld1 + 00149 dc 75 08 fdiv QWORD PTR _x$[ebp] + 0014c 5f pop edi + 0014d 5e pop esi + 0014e 5b pop ebx ; 306 : } - 0018f 5f pop edi - 00190 5e pop esi - 00191 8b e5 mov esp, ebp - 00193 5d pop ebp - 00194 c3 ret 0 + 0014f 8b e5 mov esp, ebp + 00151 5d pop ebp + 00152 c3 ret 0 $LN40@pow: ; 154 : if(hy<0) return one/x; else return x; - 00195 dd 45 08 fld QWORD PTR _x$[ebp] + 00153 dd 45 08 fld QWORD PTR _x$[ebp] + 00156 5f pop edi + 00157 5e pop esi + 00158 5b pop ebx ; 306 : } - 00198 5f pop edi - 00199 5e pop esi - 0019a 8b e5 mov esp, ebp - 0019c 5d pop ebp - 0019d c3 ret 0 + 00159 8b e5 mov esp, ebp + 0015b 5d pop ebp + 0015c c3 ret 0 $LN39@pow: ; 155 : } ; 156 : if(hy==0x40000000) return x*x; /* y is 2 */ - 0019e 81 ff 00 00 00 + 0015d 81 ff 00 00 00 40 cmp edi, 1073741824 ; 40000000H - 001a4 75 0b jne SHORT $LN38@pow - 001a6 dd 45 08 fld QWORD PTR _x$[ebp] - 001a9 dc c8 fmul ST(0), ST(0) + 00163 75 0c jne SHORT $LN38@pow + 00165 dd 45 08 fld QWORD PTR _x$[ebp] + 00168 5f pop edi + 00169 5e pop esi + 0016a dc c8 fmul ST(0), ST(0) + 0016c 5b pop ebx ; 306 : } - 001ab 5f pop edi - 001ac 5e pop esi - 001ad 8b e5 mov esp, ebp - 001af 5d pop ebp - 001b0 c3 ret 0 + 0016d 8b e5 mov esp, ebp + 0016f 5d pop ebp + 00170 c3 ret 0 $LN38@pow: ; 157 : if(hy==0x3fe00000) { /* y is 0.5 */ ; 158 : if(hx>=0) /* x >= +0 */ - 001b1 8b 45 0c mov eax, DWORD PTR _x$[ebp+4] - 001b4 81 ff 00 00 e0 + 00171 8b 4d 0c mov ecx, DWORD PTR _x$[ebp+4] + 00174 81 ff 00 00 e0 3f cmp edi, 1071644672 ; 3fe00000H - 001ba 75 23 jne SHORT $LN36@pow - 001bc 85 c0 test eax, eax - 001be 78 1f js SHORT $LN36@pow + 0017a 75 16 jne SHORT $LN36@pow + 0017c 85 c9 test ecx, ecx + 0017e 78 12 js SHORT $LN36@pow ; 159 : return sqrt(x); - 001c0 f2 0f 10 45 08 movsd xmm0, QWORD PTR _x$[ebp] - 001c5 e8 00 00 00 00 call __libm_sse2_sqrt_precise - 001ca f2 0f 11 44 24 - 18 movsd QWORD PTR tv1040[esp+32], xmm0 - 001d0 dd 44 24 18 fld QWORD PTR tv1040[esp+32] + 00180 dd 45 08 fld QWORD PTR _x$[ebp] + 00183 e8 00 00 00 00 call __CIsqrt + 00188 5f pop edi + 00189 5e pop esi + 0018a 5b pop ebx ; 306 : } - 001d4 5f pop edi - 001d5 5e pop esi - 001d6 8b e5 mov esp, ebp - 001d8 5d pop ebp - 001d9 c3 ret 0 -$LN76@pow: - 001da 33 c9 xor ecx, ecx -$LN81@pow: - 001dc 8b 45 0c mov eax, DWORD PTR _x$[ebp+4] + 0018b 8b e5 mov esp, ebp + 0018d 5d pop ebp + 0018e c3 ret 0 +$LN77@pow: + 0018f 8b 4d 0c mov ecx, DWORD PTR _x$[ebp+4] $LN36@pow: ; 160 : } @@ -618,468 +586,387 @@ $LN36@pow: ; 164 : /* special value of x */ ; 165 : if(lx==0) { - 001df 83 7d 08 00 cmp DWORD PTR _x$[ebp], 0 - 001e3 f2 0f 10 5d 08 movsd xmm3, QWORD PTR _x$[ebp] - 001e8 66 0f 54 1d 00 - 00 00 00 andpd xmm3, QWORD PTR __xmm@7fffffffffffffff7fffffffffffffff - 001f0 f2 0f 11 5c 24 - 18 movsd QWORD PTR _ax$[esp+32], xmm3 - 001f6 75 76 jne SHORT $LN34@pow + 00192 83 7d 08 00 cmp DWORD PTR _x$[ebp], 0 + 00196 dd 45 08 fld QWORD PTR _x$[ebp] + 00199 d9 c0 fld ST(0) + 0019b d9 e1 fabs + 0019d dd 55 f0 fst QWORD PTR _ax$[ebp] + 001a0 75 4d jne SHORT $LN34@pow ; 166 : if(ix==0x7ff00000||ix==0||ix==0x3ff00000){ - 001f8 81 fa 00 00 f0 + 001a2 81 fa 00 00 f0 7f cmp edx, 2146435072 ; 7ff00000H - 001fe 74 0c je SHORT $LN33@pow - 00200 85 d2 test edx, edx - 00202 74 08 je SHORT $LN33@pow - 00204 81 fa 00 00 f0 + 001a8 74 0c je SHORT $LN90@pow + 001aa 85 d2 test edx, edx + 001ac 74 08 je SHORT $LN90@pow + 001ae 81 fa 00 00 f0 3f cmp edx, 1072693248 ; 3ff00000H - 0020a 75 62 jne SHORT $LN34@pow -$LN33@pow: + 001b4 75 39 jne SHORT $LN34@pow +$LN90@pow: + 001b6 dd d9 fstp ST(1) ; 167 : z = ax; /*x is +-0,+-inf,+-1*/ - - 0020c f2 0f 11 5c 24 - 08 movsd QWORD PTR _z$[esp+32], xmm3 - ; 168 : if(hy<0) z = one/z; /* z = (1/|x|) */ - 00212 85 ff test edi, edi - 00214 79 15 jns SHORT $LN32@pow - 00216 f2 0f 10 05 00 - 00 00 00 movsd xmm0, QWORD PTR __real@3ff0000000000000 - 0021e f2 0f 5e c3 divsd xmm0, xmm3 - 00222 0f 28 d8 movaps xmm3, xmm0 - 00225 f2 0f 11 5c 24 - 08 movsd QWORD PTR _z$[esp+32], xmm3 + 001b8 85 ff test edi, edi + 001ba 79 04 jns SHORT $LN32@pow + 001bc d9 e8 fld1 + 001be de f1 fdivrp ST(1), ST(0) $LN32@pow: ; 169 : if(hx<0) { - 0022b 85 c0 test eax, eax - 0022d 79 35 jns SHORT $LN28@pow + 001c0 85 c9 test ecx, ecx + 001c2 0f 89 1b 05 00 + 00 jns $LN61@pow ; 170 : if(((ix-0x3ff00000)|yisint)==0) { - 0022f 8d 82 00 00 10 + 001c8 8d 82 00 00 10 c0 lea eax, DWORD PTR [edx-1072693248] - 00235 0b c1 or eax, ecx - 00237 75 18 jne SHORT $LN30@pow + 001ce 0b c3 or eax, ebx + 001d0 75 0b jne SHORT $LN30@pow ; 171 : z = (z-z)/(z-z); /* (-1)**non-int is NaN */ - 00239 f2 0f 5c db subsd xmm3, xmm3 - 0023d f2 0f 5e db divsd xmm3, xmm3 - -; 173 : z = -z; /* (x<0)**odd = -(|x|**odd) */ - - 00241 f2 0f 11 5c 24 - 08 movsd QWORD PTR _z$[esp+32], xmm3 - -; 174 : } -; 175 : return z; - - 00247 dd 44 24 08 fld QWORD PTR _z$[esp+32] + 001d2 dc e0 fsubr ST(0), ST(0) + 001d4 5f pop edi + 001d5 5e pop esi + 001d6 5b pop ebx + 001d7 dc f8 fdiv ST(0), ST(0) ; 306 : } - 0024b 5f pop edi - 0024c 5e pop esi - 0024d 8b e5 mov esp, ebp - 0024f 5d pop ebp - 00250 c3 ret 0 + 001d9 8b e5 mov esp, ebp + 001db 5d pop ebp + 001dc c3 ret 0 $LN30@pow: ; 172 : } else if(yisint==1) - 00251 83 f9 01 cmp ecx, 1 - 00254 75 0e jne SHORT $LN28@pow + 001dd 83 fb 01 cmp ebx, 1 + 001e0 0f 85 fd 04 00 + 00 jne $LN61@pow ; 173 : z = -z; /* (x<0)**odd = -(|x|**odd) */ - 00256 66 0f 57 1d 00 - 00 00 00 xorpd xmm3, QWORD PTR __xmm@80000000000000008000000000000000 - 0025e f2 0f 11 5c 24 - 08 movsd QWORD PTR _z$[esp+32], xmm3 -$LN28@pow: - -; 174 : } -; 175 : return z; - - 00264 dd 44 24 08 fld QWORD PTR _z$[esp+32] + 001e6 5f pop edi + 001e7 5e pop esi + 001e8 d9 e0 fchs + 001ea 5b pop ebx ; 306 : } - 00268 5f pop edi - 00269 5e pop esi - 0026a 8b e5 mov esp, ebp - 0026c 5d pop ebp - 0026d c3 ret 0 + 001eb 8b e5 mov esp, ebp + 001ed 5d pop ebp + 001ee c3 ret 0 $LN34@pow: +; 174 : } +; 175 : return z; ; 176 : } ; 177 : } ; 178 : ; 179 : n = (hx>>31)+1; - 0026e c1 f8 1f sar eax, 31 ; 0000001fH - 00271 40 inc eax - 00272 89 44 24 08 mov DWORD PTR _n$1$[esp+32], eax + 001ef c1 f9 1f sar ecx, 31 ; 0000001fH + 001f2 41 inc ecx ; 180 : ; 181 : /* (x<0)**(non-int) is NaN */ ; 182 : if((n|yisint)==0) return (x-x)/(x-x); - 00276 0b c1 or eax, ecx - 00278 75 0d jne SHORT $LN27@pow - 0027a dd 45 08 fld QWORD PTR _x$[ebp] - 0027d dc e8 fsub ST(0), ST(0) - 0027f dc f8 fdiv ST(0), ST(0) + 001f3 8b c1 mov eax, ecx + 001f5 0b c3 or eax, ebx + 001f7 75 0d jne SHORT $LN103@pow + 001f9 dd d8 fstp ST(0) + 001fb dc e8 fsub ST(0), ST(0) + 001fd 5f pop edi + 001fe 5e pop esi + 001ff 5b pop ebx + 00200 dc f8 fdiv ST(0), ST(0) ; 306 : } - 00281 5f pop edi - 00282 5e pop esi - 00283 8b e5 mov esp, ebp - 00285 5d pop ebp - 00286 c3 ret 0 -$LN27@pow: + 00202 8b e5 mov esp, ebp + 00204 5d pop ebp + 00205 c3 ret 0 +$LN103@pow: + 00206 dd d9 fstp ST(1) ; 183 : ; 184 : s = one; /* s (sign of result -ve**odd) = -1 else = 1 */ - - 00287 f2 0f 10 35 00 - 00 00 00 movsd xmm6, QWORD PTR __real@3ff0000000000000 - ; 185 : if((n|(yisint-1))==0) s = -one;/* (-ve)**(odd int) */ - 0028f 8d 41 ff lea eax, DWORD PTR [ecx-1] - 00292 0b 44 24 08 or eax, DWORD PTR _n$1$[esp+32] - 00296 66 0f 28 ce movapd xmm1, xmm6 - 0029a f2 0f 11 4c 24 - 10 movsd QWORD PTR _s$[esp+32], xmm1 - 002a0 75 0e jne SHORT $LN26@pow - 002a2 f2 0f 10 0d 00 - 00 00 00 movsd xmm1, QWORD PTR __real@bff0000000000000 - 002aa f2 0f 11 4c 24 - 10 movsd QWORD PTR _s$[esp+32], xmm1 + 00208 8d 43 ff lea eax, DWORD PTR [ebx-1] + 0020b 0b c1 or eax, ecx + 0020d d9 e8 fld1 + 0020f d9 c0 fld ST(0) + 00211 dd 55 f8 fst QWORD PTR _s$1$[ebp] + 00214 75 0b jne SHORT $LN26@pow + 00216 dd d8 fstp ST(0) + 00218 dd 05 00 00 00 + 00 fld QWORD PTR __real@bff0000000000000 + 0021e dd 55 f8 fst QWORD PTR _s$1$[ebp] $LN26@pow: ; 186 : ; 187 : /* |y| is huge */ ; 188 : if(iy>0x41e00000) { /* if |y| > 2**31 */ - 002b0 81 fe 00 00 e0 + 00221 d9 ee fldz + 00223 81 fe 00 00 e0 41 cmp esi, 1105199104 ; 41e00000H - 002b6 0f 8e 8e 01 00 - 00 jle $LN25@pow + 00229 0f 8e e6 00 00 + 00 jle $LN109@pow ; 189 : if(iy>0x43f00000){ /* if |y| > 2**64, must o/uflow */ - 002bc 81 fe 00 00 f0 + 0022f 81 fe 00 00 f0 43 cmp esi, 1139802112 ; 43f00000H - 002c2 7e 6e jle SHORT $LN22@pow + 00235 7e 3e jle SHORT $LN22@pow ; 190 : if(ix<=0x3fefffff) return (hy<0)? huge*huge:tiny*tiny; - 002c4 81 fa ff ff ef + 00237 dd d9 fstp ST(1) + 00239 dd da fstp ST(2) + 0023b dd d8 fstp ST(0) + 0023d dd d8 fstp ST(0) + 0023f 81 fa ff ff ef 3f cmp edx, 1072693247 ; 3fefffffH - 002ca 7f 33 jg SHORT $LN23@pow - 002cc 85 ff test edi, edi - 002ce 79 1c jns SHORT $LN67@pow - 002d0 f2 0f 10 05 00 - 00 00 00 movsd xmm0, QWORD PTR __real@7e37e43c8800759c - 002d8 f2 0f 59 c0 mulsd xmm0, xmm0 - 002dc f2 0f 11 44 24 - 18 movsd QWORD PTR tv192[esp+32], xmm0 - 002e2 dd 44 24 18 fld QWORD PTR tv192[esp+32] - -; 306 : } - - 002e6 5f pop edi - 002e7 5e pop esi - 002e8 8b e5 mov esp, ebp - 002ea 5d pop ebp - 002eb c3 ret 0 -$LN67@pow: - 002ec 0f 57 c0 xorps xmm0, xmm0 - -; 190 : if(ix<=0x3fefffff) return (hy<0)? huge*huge:tiny*tiny; - - 002ef f2 0f 11 44 24 - 18 movsd QWORD PTR tv192[esp+32], xmm0 - 002f5 dd 44 24 18 fld QWORD PTR tv192[esp+32] + 00245 7f 17 jg SHORT $LN23@pow + 00247 85 ff test edi, edi + 00249 0f 89 d3 fe ff + ff jns $LN63@pow + 0024f dd 05 00 00 00 + 00 fld QWORD PTR __real@7e37e43c8800759c + 00255 5f pop edi + 00256 5e pop esi + 00257 dc c8 fmul ST(0), ST(0) + 00259 5b pop ebx ; 306 : } - 002f9 5f pop edi - 002fa 5e pop esi - 002fb 8b e5 mov esp, ebp - 002fd 5d pop ebp - 002fe c3 ret 0 + 0025a 8b e5 mov esp, ebp + 0025c 5d pop ebp + 0025d c3 ret 0 $LN23@pow: ; 191 : if(ix>=0x3ff00000) return (hy>0)? huge*huge:tiny*tiny; - 002ff 85 ff test edi, edi - 00301 7e 1c jle SHORT $LN69@pow - 00303 f2 0f 10 05 00 - 00 00 00 movsd xmm0, QWORD PTR __real@7e37e43c8800759c - 0030b f2 0f 59 c0 mulsd xmm0, xmm0 - 0030f f2 0f 11 44 24 - 18 movsd QWORD PTR tv197[esp+32], xmm0 - 00315 dd 44 24 18 fld QWORD PTR tv197[esp+32] - -; 306 : } - - 00319 5f pop edi - 0031a 5e pop esi - 0031b 8b e5 mov esp, ebp - 0031d 5d pop ebp - 0031e c3 ret 0 -$LN69@pow: - 0031f 0f 57 c0 xorps xmm0, xmm0 - -; 191 : if(ix>=0x3ff00000) return (hy>0)? huge*huge:tiny*tiny; - - 00322 f2 0f 11 44 24 - 18 movsd QWORD PTR tv197[esp+32], xmm0 - 00328 dd 44 24 18 fld QWORD PTR tv197[esp+32] + 0025e 85 ff test edi, edi + 00260 0f 8e bc fe ff + ff jle $LN63@pow + 00266 dd 05 00 00 00 + 00 fld QWORD PTR __real@7e37e43c8800759c + 0026c 5f pop edi + 0026d 5e pop esi + 0026e dc c8 fmul ST(0), ST(0) + 00270 5b pop ebx ; 306 : } - 0032c 5f pop edi - 0032d 5e pop esi - 0032e 8b e5 mov esp, ebp - 00330 5d pop ebp - 00331 c3 ret 0 + 00271 8b e5 mov esp, ebp + 00273 5d pop ebp + 00274 c3 ret 0 $LN22@pow: ; 192 : } ; 193 : /* over/underflow if x is not close to one */ ; 194 : if(ix<0x3fefffff) return (hy<0)? s*huge*huge:s*tiny*tiny; - 00332 81 fa ff ff ef + 00275 81 fa ff ff ef 3f cmp edx, 1072693247 ; 3fefffffH - 00338 7d 44 jge SHORT $LN21@pow - 0033a 85 ff test edi, edi - 0033c 79 20 jns SHORT $LN71@pow - 0033e f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@7e37e43c8800759c - 00346 f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@7e37e43c8800759c - 0034e f2 0f 11 4c 24 - 18 movsd QWORD PTR tv204[esp+32], xmm1 - 00354 dd 44 24 18 fld QWORD PTR tv204[esp+32] - -; 306 : } - - 00358 5f pop edi - 00359 5e pop esi - 0035a 8b e5 mov esp, ebp - 0035c 5d pop ebp - 0035d c3 ret 0 + 0027b 7d 1b jge SHORT $LN21@pow + 0027d dd db fstp ST(3) + 0027f dd d9 fstp ST(1) + 00281 dd d9 fstp ST(1) + 00283 85 ff test edi, edi + 00285 78 23 js SHORT $LN173@pow $LN71@pow: - -; 192 : } -; 193 : /* over/underflow if x is not close to one */ -; 194 : if(ix<0x3fefffff) return (hy<0)? s*huge*huge:s*tiny*tiny; - - 0035e f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@01a56e1fc2f8f359 - 00366 f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@01a56e1fc2f8f359 - 0036e f2 0f 11 4c 24 - 18 movsd QWORD PTR tv204[esp+32], xmm1 - 00374 dd 44 24 18 fld QWORD PTR tv204[esp+32] + 00287 dd 05 00 00 00 + 00 fld QWORD PTR __real@01a56e1fc2f8f359 + 0028d dc c9 fmul ST(1), ST(0) + 0028f 5f pop edi + 00290 5e pop esi + 00291 5b pop ebx + 00292 de c9 fmulp ST(1), ST(0) ; 306 : } - 00378 5f pop edi - 00379 5e pop esi - 0037a 8b e5 mov esp, ebp - 0037c 5d pop ebp - 0037d c3 ret 0 + 00294 8b e5 mov esp, ebp + 00296 5d pop ebp + 00297 c3 ret 0 $LN21@pow: ; 195 : if(ix>0x3ff00000) return (hy>0)? s*huge*huge:s*tiny*tiny; - 0037e 81 fa 00 00 f0 + 00298 81 fa 00 00 f0 3f cmp edx, 1072693248 ; 3ff00000H - 00384 7e 44 jle SHORT $LN20@pow - 00386 85 ff test edi, edi - 00388 7e 20 jle SHORT $LN73@pow - 0038a f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@7e37e43c8800759c - 00392 f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@7e37e43c8800759c - 0039a f2 0f 11 4c 24 - 18 movsd QWORD PTR tv211[esp+32], xmm1 - 003a0 dd 44 24 18 fld QWORD PTR tv211[esp+32] - -; 306 : } - - 003a4 5f pop edi - 003a5 5e pop esi - 003a6 8b e5 mov esp, ebp - 003a8 5d pop ebp - 003a9 c3 ret 0 -$LN73@pow: - -; 195 : if(ix>0x3ff00000) return (hy>0)? s*huge*huge:s*tiny*tiny; - - 003aa f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@01a56e1fc2f8f359 - 003b2 f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@01a56e1fc2f8f359 - 003ba f2 0f 11 4c 24 - 18 movsd QWORD PTR tv211[esp+32], xmm1 - 003c0 dd 44 24 18 fld QWORD PTR tv211[esp+32] + 0029e 7e 1b jle SHORT $LN122@pow + 002a0 dd db fstp ST(3) + 002a2 dd d9 fstp ST(1) + 002a4 dd d9 fstp ST(1) + 002a6 85 ff test edi, edi + 002a8 7e dd jle SHORT $LN71@pow +$LN173@pow: + 002aa dd 05 00 00 00 + 00 fld QWORD PTR __real@7e37e43c8800759c + 002b0 dc c9 fmul ST(1), ST(0) + 002b2 5f pop edi + 002b3 5e pop esi + 002b4 5b pop ebx + 002b5 de c9 fmulp ST(1), ST(0) ; 306 : } - 003c4 5f pop edi - 003c5 5e pop esi - 003c6 8b e5 mov esp, ebp - 003c8 5d pop ebp - 003c9 c3 ret 0 -$LN20@pow: + 002b7 8b e5 mov esp, ebp + 002b9 5d pop ebp + 002ba c3 ret 0 +$LN122@pow: + 002bb dd d9 fstp ST(1) ; 196 : /* now |1-x| is tiny <= 2**-20, suffice to compute ; 197 : log(x) by x-x^2/2+x^3/3-x^4/4 */ ; 198 : t = ax-one; /* t has 20 trailing zeros */ -; 199 : w = (t*t)*(0.5-t*(0.3333333333333333333333-t*0.25)); - 003ca f2 0f 10 0d 00 - 00 00 00 movsd xmm1, QWORD PTR __real@3fd5555555555555 - 003d2 f2 0f 5c de subsd xmm3, xmm6 - 003d6 66 0f 28 c3 movapd xmm0, xmm3 + 002bd d9 ca fxch ST(2) + 002bf d8 e1 fsub ST(0), ST(1) +; 199 : w = (t*t)*(0.5-t*(0.3333333333333333333333-t*0.25)); ; 200 : u = ivln2_h*t; /* ivln2_h has 21 sig. bits */ - 003da 66 0f 28 d3 movapd xmm2, xmm3 - 003de f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@3fd0000000000000 + 002c1 dd 05 00 00 00 + 00 fld QWORD PTR __real@3ff7154760000000 + 002c7 d8 c9 fmul ST(0), ST(1) ; 201 : v = t*ivln2_l-w*ivln2; - 003e6 66 0f 28 eb movapd xmm5, xmm3 - 003ea f2 0f 59 2d 00 - 00 00 00 mulsd xmm5, QWORD PTR __real@3e54ae0bf85ddf44 - 003f2 f2 0f 59 15 00 - 00 00 00 mulsd xmm2, QWORD PTR __real@3ff7154760000000 - 003fa f2 0f 5c c8 subsd xmm1, xmm0 - 003fe f2 0f 10 05 00 - 00 00 00 movsd xmm0, QWORD PTR __real@3fe0000000000000 - 00406 f2 0f 59 cb mulsd xmm1, xmm3 - 0040a f2 0f 59 db mulsd xmm3, xmm3 - 0040e f2 0f 5c c1 subsd xmm0, xmm1 - 00412 f2 0f 59 c3 mulsd xmm0, xmm3 - 00416 f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@3ff71547652b82fe - 0041e f2 0f 5c e8 subsd xmm5, xmm0 + 002c9 d9 c1 fld ST(1) + 002cb dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3e54ae0bf85ddf44 + 002d1 d9 c2 fld ST(2) + 002d3 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3fd0000000000000 + 002d9 dc 2d 00 00 00 + 00 fsubr QWORD PTR __real@3fd5555555555555 + 002df d8 cb fmul ST(0), ST(3) + 002e1 dc 2d 00 00 00 + 00 fsubr QWORD PTR __real@3fe0000000000000 + 002e7 d9 cb fxch ST(3) + 002e9 dc c8 fmul ST(0), ST(0) + 002eb de cb fmulp ST(3), ST(0) + 002ed d9 ca fxch ST(2) + 002ef dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3ff71547652b82fe + 002f5 de ea fsubp ST(2), ST(0) ; 202 : t1 = u+v; - 00422 66 0f 28 c5 movapd xmm0, xmm5 - 00426 f2 0f 58 c2 addsd xmm0, xmm2 - 0042a f2 0f 11 44 24 - 08 movsd QWORD PTR _t1$[esp+32], xmm0 + 002f7 d9 c1 fld ST(1) + 002f9 d8 c1 fadd ST(0), ST(1) + 002fb dd 5d 08 fstp QWORD PTR _t1$[ebp] ; 203 : __LO(t1) = 0; - 00430 c7 44 24 08 00 - 00 00 00 mov DWORD PTR _t1$[esp+32], 0 + 002fe c7 45 08 00 00 + 00 00 mov DWORD PTR _t1$[ebp], 0 ; 204 : t2 = v-(t1-u); - 00438 f2 0f 10 7c 24 - 08 movsd xmm7, QWORD PTR _t1$[esp+32] - 0043e 0f 28 c7 movaps xmm0, xmm7 - 00441 f2 0f 5c c2 subsd xmm0, xmm2 + 00305 dd 45 08 fld QWORD PTR _t1$[ebp] + 00308 d9 c0 fld ST(0) + 0030a de e2 fsubrp ST(2), ST(0) + 0030c d9 ca fxch ST(2) + 0030e de e1 fsubrp ST(1), ST(0) ; 205 : } else { - 00445 e9 40 02 00 00 jmp $LN91@pow -$LN25@pow: + 00310 e9 c0 01 00 00 jmp $LN19@pow +$LN109@pow: ; 206 : double ss,s2,s_h,s_l,t_h,t_l; ; 207 : n = 0; - 0044a 33 c9 xor ecx, ecx + 00315 33 c9 xor ecx, ecx + 00317 dd d9 fstp ST(1) ; 208 : /* take care subnormal number */ ; 209 : if(ix<0x00100000) - 0044c 81 fa 00 00 10 + 00319 81 fa 00 00 10 00 cmp edx, 1048576 ; 00100000H - 00452 7d 17 jge SHORT $LN18@pow + 0031f 7d 15 jge SHORT $LN157@pow ; 210 : {ax *= two53; n -= 53; ix = __HI(ax); } - 00454 f2 0f 59 1d 00 - 00 00 00 mulsd xmm3, QWORD PTR __real@4340000000000000 - 0045c b9 cb ff ff ff mov ecx, -53 ; ffffffcbH - 00461 f2 0f 11 5c 24 - 18 movsd QWORD PTR _ax$[esp+32], xmm3 - 00467 8b 54 24 1c mov edx, DWORD PTR _ax$[esp+36] + 00321 d9 ca fxch ST(2) + 00323 b9 cb ff ff ff mov ecx, -53 ; ffffffcbH + 00328 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@4340000000000000 + 0032e dd 5d f0 fstp QWORD PTR _ax$[ebp] + 00331 8b 55 f4 mov edx, DWORD PTR _ax$[ebp+4] + 00334 eb 02 jmp SHORT $LN18@pow +$LN157@pow: + 00336 dd da fstp ST(2) $LN18@pow: ; 211 : n += ((ix)>>20)-0x3ff; - 0046b 8b f2 mov esi, edx - 0046d 81 c1 01 fc ff + 00338 8b c2 mov eax, edx + 0033a 81 c1 01 fc ff ff add ecx, -1023 ; fffffc01H - 00473 c1 fe 14 sar esi, 20 ; 00000014H + 00340 c1 f8 14 sar eax, 20 ; 00000014H ; 212 : j = ix&0x000fffff; - 00476 81 e2 ff ff 0f + 00343 81 e2 ff ff 0f 00 and edx, 1048575 ; 000fffffH - 0047c 03 f1 add esi, ecx + 00349 03 c1 add eax, ecx ; 213 : /* determine interval */ ; 214 : ix = j|0x3ff00000; /* normalize ix */ - 0047e 8b ca mov ecx, edx - 00480 81 c9 00 00 f0 + 0034b 8b ca mov ecx, edx + 0034d 81 c9 00 00 f0 3f or ecx, 1072693248 ; 3ff00000H + 00353 89 45 0c mov DWORD PTR _n$[ebp], eax ; 215 : if(j<=0x3988E) k=0; /* |x|>1)|0x20000000)+0x00080000+(k<<18); - 004b3 8d 42 02 lea eax, DWORD PTR [edx+2] - 004b6 89 4c 24 1c mov DWORD PTR _ax$[esp+36], ecx - 004ba 66 0f 28 c3 movapd xmm0, xmm3 - 004be f2 0f 10 64 24 - 18 movsd xmm4, QWORD PTR _ax$[esp+32] - 004c4 66 0f 28 d6 movapd xmm2, xmm6 - 004c8 f2 0f 58 c4 addsd xmm0, xmm4 - 004cc c1 e0 12 shl eax, 18 ; 00000012H - 004cf 66 0f 28 fc movapd xmm7, xmm4 - 004d3 81 c9 00 00 00 + 00380 8d 42 02 lea eax, DWORD PTR [edx+2] + 00383 dd 45 f0 fld QWORD PTR _ax$[ebp] + 00386 81 c9 00 00 00 40 or ecx, 1073741824 ; 40000000H - 004d9 f2 0f 5c fb subsd xmm7, xmm3 - 004dd d1 f9 sar ecx, 1 - 004df 03 c8 add ecx, eax - 004e1 f2 0f 5e d0 divsd xmm2, xmm0 - 004e5 0f 57 c0 xorps xmm0, xmm0 - 004e8 f2 0f 11 44 24 - 08 movsd QWORD PTR _t_h$1[esp+32], xmm0 - 004ee 66 0f 28 f2 movapd xmm6, xmm2 - 004f2 f2 0f 59 f7 mulsd xmm6, xmm7 - 004f6 89 4c 24 0c mov DWORD PTR _t_h$1[esp+36], ecx + 0038c d9 c0 fld ST(0) + 0038e d1 f9 sar ecx, 1 + 00390 dc 24 d5 00 00 + 00 00 fsub QWORD PTR _bp[edx*8] + 00397 c1 e0 12 shl eax, 18 ; 00000012H + 0039a 03 c8 add ecx, eax + 0039c d9 c1 fld ST(1) + 0039e dc 04 d5 00 00 + 00 00 fadd QWORD PTR _bp[edx*8] + 003a5 de fb fdivp ST(3), ST(0) + 003a7 d9 c2 fld ST(2) + 003a9 d8 c9 fmul ST(0), ST(1) + 003ab dd 55 e0 fst QWORD PTR _ss$1$[ebp] + 003ae dd 55 e8 fst QWORD PTR _s_h$1[ebp] + 003b1 d9 cc fxch ST(4) + 003b3 c7 45 e8 00 00 + 00 00 mov DWORD PTR _s_h$1[ebp], 0 + 003ba dd 5d f0 fstp QWORD PTR _t_h$2[ebp] + 003bd 89 4d f4 mov DWORD PTR _t_h$2[ebp+4], ecx ; 229 : t_l = ax - (t_h-bp[k]); ; 230 : s_l = v*((u-s_h*t_h)-s_h*t_l); - 004fa f2 0f 10 4c 24 - 08 movsd xmm1, QWORD PTR _t_h$1[esp+32] - 00500 0f 28 c1 movaps xmm0, xmm1 - 00503 f2 0f 5c cb subsd xmm1, xmm3 - 00507 f2 0f 11 74 24 - 18 movsd QWORD PTR _s_h$2[esp+32], xmm6 - 0050d c7 44 24 18 00 - 00 00 00 mov DWORD PTR _s_h$2[esp+32], 0 - 00515 f2 0f 10 6c 24 - 18 movsd xmm5, QWORD PTR _s_h$2[esp+32] - 0051b f2 0f 59 c5 mulsd xmm0, xmm5 - 0051f f2 0f 5c e1 subsd xmm4, xmm1 + 003c0 dd 45 f0 fld QWORD PTR _t_h$2[ebp] + 003c3 d9 c0 fld ST(0) + 003c5 dd 45 e8 fld QWORD PTR _s_h$1[ebp] + 003c8 dc c9 fmul ST(1), ST(0) + 003ca d9 cb fxch ST(3) + 003cc de e1 fsubrp ST(1), ST(0) + 003ce d9 c9 fxch ST(1) + 003d0 dc 24 d5 00 00 + 00 00 fsub QWORD PTR _bp[edx*8] + 003d7 de eb fsubp ST(3), ST(0) + 003d9 d9 ca fxch ST(2) + 003db d8 c9 fmul ST(0), ST(1) + 003dd de ea fsubp ST(2), ST(0) + 003df d9 c9 fxch ST(1) + 003e1 de ca fmulp ST(2), ST(0) ; 231 : /* compute log(ax) */ ; 232 : s2 = ss*ss; + + 003e3 d9 c2 fld ST(2) + 003e5 d8 cb fmul ST(0), ST(3) + ; 233 : r = s2*s2*(L1+s2*(L2+s2*(L3+s2*(L4+s2*(L5+s2*L6))))); + + 003e7 dd 05 00 00 00 + 00 fld QWORD PTR __real@3fca7e284a454eef + 003ed d8 c9 fmul ST(0), ST(1) + 003ef dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fcd864a93c9db65 + 003f5 d8 c9 fmul ST(0), ST(1) + 003f7 dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fd17460a91d4101 + 003fd d8 c9 fmul ST(0), ST(1) + 003ff dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fd55555518f264d + 00405 d8 c9 fmul ST(0), ST(1) + 00407 dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fdb6db6db6fabff + 0040d d8 c9 fmul ST(0), ST(1) + 0040f dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fe3333333333303 + 00415 d9 c9 fxch ST(1) + 00417 dc c8 fmul ST(0), ST(0) + 00419 de c9 fmulp ST(1), ST(0) + ; 234 : r += s_l*(s_h+ss); + + 0041b d9 c1 fld ST(1) + 0041d de c4 faddp ST(4), ST(0) + 0041f d9 cb fxch ST(3) + 00421 d8 ca fmul ST(0), ST(2) + 00423 de c3 faddp ST(3), ST(0) + ; 235 : s2 = s_h*s_h; - 00523 0f 28 dd movaps xmm3, xmm5 - 00526 f2 0f 59 dd mulsd xmm3, xmm5 - 0052a f2 0f 5c f8 subsd xmm7, xmm0 - 0052e f2 0f 59 e5 mulsd xmm4, xmm5 - 00532 0f 28 c6 movaps xmm0, xmm6 - 00535 f2 0f 59 c6 mulsd xmm0, xmm6 - 00539 f2 0f 5c fc subsd xmm7, xmm4 - 0053d f2 0f 59 fa mulsd xmm7, xmm2 - 00541 66 0f 28 d0 movapd xmm2, xmm0 - 00545 f2 0f 59 15 00 - 00 00 00 mulsd xmm2, QWORD PTR __real@3fca7e284a454eef - 0054d f2 0f 58 15 00 - 00 00 00 addsd xmm2, QWORD PTR __real@3fcd864a93c9db65 - 00555 f2 0f 59 d0 mulsd xmm2, xmm0 - 00559 f2 0f 58 15 00 - 00 00 00 addsd xmm2, QWORD PTR __real@3fd17460a91d4101 - 00561 f2 0f 59 d0 mulsd xmm2, xmm0 - 00565 f2 0f 58 15 00 - 00 00 00 addsd xmm2, QWORD PTR __real@3fd55555518f264d - 0056d f2 0f 59 d0 mulsd xmm2, xmm0 - 00571 f2 0f 58 15 00 - 00 00 00 addsd xmm2, QWORD PTR __real@3fdb6db6db6fabff - 00579 f2 0f 59 d0 mulsd xmm2, xmm0 - 0057d f2 0f 59 c0 mulsd xmm0, xmm0 - 00581 f2 0f 58 15 00 - 00 00 00 addsd xmm2, QWORD PTR __real@3fe3333333333303 - 00589 f2 0f 59 d0 mulsd xmm2, xmm0 - 0058d 0f 28 c5 movaps xmm0, xmm5 - 00590 f2 0f 58 c6 addsd xmm0, xmm6 - 00594 f2 0f 59 c7 mulsd xmm0, xmm7 - 00598 f2 0f 58 d0 addsd xmm2, xmm0 + 00425 d9 c0 fld ST(0) + 00427 d8 c9 fmul ST(0), ST(1) ; 236 : t_h = 3.0+s2+r; - 0059c 0f 28 c3 movaps xmm0, xmm3 - 0059f f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@4008000000000000 - 005a7 f2 0f 11 54 24 - 18 movsd QWORD PTR _t2$1$[esp+32], xmm2 - 005ad f2 0f 58 c2 addsd xmm0, xmm2 - 005b1 f2 0f 11 44 24 - 08 movsd QWORD PTR _t_h$1[esp+32], xmm0 + 00429 d9 c0 fld ST(0) + 0042b dd 05 00 00 00 + 00 fld QWORD PTR __real@4008000000000000 + 00431 dc c1 fadd ST(1), ST(0) + 00433 d9 c9 fxch ST(1) + 00435 d8 c5 fadd ST(0), ST(5) + 00437 dd 5d f0 fstp QWORD PTR _t_h$2[ebp] ; 237 : __LO(t_h) = 0; - 005b7 c7 44 24 08 00 - 00 00 00 mov DWORD PTR _t_h$1[esp+32], 0 + 0043a c7 45 f0 00 00 + 00 00 mov DWORD PTR _t_h$2[ebp], 0 ; 238 : t_l = r-((t_h-3.0)-s2); ; 239 : /* u+v = ss*(1+...) */ ; 240 : u = s_h*t_h; - 005bf f2 0f 10 54 24 - 08 movsd xmm2, QWORD PTR _t_h$1[esp+32] - 005c5 0f 28 c2 movaps xmm0, xmm2 + 00441 dd 45 f0 fld QWORD PTR _t_h$2[ebp] + 00444 d9 c0 fld ST(0) + 00446 de cc fmulp ST(4), ST(0) + 00448 d9 c0 fld ST(0) + 0044a de e2 fsubrp ST(2), ST(0) + 0044c d9 c9 fxch ST(1) + 0044e de e2 fsubrp ST(2), ST(0) + 00450 d9 cc fxch ST(4) + 00452 de e1 fsubrp ST(1), ST(0) ; 241 : v = s_l*t_h+t_l*ss; - 005c8 f2 0f 59 fa mulsd xmm7, xmm2 - 005cc f2 0f 5c 05 00 - 00 00 00 subsd xmm0, QWORD PTR __real@4008000000000000 - 005d4 0f 28 e2 movaps xmm4, xmm2 - 005d7 f2 0f 59 e5 mulsd xmm4, xmm5 - 005db f2 0f 10 6c 24 - 18 movsd xmm5, QWORD PTR _t2$1$[esp+32] - 005e1 f2 0f 5c c3 subsd xmm0, xmm3 - 005e5 f2 0f 5c e8 subsd xmm5, xmm0 - 005e9 f2 0f 59 ee mulsd xmm5, xmm6 - 005ed f2 0f 58 ef addsd xmm5, xmm7 + 00454 dc 4d e0 fmul QWORD PTR _ss$1$[ebp] + 00457 d9 ca fxch ST(2) + 00459 de cb fmulp ST(3), ST(0) + 0045b d9 c9 fxch ST(1) + 0045d de c2 faddp ST(2), ST(0) ; 242 : /* 2/(3log2)*(ss+...) */ ; 243 : p_h = u+v; - 005f1 0f 28 c5 movaps xmm0, xmm5 - 005f4 f2 0f 58 c4 addsd xmm0, xmm4 - 005f8 f2 0f 11 44 24 - 18 movsd QWORD PTR _p_h$[esp+32], xmm0 + 0045f d9 c1 fld ST(1) + 00461 d8 c1 fadd ST(0), ST(1) + 00463 dd 5d e8 fstp QWORD PTR _p_h$[ebp] ; 244 : __LO(p_h) = 0; - 005fe c7 44 24 18 00 - 00 00 00 mov DWORD PTR _p_h$[esp+32], 0 + 00466 c7 45 e8 00 00 + 00 00 mov DWORD PTR _p_h$[ebp], 0 ; 245 : p_l = v-(p_h-u); ; 246 : z_h = cp_h*p_h; /* cp_h+cp_l = 2/(3*log2) */ - 00606 f2 0f 10 4c 24 - 18 movsd xmm1, QWORD PTR _p_h$[esp+32] - 0060c 0f 28 c1 movaps xmm0, xmm1 - 0060f 0f 28 d9 movaps xmm3, xmm1 - 00612 f2 0f 59 1d 00 - 00 00 00 mulsd xmm3, QWORD PTR __real@3feec709e0000000 - 0061a f2 0f 5c c4 subsd xmm0, xmm4 + 0046d dd 45 e8 fld QWORD PTR _p_h$[ebp] + 00470 dd 05 00 00 00 + 00 fld QWORD PTR __real@3feec709e0000000 + 00476 d8 c9 fmul ST(0), ST(1) + 00478 d9 c1 fld ST(1) + 0047a de e3 fsubrp ST(3), ST(0) + 0047c d9 cb fxch ST(3) + 0047e de e2 fsubrp ST(2), ST(0) ; 247 : z_l = cp_l*p_h+p_l*cp+dp_l[k]; - 0061e f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@3e3e2fe0145b01f5 - 00626 f2 0f 5c e8 subsd xmm5, xmm0 - 0062a f2 0f 59 2d 00 - 00 00 00 mulsd xmm5, QWORD PTR __real@3feec709dc3a03fd - 00632 f2 0f 5c e9 subsd xmm5, xmm1 - 00636 66 0f 6e d6 movd xmm2, esi + 00480 d9 c9 fxch ST(1) + 00482 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3feec709dc3a03fd + 00488 d9 c9 fxch ST(1) + 0048a dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3e3e2fe0145b01f5 + 00490 de e9 fsubp ST(1), ST(0) + 00492 dc 04 d5 00 00 + 00 00 fadd QWORD PTR _dp_l[edx*8] ; 248 : /* log2(ax) = (ss+..)*2/(3*log2) = n + dp_h + z_h + z_l */ ; 249 : t = (double)n; + + 00499 db 45 0c fild DWORD PTR _n$[ebp] + ; 250 : t1 = (((z_h+z_l)+dp_h[k])+t); - 0063a f2 0f 10 0c d5 - 00 00 00 00 movsd xmm1, QWORD PTR _dp_h[edx*8] - 00643 f3 0f e6 d2 cvtdq2pd xmm2, xmm2 - 00647 f2 0f 58 2c d5 - 00 00 00 00 addsd xmm5, QWORD PTR _dp_l[edx*8] - 00650 f2 0f 10 35 00 - 00 00 00 movsd xmm6, QWORD PTR __real@3ff0000000000000 - 00658 0f 28 c5 movaps xmm0, xmm5 - 0065b f2 0f 58 c3 addsd xmm0, xmm3 - 0065f f2 0f 58 c1 addsd xmm0, xmm1 - 00663 f2 0f 58 c2 addsd xmm0, xmm2 - 00667 f2 0f 11 44 24 - 08 movsd QWORD PTR _t1$[esp+32], xmm0 + 0049c d9 c1 fld ST(1) + 0049e d8 c3 fadd ST(0), ST(3) + 004a0 dc 04 d5 00 00 + 00 00 fadd QWORD PTR _dp_h[edx*8] + 004a7 d8 c1 fadd ST(0), ST(1) + 004a9 dd 5d 08 fstp QWORD PTR _t1$[ebp] ; 251 : __LO(t1) = 0; - 0066d c7 44 24 08 00 - 00 00 00 mov DWORD PTR _t1$[esp+32], 0 + 004ac c7 45 08 00 00 + 00 00 mov DWORD PTR _t1$[ebp], 0 ; 252 : t2 = z_l-(((t1-t)-dp_h[k])-z_h); - 00675 f2 0f 10 7c 24 - 08 movsd xmm7, QWORD PTR _t1$[esp+32] - 0067b 0f 28 c7 movaps xmm0, xmm7 - 0067e f2 0f 5c c2 subsd xmm0, xmm2 - 00682 f2 0f 5c c1 subsd xmm0, xmm1 - 00686 f2 0f 5c c3 subsd xmm0, xmm3 -$LN91@pow: - 0068a f2 0f 5c e8 subsd xmm5, xmm0 + 004b3 dd 45 08 fld QWORD PTR _t1$[ebp] + 004b6 d9 c0 fld ST(0) + 004b8 de e2 fsubrp ST(2), ST(0) + 004ba d9 c9 fxch ST(1) + 004bc dc 24 d5 00 00 + 00 00 fsub QWORD PTR _dp_h[edx*8] + 004c3 de e3 fsubrp ST(3), ST(0) + 004c5 d9 c9 fxch ST(1) + 004c7 de e2 fsubrp ST(2), ST(0) + 004c9 d9 e8 fld1 + 004cb d9 ee fldz + 004cd d9 cb fxch ST(3) + 004cf d9 c9 fxch ST(1) + 004d1 d9 ca fxch ST(2) + 004d3 d9 c9 fxch ST(1) +$LN19@pow: ; 253 : } ; 254 : ; 255 : /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */ ; 256 : y1 = y; - 0068e f2 0f 10 45 10 movsd xmm0, QWORD PTR _y$[ebp] - 00693 f2 0f 11 44 24 - 18 movsd QWORD PTR _y1$[esp+32], xmm0 + 004d5 dd 45 10 fld QWORD PTR _y$[ebp] + 004d8 dd 55 08 fst QWORD PTR _y1$[ebp] ; 257 : __LO(y1) = 0; ; 258 : p_l = (y-y1)*t1+y*t2; - 00699 66 0f 28 e0 movapd xmm4, xmm0 - 0069d c7 44 24 18 00 - 00 00 00 mov DWORD PTR _y1$[esp+32], 0 - 006a5 f2 0f 10 5c 24 - 18 movsd xmm3, QWORD PTR _y1$[esp+32] - 006ab f2 0f 5c e3 subsd xmm4, xmm3 + 004db d9 c0 fld ST(0) + 004dd c7 45 08 00 00 + 00 00 mov DWORD PTR _y1$[ebp], 0 + 004e4 dd 45 08 fld QWORD PTR _y1$[ebp] + 004e7 dc e9 fsub ST(1), ST(0) + 004e9 d9 c9 fxch ST(1) + 004eb d8 cc fmul ST(0), ST(4) + 004ed d9 cb fxch ST(3) + 004ef de ca fmulp ST(2), ST(0) + 004f1 d9 ca fxch ST(2) + 004f3 de c1 faddp ST(1), ST(0) ; 259 : p_h = y1*t1; - 006af f2 0f 59 df mulsd xmm3, xmm7 - 006b3 f2 0f 59 e8 mulsd xmm5, xmm0 - 006b7 f2 0f 59 e7 mulsd xmm4, xmm7 - 006bb f2 0f 58 e5 addsd xmm4, xmm5 + 004f5 d9 c9 fxch ST(1) + 004f7 de ca fmulp ST(2), ST(0) ; 260 : z = p_l+p_h; - 006bf 66 0f 28 cc movapd xmm1, xmm4 - 006c3 f2 0f 58 cb addsd xmm1, xmm3 - 006c7 f2 0f 11 4c 24 - 08 movsd QWORD PTR _z$[esp+32], xmm1 + 004f9 d9 c0 fld ST(0) + 004fb d8 c2 fadd ST(0), ST(2) + 004fd dd 55 08 fst QWORD PTR _z$[ebp] ; 261 : j = __HI(z); ; 262 : i = __LO(z); ; 263 : if (j>=0x40900000) { /* z >= 1024 */ - 006cd 8b 7c 24 0c mov edi, DWORD PTR _z$[esp+36] - 006d1 81 ff 00 00 90 + 00500 8b 7d 0c mov edi, DWORD PTR _z$[ebp+4] + 00503 81 ff 00 00 90 40 cmp edi, 1083179008 ; 40900000H - 006d7 7c 36 jl SHORT $LN13@pow + 00509 7c 40 jl SHORT $LN13@pow ; 264 : if(((j-0x40900000)|i)!=0) /* if z > 1024 */ - 006d9 8d 87 00 00 70 + 0050b 8d 87 00 00 70 bf lea eax, DWORD PTR [edi-1083179008] - 006df 0b 44 24 08 or eax, DWORD PTR _z$[esp+32] - 006e3 75 16 jne SHORT $LN92@pow + 00511 0b 45 08 or eax, DWORD PTR _z$[ebp] + 00514 74 1e je SHORT $LN12@pow + 00516 dd d8 fstp ST(0) +$LN171@pow: + 00518 dd d9 fstp ST(1) + 0051a dd d8 fstp ST(0) + 0051c dd d8 fstp ST(0) + 0051e dd d8 fstp ST(0) ; 265 : return s*huge*huge; /* overflow */ -; 266 : else { -; 267 : if(p_l+ovt>z-p_h) return s*huge*huge; /* overflow */ - 006e5 66 0f 28 c4 movapd xmm0, xmm4 - 006e9 f2 0f 5c cb subsd xmm1, xmm3 - 006ed f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3c971547652b82fe - 006f5 66 0f 2f c1 comisd xmm0, xmm1 - 006f9 76 4c jbe SHORT $LN5@pow -$LN92@pow: - 006fb dd 44 24 10 fld QWORD PTR _s$[esp+32] - 006ff dd 05 00 00 00 + 00520 dd 05 00 00 00 00 fld QWORD PTR __real@7e37e43c8800759c - 00705 dc c9 fmul ST(1), ST(0) - 00707 de c9 fmulp ST(1), ST(0) + 00526 dd 45 f8 fld QWORD PTR _s$1$[ebp] + 00529 d8 c9 fmul ST(0), ST(1) + 0052b 5f pop edi + 0052c 5e pop esi + 0052d 5b pop ebx + 0052e de c9 fmulp ST(1), ST(0) ; 306 : } - 00709 5f pop edi - 0070a 5e pop esi - 0070b 8b e5 mov esp, ebp - 0070d 5d pop ebp - 0070e c3 ret 0 + 00530 8b e5 mov esp, ebp + 00532 5d pop ebp + 00533 c3 ret 0 +$LN12@pow: + +; 266 : else { +; 267 : if(p_l+ovt>z-p_h) return s*huge*huge; /* overflow */ + + 00534 d9 c1 fld ST(1) + 00536 dc 05 00 00 00 + 00 fadd QWORD PTR __real@3c971547652b82fe + 0053c d9 c9 fxch ST(1) + 0053e d8 e3 fsub ST(0), ST(3) + 00540 de d9 fcompp + 00542 df e0 fnstsw ax + 00544 f6 c4 05 test ah, 5 + 00547 7a 62 jp SHORT $LN5@pow + 00549 eb cd jmp SHORT $LN171@pow $LN13@pow: ; 268 : } ; 269 : } else if((j&0x7fffffff)>=0x4090cc00 ) { /* z <= -1075 */ - 0070f 8b c7 mov eax, edi - 00711 25 ff ff ff 7f and eax, 2147483647 ; 7fffffffH - 00716 3d 00 cc 90 40 cmp eax, 1083231232 ; 4090cc00H - 0071b 7c 2a jl SHORT $LN5@pow + 0054b 8b c7 mov eax, edi + 0054d 25 ff ff ff 7f and eax, 2147483647 ; 7fffffffH + 00552 3d 00 cc 90 40 cmp eax, 1083231232 ; 4090cc00H + 00557 7c 50 jl SHORT $LN149@pow ; 270 : if(((j-0xc090cc00)|i)!=0) /* z < -1075 */ - 0071d 8d 87 00 34 6f + 00559 8d 87 00 34 6f 3f lea eax, DWORD PTR [edi+1064252416] - 00723 0b 44 24 08 or eax, DWORD PTR _z$[esp+32] - 00727 74 14 je SHORT $LN7@pow -$LN93@pow: + 0055f 0b 45 08 or eax, DWORD PTR _z$[ebp] + 00562 74 1e je SHORT $LN7@pow ; 271 : return s*tiny*tiny; /* underflow */ - 00729 dd 44 24 10 fld QWORD PTR _s$[esp+32] - 0072d dd 05 00 00 00 + 00564 dd d8 fstp ST(0) + 00566 dd d9 fstp ST(1) + 00568 dd d8 fstp ST(0) + 0056a dd d8 fstp ST(0) + 0056c dd d8 fstp ST(0) + 0056e dd 05 00 00 00 00 fld QWORD PTR __real@01a56e1fc2f8f359 - 00733 dc c9 fmul ST(1), ST(0) - 00735 de c9 fmulp ST(1), ST(0) + 00574 dd 45 f8 fld QWORD PTR _s$1$[ebp] + 00577 d8 c9 fmul ST(0), ST(1) + 00579 5f pop edi + 0057a 5e pop esi + 0057b 5b pop ebx + 0057c de c9 fmulp ST(1), ST(0) ; 306 : } - 00737 5f pop edi - 00738 5e pop esi - 00739 8b e5 mov esp, ebp - 0073b 5d pop ebp - 0073c c3 ret 0 + 0057e 8b e5 mov esp, ebp + 00580 5d pop ebp + 00581 c3 ret 0 $LN7@pow: ; 272 : else { ; 273 : if(p_l<=z-p_h) return s*tiny*tiny; /* underflow */ - 0073d f2 0f 5c cb subsd xmm1, xmm3 - 00741 66 0f 2f cc comisd xmm1, xmm4 - 00745 73 e2 jae SHORT $LN93@pow + 00582 d8 e2 fsub ST(0), ST(2) + 00584 d8 d9 fcomp ST(1) + 00586 df e0 fnstsw ax + 00588 f6 c4 01 test ah, 1 + 0058b 75 1e jne SHORT $LN5@pow + 0058d dd d9 fstp ST(1) + 0058f dd d8 fstp ST(0) + 00591 dd d8 fstp ST(0) + 00593 dd d8 fstp ST(0) + 00595 dd 05 00 00 00 + 00 fld QWORD PTR __real@01a56e1fc2f8f359 + 0059b dd 45 f8 fld QWORD PTR _s$1$[ebp] + 0059e d8 c9 fmul ST(0), ST(1) + 005a0 5f pop edi + 005a1 5e pop esi + 005a2 5b pop ebx + 005a3 de c9 fmulp ST(1), ST(0) + +; 306 : } + + 005a5 8b e5 mov esp, ebp + 005a7 5d pop ebp + 005a8 c3 ret 0 +$LN149@pow: + 005a9 dd d8 fstp ST(0) $LN5@pow: ; 274 : } @@ -1393,77 +1335,78 @@ $LN5@pow: ; 278 : */ ; 279 : i = j&0x7fffffff; - 00747 8b cf mov ecx, edi + 005ab 8b cf mov ecx, edi ; 280 : k = (i>>20)-0x3ff; ; 281 : n = 0; - 00749 33 f6 xor esi, esi - 0074b 81 e1 ff ff ff + 005ad 33 f6 xor esi, esi + 005af 81 e1 ff ff ff 7f and ecx, 2147483647 ; 7fffffffH ; 282 : if(i>0x3fe00000) { /* if |z| > 0.5, set n = [z+0.5] */ - 00751 81 f9 00 00 e0 + 005b5 81 f9 00 00 e0 3f cmp ecx, 1071644672 ; 3fe00000H - 00757 7e 5e jle SHORT $LN4@pow + 005bb 7e 58 jle SHORT $LN139@pow ; 283 : n = j+(0x00100000>>(k+1)); - 00759 c1 f9 14 sar ecx, 20 ; 00000014H - 0075c be 00 00 10 00 mov esi, 1048576 ; 00100000H - 00761 81 e9 fe 03 00 + 005bd c1 f9 14 sar ecx, 20 ; 00000014H + 005c0 be 00 00 10 00 mov esi, 1048576 ; 00100000H + 005c5 81 e9 fe 03 00 00 sub ecx, 1022 ; 000003feH ; 284 : k = ((n&0x7fffffff)>>20)-0x3ff; /* new k for n */ ; 285 : t = zero; ; 286 : __HI(t) = (n&~(0x000fffff>>k)); - 00767 b8 ff ff 0f 00 mov eax, 1048575 ; 000fffffH - 0076c d3 fe sar esi, cl - 0076e 0f 57 c0 xorps xmm0, xmm0 - 00771 03 f7 add esi, edi - 00773 f2 0f 11 44 24 - 08 movsd QWORD PTR _t$[esp+32], xmm0 - 00779 8b d6 mov edx, esi - 0077b c1 fa 14 sar edx, 20 ; 00000014H - 0077e 81 e2 ff 07 00 + 005cb b8 ff ff 0f 00 mov eax, 1048575 ; 000fffffH + 005d0 d3 fe sar esi, cl + 005d2 d9 cb fxch ST(3) + 005d4 03 f7 add esi, edi + 005d6 8b d6 mov edx, esi + 005d8 c1 fa 14 sar edx, 20 ; 00000014H + 005db 81 e2 ff 07 00 00 and edx, 2047 ; 000007ffH - 00784 81 ea ff 03 00 + 005e1 81 ea ff 03 00 00 sub edx, 1023 ; 000003ffH - 0078a 8b ca mov ecx, edx - 0078c d3 f8 sar eax, cl + 005e7 8b ca mov ecx, edx + 005e9 d3 f8 sar eax, cl ; 287 : n = ((n&0x000fffff)|0x00100000)>>(20-k); - 0078e b9 14 00 00 00 mov ecx, 20 ; 00000014H - 00793 f7 d0 not eax - 00795 2b ca sub ecx, edx - 00797 23 c6 and eax, esi - 00799 81 e6 ff ff 0f + 005eb b9 14 00 00 00 mov ecx, 20 ; 00000014H + 005f0 f7 d0 not eax + 005f2 2b ca sub ecx, edx + 005f4 23 c6 and eax, esi + 005f6 81 e6 ff ff 0f 00 and esi, 1048575 ; 000fffffH - 0079f 81 ce 00 00 10 + 005fc 81 ce 00 00 10 00 or esi, 1048576 ; 00100000H - 007a5 89 44 24 0c mov DWORD PTR _t$[esp+36], eax - 007a9 d3 fe sar esi, cl + 00602 d3 fe sar esi, cl + 00604 dd 5d 08 fstp QWORD PTR _t$[ebp] + 00607 89 45 0c mov DWORD PTR _t$[ebp+4], eax ; 288 : if(j<0) n = -n; - 007ab 85 ff test edi, edi - 007ad 79 02 jns SHORT $LN3@pow - 007af f7 de neg esi + 0060a 85 ff test edi, edi + 0060c 79 02 jns SHORT $LN3@pow + 0060e f7 de neg esi $LN3@pow: ; 289 : p_h -= t; - 007b1 f2 0f 5c 5c 24 - 08 subsd xmm3, QWORD PTR _t$[esp+32] + 00610 dc 65 08 fsub QWORD PTR _t$[ebp] + 00613 eb 02 jmp SHORT $LN4@pow +$LN139@pow: + 00615 dd db fstp ST(3) $LN4@pow: ; 290 : } ; 291 : t = p_l+p_h; - 007b7 66 0f 28 c4 movapd xmm0, xmm4 + 00617 d9 c2 fld ST(2) ; 292 : __LO(t) = 0; ; 293 : u = t*lg2_h; @@ -1477,119 +1420,125 @@ $LN4@pow: ; 301 : j = __HI(z); ; 302 : j += (n<<20); - 007bb 8b ce mov ecx, esi - 007bd f2 0f 58 c3 addsd xmm0, xmm3 - 007c1 c1 e1 14 shl ecx, 20 ; 00000014H - 007c4 f2 0f 11 44 24 - 08 movsd QWORD PTR _t$[esp+32], xmm0 - 007ca c7 44 24 08 00 - 00 00 00 mov DWORD PTR _t$[esp+32], 0 - 007d2 f2 0f 10 4c 24 - 08 movsd xmm1, QWORD PTR _t$[esp+32] - 007d8 0f 28 c1 movaps xmm0, xmm1 - 007db 66 0f 28 d1 movapd xmm2, xmm1 - 007df f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@3e205c610ca86c39 - 007e7 f2 0f 5c c3 subsd xmm0, xmm3 - 007eb f2 0f 59 15 00 - 00 00 00 mulsd xmm2, QWORD PTR __real@3fe62e4300000000 - 007f3 f2 0f 5c e0 subsd xmm4, xmm0 - 007f7 f2 0f 59 25 00 - 00 00 00 mulsd xmm4, QWORD PTR __real@3fe62e42fefa39ef - 007ff f2 0f 5c e1 subsd xmm4, xmm1 - 00803 66 0f 28 dc movapd xmm3, xmm4 - 00807 f2 0f 58 da addsd xmm3, xmm2 - 0080b 0f 28 c3 movaps xmm0, xmm3 - 0080e f2 0f 5c c2 subsd xmm0, xmm2 - 00812 f2 0f 5c e0 subsd xmm4, xmm0 - 00816 0f 28 c3 movaps xmm0, xmm3 - 00819 f2 0f 59 c3 mulsd xmm0, xmm3 - 0081d 0f 28 c8 movaps xmm1, xmm0 - 00820 f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@3e66376972bea4d0 - 00828 f2 0f 5c 0d 00 - 00 00 00 subsd xmm1, QWORD PTR __real@3ebbbd41c5d26bf1 - 00830 f2 0f 59 c8 mulsd xmm1, xmm0 - 00834 f2 0f 58 0d 00 - 00 00 00 addsd xmm1, QWORD PTR __real@3f11566aaf25de2c - 0083c f2 0f 59 c8 mulsd xmm1, xmm0 - 00840 f2 0f 5c 0d 00 - 00 00 00 subsd xmm1, QWORD PTR __real@3f66c16c16bebd93 - 00848 f2 0f 59 c8 mulsd xmm1, xmm0 - 0084c f2 0f 58 0d 00 - 00 00 00 addsd xmm1, QWORD PTR __real@3fc555555555553e - 00854 f2 0f 59 c8 mulsd xmm1, xmm0 - 00858 0f 28 c3 movaps xmm0, xmm3 - 0085b f2 0f 5c c1 subsd xmm0, xmm1 - 0085f 0f 28 c8 movaps xmm1, xmm0 - 00862 f2 0f 5c 05 00 - 00 00 00 subsd xmm0, QWORD PTR __real@4000000000000000 - 0086a f2 0f 59 cb mulsd xmm1, xmm3 - 0086e f2 0f 5e c8 divsd xmm1, xmm0 - 00872 66 0f 28 c4 movapd xmm0, xmm4 - 00876 f2 0f 59 c3 mulsd xmm0, xmm3 - 0087a f2 0f 58 c4 addsd xmm0, xmm4 - 0087e f2 0f 5c c8 subsd xmm1, xmm0 - 00882 f2 0f 5c cb subsd xmm1, xmm3 - 00886 f2 0f 5c f1 subsd xmm6, xmm1 - 0088a f2 0f 11 74 24 - 08 movsd QWORD PTR _z$[esp+32], xmm6 - 00890 8b 44 24 0c mov eax, DWORD PTR _z$[esp+36] - 00894 03 c1 add eax, ecx + 00619 8b ce mov ecx, esi + 0061b d8 c1 fadd ST(0), ST(1) + 0061d c1 e1 14 shl ecx, 20 ; 00000014H + 00620 dd 5d 08 fstp QWORD PTR _t$[ebp] + 00623 c7 45 08 00 00 + 00 00 mov DWORD PTR _t$[ebp], 0 + 0062a dd 45 08 fld QWORD PTR _t$[ebp] + 0062d dd 05 00 00 00 + 00 fld QWORD PTR __real@3fe62e4300000000 + 00633 d8 c9 fmul ST(0), ST(1) + 00635 d9 c1 fld ST(1) + 00637 de e3 fsubrp ST(3), ST(0) + 00639 d9 cc fxch ST(4) + 0063b de e2 fsubrp ST(2), ST(0) + 0063d d9 c9 fxch ST(1) + 0063f dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3fe62e42fefa39ef + 00645 d9 c9 fxch ST(1) + 00647 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3e205c610ca86c39 + 0064d de e9 fsubp ST(1), ST(0) + 0064f d9 c0 fld ST(0) + 00651 d8 c3 fadd ST(0), ST(3) + 00653 d9 c0 fld ST(0) + 00655 de e4 fsubrp ST(4), ST(0) + 00657 d9 c9 fxch ST(1) + 00659 de e3 fsubrp ST(3), ST(0) + 0065b d9 c0 fld ST(0) + 0065d d8 c9 fmul ST(0), ST(1) + 0065f dd 05 00 00 00 + 00 fld QWORD PTR __real@3e66376972bea4d0 + 00665 d8 c9 fmul ST(0), ST(1) + 00667 dc 25 00 00 00 + 00 fsub QWORD PTR __real@3ebbbd41c5d26bf1 + 0066d d8 c9 fmul ST(0), ST(1) + 0066f dc 05 00 00 00 + 00 fadd QWORD PTR __real@3f11566aaf25de2c + 00675 d8 c9 fmul ST(0), ST(1) + 00677 dc 25 00 00 00 + 00 fsub QWORD PTR __real@3f66c16c16bebd93 + 0067d d8 c9 fmul ST(0), ST(1) + 0067f dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fc555555555553e + 00685 de c9 fmulp ST(1), ST(0) + 00687 d8 e9 fsubr ST(0), ST(1) + 00689 d9 c0 fld ST(0) + 0068b d8 ca fmul ST(0), ST(2) + 0068d d9 c9 fxch ST(1) + 0068f dc 25 00 00 00 + 00 fsub QWORD PTR __real@4000000000000000 + 00695 de f9 fdivp ST(1), ST(0) + 00697 d9 c3 fld ST(3) + 00699 d8 ca fmul ST(0), ST(2) + 0069b de c4 faddp ST(4), ST(0) + 0069d de e3 fsubrp ST(3), ST(0) + 0069f de ea fsubp ST(2), ST(0) + 006a1 de e1 fsubrp ST(1), ST(0) + 006a3 dd 55 08 fst QWORD PTR _z$[ebp] + 006a6 8b 45 0c mov eax, DWORD PTR _z$[ebp+4] + 006a9 03 c1 add eax, ecx ; 303 : if((j>>20)<=0) z = scalbn(z,n); /* subnormal output */ - 00896 a9 00 00 f0 ff test eax, -1048576 ; fff00000H - 0089b 7f 1b jg SHORT $LN2@pow - 0089d 56 push esi - 0089e 83 ec 08 sub esp, 8 - 008a1 f2 0f 11 34 24 movsd QWORD PTR [esp], xmm6 - 008a6 e8 00 00 00 00 call _scalbn + 006ab a9 00 00 f0 ff test eax, -1048576 ; fff00000H + 006b0 7f 19 jg SHORT $LN145@pow + 006b2 56 push esi + 006b3 83 ec 08 sub esp, 8 + 006b6 dd 1c 24 fstp QWORD PTR [esp] + 006b9 e8 00 00 00 00 call _scalbn ; 305 : return s*z; - 008ab dc 4c 24 1c fmul QWORD PTR _s$[esp+44] - 008af 83 c4 0c add esp, 12 ; 0000000cH + 006be dc 4d f8 fmul QWORD PTR _s$1$[ebp] + 006c1 83 c4 0c add esp, 12 ; 0000000cH + 006c4 5f pop edi + 006c5 5e pop esi + 006c6 5b pop ebx ; 306 : } - 008b2 5f pop edi - 008b3 5e pop esi - 008b4 8b e5 mov esp, ebp - 008b6 5d pop ebp - 008b7 c3 ret 0 -$LN2@pow: + 006c7 8b e5 mov esp, ebp + 006c9 5d pop ebp + 006ca c3 ret 0 +$LN145@pow: + 006cb dd d8 fstp ST(0) ; 304 : else __HI(z) += (n<<20); - 008b8 89 44 24 0c mov DWORD PTR _z$[esp+36], eax - 008bc dd 44 24 08 fld QWORD PTR _z$[esp+32] + 006cd 89 45 0c mov DWORD PTR _z$[ebp+4], eax + 006d0 dd 45 08 fld QWORD PTR _z$[ebp] ; 305 : return s*z; - 008c0 dc 4c 24 10 fmul QWORD PTR _s$[esp+32] + 006d3 dc 4d f8 fmul QWORD PTR _s$1$[ebp] + 006d6 5f pop edi + 006d7 5e pop esi + 006d8 5b pop ebx ; 306 : } - 008c4 5f pop edi - 008c5 5e pop esi - 008c6 8b e5 mov esp, ebp - 008c8 5d pop ebp - 008c9 c3 ret 0 + 006d9 8b e5 mov esp, ebp + 006db 5d pop ebp + 006dc c3 ret 0 $LN58@pow: ; 121 : return x+y; - 008ca dd 45 08 fld QWORD PTR _x$[ebp] - 008cd dc 45 10 fadd QWORD PTR _y$[ebp] + 006dd dd 45 08 fld QWORD PTR _x$[ebp] + 006e0 dc 45 10 fadd QWORD PTR _y$[ebp] +$LN61@pow: + 006e3 5f pop edi + 006e4 5e pop esi + 006e5 5b pop ebx ; 306 : } - 008d0 5f pop edi - 008d1 5e pop esi - 008d2 8b e5 mov esp, ebp - 008d4 5d pop ebp - 008d5 c3 ret 0 + 006e6 8b e5 mov esp, ebp + 006e8 5d pop ebp + 006e9 c3 ret 0 _pow ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/scalbn.cod b/clib/mscv/CLib/scalbn.cod index 8750da810..733ccc937 100644 --- a/clib/mscv/CLib/scalbn.cod +++ b/clib/mscv/CLib/scalbn.cod @@ -62,166 +62,153 @@ _scalbn PROC ; COMDAT ; 35 : if (k==0) { /* 0 or subnormal x */ 00008 8b 55 10 mov edx, DWORD PTR _n$[ebp] - 0000b c1 f8 14 sar eax, 20 ; 00000014H - 0000e 25 ff 07 00 00 and eax, 2047 ; 000007ffH - 00013 75 44 jne SHORT $LN12@scalbn ; 36 : if ((lx|(hx&0x7fffffff))==0) return x; /* +-0 */ - 00015 81 e1 ff ff ff + 0000b dd 45 08 fld QWORD PTR _x$[ebp] + 0000e c1 f8 14 sar eax, 20 ; 00000014H + 00011 25 ff 07 00 00 and eax, 2047 ; 000007ffH + 00016 75 30 jne SHORT $LN7@scalbn + 00018 81 e1 ff ff ff 7f and ecx, 2147483647 ; 7fffffffH - 0001b 0b 4d 08 or ecx, DWORD PTR _x$[ebp] - 0001e 0f 84 89 00 00 - 00 je $LN13@scalbn + 0001e 0b 4d 08 or ecx, DWORD PTR _x$[ebp] + 00021 0f 84 b7 00 00 + 00 je $LN10@scalbn ; 37 : x *= two54; - 00024 f2 0f 10 45 08 movsd xmm0, QWORD PTR _x$[ebp] - 00029 f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@4350000000000000 - 00031 f2 0f 11 45 08 movsd QWORD PTR _x$[ebp], xmm0 + 00027 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@4350000000000000 + 0002d dd 55 08 fst QWORD PTR _x$[ebp] ; 38 : hx = __HI(x); ; 39 : k = ((hx&0x7ff00000)>>20) - 54; - 00036 8b 4d 0c mov ecx, DWORD PTR _x$[ebp+4] - 00039 8b c1 mov eax, ecx - 0003b c1 f8 14 sar eax, 20 ; 00000014H - 0003e 25 ff 07 00 00 and eax, 2047 ; 000007ffH - 00043 83 e8 36 sub eax, 54 ; 00000036H + 00030 8b 4d 0c mov ecx, DWORD PTR _x$[ebp+4] + 00033 8b c1 mov eax, ecx + 00035 c1 f8 14 sar eax, 20 ; 00000014H + 00038 25 ff 07 00 00 and eax, 2047 ; 000007ffH + 0003d 83 e8 36 sub eax, 54 ; 00000036H ; 40 : if (n< -50000) return tiny*x; /*underflow*/ - 00046 81 fa b0 3c ff + 00040 81 fa b0 3c ff ff cmp edx, -50000 ; ffff3cb0H - 0004c 7d 10 jge SHORT $LN7@scalbn - 0004e dd 45 08 fld QWORD PTR _x$[ebp] - 00051 dc 0d 00 00 00 - 00 fmul QWORD PTR __real@01a56e1fc2f8f359 - -; 54 : } - - 00057 5d pop ebp - 00058 c3 ret 0 -$LN12@scalbn: - -; 40 : if (n< -50000) return tiny*x; /*underflow*/ - - 00059 f2 0f 10 45 08 movsd xmm0, QWORD PTR _x$[ebp] + 00046 7c 72 jl SHORT $LN31@scalbn $LN7@scalbn: ; 41 : } ; 42 : if (k==0x7ff) return x+x; /* NaN or Inf */ - 0005e 3d ff 07 00 00 cmp eax, 2047 ; 000007ffH - 00063 75 07 jne SHORT $LN6@scalbn - 00065 dd 45 08 fld QWORD PTR _x$[ebp] - 00068 dc c0 fadd ST(0), ST(0) + 00048 3d ff 07 00 00 cmp eax, 2047 ; 000007ffH + 0004d 75 04 jne SHORT $LN6@scalbn + 0004f dc c0 fadd ST(0), ST(0) ; 54 : } - 0006a 5d pop ebp - 0006b c3 ret 0 + 00051 5d pop ebp + 00052 c3 ret 0 $LN6@scalbn: ; 43 : k = k+n; - 0006c 03 c2 add eax, edx + 00053 03 c2 add eax, edx ; 44 : if (k > 0x7fe) return huge*copysign(huge,x); /* overflow */ - 0006e 3d fe 07 00 00 cmp eax, 2046 ; 000007feH - 00073 7e 26 jle SHORT $LN5@scalbn - 00075 83 ec 10 sub esp, 16 ; 00000010H - 00078 f2 0f 11 44 24 - 08 movsd QWORD PTR [esp+8], xmm0 -$LN14@scalbn: - 0007e f2 0f 10 05 00 - 00 00 00 movsd xmm0, QWORD PTR __real@7e37e43c8800759c - 00086 f2 0f 11 04 24 movsd QWORD PTR [esp], xmm0 - 0008b e8 00 00 00 00 call _copysign - 00090 dc 0d 00 00 00 + 00055 3d fe 07 00 00 cmp eax, 2046 ; 000007feH + 0005a 7e 20 jle SHORT $LN5@scalbn + 0005c 83 ec 10 sub esp, 16 ; 00000010H + 0005f dd 5c 24 08 fstp QWORD PTR [esp+8] +$LN32@scalbn: + 00063 dd 05 00 00 00 + 00 fld QWORD PTR __real@7e37e43c8800759c + 00069 dd 1c 24 fstp QWORD PTR [esp] + 0006c e8 00 00 00 00 call _copysign + 00071 dc 0d 00 00 00 00 fmul QWORD PTR __real@7e37e43c8800759c - 00096 83 c4 10 add esp, 16 ; 00000010H + 00077 83 c4 10 add esp, 16 ; 00000010H ; 54 : } - 00099 5d pop ebp - 0009a c3 ret 0 + 0007a 5d pop ebp + 0007b c3 ret 0 $LN5@scalbn: ; 45 : if (k > 0) /* normal result */ - 0009b 85 c0 test eax, eax - 0009d 7e 13 jle SHORT $LN4@scalbn + 0007c 85 c0 test eax, eax + 0007e 7e 15 jle SHORT $LN4@scalbn ; 46 : {__HI(x) = (hx&0x800fffff)|(k<<20); return x;} - 0009f c1 e0 14 shl eax, 20 ; 00000014H - 000a2 81 e1 ff ff 0f + 00080 c1 e0 14 shl eax, 20 ; 00000014H + 00083 81 e1 ff ff 0f 80 and ecx, -2146435073 ; 800fffffH - 000a8 0b c1 or eax, ecx - 000aa 89 45 0c mov DWORD PTR _x$[ebp+4], eax -$LN13@scalbn: - 000ad dd 45 08 fld QWORD PTR _x$[ebp] + 00089 0b c1 or eax, ecx + 0008b dd d8 fstp ST(0) + 0008d 89 45 0c mov DWORD PTR _x$[ebp+4], eax + 00090 dd 45 08 fld QWORD PTR _x$[ebp] ; 54 : } - 000b0 5d pop ebp - 000b1 c3 ret 0 + 00093 5d pop ebp + 00094 c3 ret 0 $LN4@scalbn: ; 47 : if (k <= -54) - 000b2 83 f8 ca cmp eax, -54 ; ffffffcaH - 000b5 7f 2e jg SHORT $LN1@scalbn + 00095 83 f8 ca cmp eax, -54 ; ffffffcaH + 00098 7f 28 jg SHORT $LN26@scalbn ; 48 : if (n > 50000) /* in case integer overflow in n+k */ ; 49 : return huge*copysign(huge,x); /*overflow*/ - 000b7 83 ec 10 sub esp, 16 ; 00000010H - 000ba f2 0f 11 44 24 - 08 movsd QWORD PTR [esp+8], xmm0 - 000c0 81 fa 50 c3 00 + 0009a 83 ec 10 sub esp, 16 ; 00000010H + 0009d dd 5c 24 08 fstp QWORD PTR [esp+8] + 000a1 81 fa 50 c3 00 00 cmp edx, 50000 ; 0000c350H - 000c6 7f b6 jg SHORT $LN14@scalbn + 000a7 7f ba jg SHORT $LN32@scalbn ; 50 : else return tiny*copysign(tiny,x); /*underflow*/ - 000c8 f2 0f 10 05 00 - 00 00 00 movsd xmm0, QWORD PTR __real@01a56e1fc2f8f359 - 000d0 f2 0f 11 04 24 movsd QWORD PTR [esp], xmm0 - 000d5 e8 00 00 00 00 call _copysign - 000da dc 0d 00 00 00 + 000a9 dd 05 00 00 00 + 00 fld QWORD PTR __real@01a56e1fc2f8f359 + 000af dd 1c 24 fstp QWORD PTR [esp] + 000b2 e8 00 00 00 00 call _copysign + 000b7 83 c4 10 add esp, 16 ; 00000010H +$LN31@scalbn: + 000ba dc 0d 00 00 00 00 fmul QWORD PTR __real@01a56e1fc2f8f359 - 000e0 83 c4 10 add esp, 16 ; 00000010H ; 54 : } - 000e3 5d pop ebp - 000e4 c3 ret 0 -$LN1@scalbn: + 000c0 5d pop ebp + 000c1 c3 ret 0 +$LN26@scalbn: ; 51 : k += 54; /* subnormal result */ ; 52 : __HI(x) = (hx&0x800fffff)|(k<<20); - 000e5 83 c0 36 add eax, 54 ; 00000036H - 000e8 81 e1 ff ff 0f + 000c2 83 c0 36 add eax, 54 ; 00000036H + 000c5 81 e1 ff ff 0f 80 and ecx, -2146435073 ; 800fffffH - 000ee c1 e0 14 shl eax, 20 ; 00000014H - 000f1 0b c1 or eax, ecx - 000f3 89 45 0c mov DWORD PTR _x$[ebp+4], eax + 000cb c1 e0 14 shl eax, 20 ; 00000014H + 000ce dd d8 fstp ST(0) + 000d0 0b c1 or eax, ecx + 000d2 89 45 0c mov DWORD PTR _x$[ebp+4], eax ; 53 : return x*twom54; - 000f6 dd 45 08 fld QWORD PTR _x$[ebp] - 000f9 dc 0d 00 00 00 + 000d5 dd 45 08 fld QWORD PTR _x$[ebp] + 000d8 dc 0d 00 00 00 00 fmul QWORD PTR __real@3c90000000000000 +$LN10@scalbn: ; 54 : } - 000ff 5d pop ebp - 00100 c3 ret 0 + 000de 5d pop ebp + 000df c3 ret 0 _scalbn ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/sin.cod b/clib/mscv/CLib/sin.cod index 73a762667..264d56827 100644 --- a/clib/mscv/CLib/sin.cod +++ b/clib/mscv/CLib/sin.cod @@ -34,14 +34,9 @@ PUBLIC __real@3fe0000000000000 PUBLIC __real@3fe45f306dc9c883 PUBLIC __real@3ff0000000000000 PUBLIC __real@3ff921fb54442d18 -PUBLIC __xmm@80000000000000008000000000000000 -EXTRN __libm_sse2_exp_precise:PROC +EXTRN __CIexp:PROC +EXTRN __ftol2_sse:PROC EXTRN __fltused:DWORD -; COMDAT __xmm@80000000000000008000000000000000 -CONST SEGMENT -__xmm@80000000000000008000000000000000 DB 00H, 00H, 00H, 00H, 00H, 00H, 00H - DB 080H, 00H, 00H, 00H, 00H, 00H, 00H, 00H, 080H -CONST ENDS ; COMDAT __real@3ff921fb54442d18 CONST SEGMENT __real@3ff921fb54442d18 DQ 03ff921fb54442d18r ; 1.5708 @@ -98,8 +93,9 @@ CONST ENDS ; File c:\users\philip\documents\github\mollenos\clib\src\math\sin.c ; COMDAT _sin _TEXT SEGMENT -tv242 = 8 ; size = 8 +tv244 = 8 ; size = 8 _x$ = 8 ; size = 8 +_quadrant$ = 12 ; size = 4 _sin PROC ; COMDAT ; 21 : { @@ -113,12 +109,12 @@ _sin PROC ; COMDAT ; 25 : /* Calculate the quadrant */ ; 26 : quadrant = (int)(x * (2./M_PI)); - 00003 f2 0f 10 4d 08 movsd xmm1, QWORD PTR _x$[ebp] - 00008 66 0f 28 c1 movapd xmm0, xmm1 - 0000c f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@3fe45f306dc9c883 - 00014 f2 0f 2c c0 cvttsd2si eax, xmm0 - 00018 66 0f 6e c0 movd xmm0, eax + 00003 dd 45 08 fld QWORD PTR _x$[ebp] + 00006 dd 05 00 00 00 + 00 fld QWORD PTR __real@3fe45f306dc9c883 + 0000c d8 c9 fmul ST(0), ST(1) + 0000e e8 00 00 00 00 call __ftol2_sse + 00013 89 45 0c mov DWORD PTR _quadrant$[ebp], eax ; 27 : ; 28 : /* Get offset inside quadrant */ @@ -127,28 +123,28 @@ _sin PROC ; COMDAT ; 31 : /* Normalize quadrant to [0..3] */ ; 32 : quadrant = (quadrant - 1) & 0x3; - 0001c 48 dec eax - 0001d f3 0f e6 c0 cvtdq2pd xmm0, xmm0 - 00021 83 e0 03 and eax, 3 + 00016 48 dec eax + 00017 db 45 0c fild DWORD PTR _quadrant$[ebp] + 0001a 83 e0 03 and eax, 3 + 0001d dd 5d 08 fstp QWORD PTR tv244[ebp] + 00020 dd 45 08 fld QWORD PTR tv244[ebp] + 00023 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3ff921fb54442d18 + 00029 de e9 fsubp ST(1), ST(0) ; 33 : ; 34 : /* Fixup value for the generic function */ ; 35 : x += sin_off_tbl[quadrant]; - 00024 f2 0f 10 14 c5 - 00 00 00 00 movsd xmm2, QWORD PTR _sin_off_tbl[eax*8] - 0002d f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@3ff921fb54442d18 - 00035 f2 0f 5c c8 subsd xmm1, xmm0 - 00039 f2 0f 58 d1 addsd xmm2, xmm1 + 0002b dc 04 c5 00 00 + 00 00 fadd QWORD PTR _sin_off_tbl[eax*8] ; 36 : ; 37 : /* Calculate the negative of the square of x */ ; 38 : x2 = - (x * x); - 0003d f2 0f 59 d2 mulsd xmm2, xmm2 - 00041 66 0f 57 15 00 - 00 00 00 xorpd xmm2, QWORD PTR __xmm@80000000000000008000000000000000 + 00032 dc c8 fmul ST(0), ST(0) + 00034 d9 e0 fchs ; 39 : ; 40 : /* This is an unrolled taylor series using iterations @@ -170,125 +166,119 @@ _sin PROC ; COMDAT ; 56 : result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16*17*18); ; 57 : result *= x2; - 00049 66 0f 28 c2 movapd xmm0, xmm2 - 0004d f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@3ca6827863b97d97 + 00036 dd 05 00 00 00 + 00 fld QWORD PTR __real@3ca6827863b97d97 + 0003c d8 c9 fmul ST(0), ST(1) ; 58 : #endif ; 59 : #if (PRECISION >= 8) ; 60 : result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14*15*16); - 00055 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3d2ae7f3e733b81f + 0003e dc 05 00 00 00 + 00 fadd QWORD PTR __real@3d2ae7f3e733b81f ; 61 : result *= x2; - 0005d f2 0f 59 c2 mulsd xmm0, xmm2 + 00044 d8 c9 fmul ST(0), ST(1) ; 62 : #endif ; 63 : #if (PRECISION >= 7) ; 64 : result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12*13*14); - 00061 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3da93974a8c07c9d + 00046 dc 05 00 00 00 + 00 fadd QWORD PTR __real@3da93974a8c07c9d ; 65 : result *= x2; - 00069 f2 0f 59 c2 mulsd xmm0, xmm2 + 0004c d8 c9 fmul ST(0), ST(1) ; 66 : #endif ; 67 : #if (PRECISION >= 6) ; 68 : result += 1./(1.*2*3*4*5*6*7*8*9*10*11*12); - 0006d f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3e21eed8eff8d898 + 0004e dc 05 00 00 00 + 00 fadd QWORD PTR __real@3e21eed8eff8d898 ; 69 : result *= x2; - 00075 f2 0f 59 c2 mulsd xmm0, xmm2 + 00054 d8 c9 fmul ST(0), ST(1) ; 70 : #endif ; 71 : #if (PRECISION >= 5) ; 72 : result += 1./(1.*2*3*4*5*6*7*8*9*10); - 00079 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3e927e4fb7789f5c + 00056 dc 05 00 00 00 + 00 fadd QWORD PTR __real@3e927e4fb7789f5c ; 73 : result *= x2; - 00081 f2 0f 59 c2 mulsd xmm0, xmm2 + 0005c d8 c9 fmul ST(0), ST(1) ; 74 : #endif ; 75 : result += 1./(1.*2*3*4*5*6*7*8); - 00085 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3efa01a01a01a01a + 0005e dc 05 00 00 00 + 00 fadd QWORD PTR __real@3efa01a01a01a01a ; 76 : result *= x2; - 0008d f2 0f 59 c2 mulsd xmm0, xmm2 + 00064 d8 c9 fmul ST(0), ST(1) ; 77 : ; 78 : result += 1./(1.*2*3*4*5*6); - 00091 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3f56c16c16c16c17 + 00066 dc 05 00 00 00 + 00 fadd QWORD PTR __real@3f56c16c16c16c17 ; 79 : result *= x2; - 00099 f2 0f 59 c2 mulsd xmm0, xmm2 + 0006c d8 c9 fmul ST(0), ST(1) ; 80 : ; 81 : result += 1./(1.*2*3*4); - 0009d f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3fa5555555555555 + 0006e dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fa5555555555555 ; 82 : result *= x2; - 000a5 f2 0f 59 c2 mulsd xmm0, xmm2 + 00074 d8 c9 fmul ST(0), ST(1) ; 83 : ; 84 : result += 1./(1.*2); - 000a9 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3fe0000000000000 + 00076 dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fe0000000000000 ; 85 : result *= x2; - 000b1 f2 0f 59 c2 mulsd xmm0, xmm2 + 0007c de c9 fmulp ST(1), ST(0) ; 86 : ; 87 : result += 1; - 000b5 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3ff0000000000000 + 0007e dc 05 00 00 00 + 00 fadd QWORD PTR __real@3ff0000000000000 ; 88 : ; 89 : /* Apply correct sign */ ; 90 : result *= sin_sign_tbl[quadrant]; - 000bd f2 0f 59 04 c5 - 00 00 00 00 mulsd xmm0, QWORD PTR _sin_sign_tbl[eax*8] + 00084 dc 0c c5 00 00 + 00 00 fmul QWORD PTR _sin_sign_tbl[eax*8] ; 91 : ; 92 : return result; - - 000c6 f2 0f 11 45 08 movsd QWORD PTR tv242[ebp], xmm0 - 000cb dd 45 08 fld QWORD PTR tv242[ebp] - ; 93 : } - 000ce 5d pop ebp - 000cf c3 ret 0 + 0008b 5d pop ebp + 0008c c3 ret 0 _sin ENDP _TEXT ENDS ; Function compile flags: /Ogtp ; File c:\users\philip\documents\github\mollenos\clib\src\math\sin.c ; COMDAT _sinh _TEXT SEGMENT -tv137 = 8 ; size = 8 -tv131 = 8 ; size = 8 _x$ = 8 ; size = 8 _sinh PROC ; COMDAT @@ -299,32 +289,35 @@ _sinh PROC ; COMDAT ; 101 : if(x >= 0.0) - 00003 f2 0f 10 45 08 movsd xmm0, QWORD PTR _x$[ebp] - 00008 66 0f 2f 05 00 - 00 00 00 comisd xmm0, QWORD PTR __real@0000000000000000 - 00010 72 27 jb SHORT $LN2@sinh + 00003 d9 ee fldz + 00005 dd 45 08 fld QWORD PTR _x$[ebp] + 00008 d8 d1 fcom ST(1) + 0000a df e0 fnstsw ax + 0000c dd d9 fstp ST(1) + 0000e f6 c4 01 test ah, 1 + 00011 75 13 jne SHORT $LN2@sinh ; 102 : { ; 103 : const double epos = exp(x); - 00012 e8 00 00 00 00 call __libm_sse2_exp_precise + 00013 e8 00 00 00 00 call __CIexp ; 104 : return (epos - 1.0/epos) / 2.0; - 00017 f2 0f 10 0d 00 - 00 00 00 movsd xmm1, QWORD PTR __real@3ff0000000000000 - 0001f f2 0f 5e c8 divsd xmm1, xmm0 - 00023 f2 0f 5c c1 subsd xmm0, xmm1 - 00027 f2 0f 59 05 00 - 00 00 00 mulsd xmm0, QWORD PTR __real@3fe0000000000000 - 0002f f2 0f 11 45 08 movsd QWORD PTR tv137[ebp], xmm0 - 00034 dd 45 08 fld QWORD PTR tv137[ebp] + 00018 d9 e8 fld1 + 0001a d8 f1 fdiv ST(0), ST(1) + 0001c de e9 fsubp ST(1), ST(0) + +; 109 : return (1.0/eneg - eneg) / 2.0; + + 0001e dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3fe0000000000000 ; 110 : } ; 111 : } - 00037 5d pop ebp - 00038 c3 ret 0 + 00024 5d pop ebp + 00025 c3 ret 0 $LN2@sinh: ; 105 : } @@ -332,26 +325,22 @@ $LN2@sinh: ; 107 : { ; 108 : const double eneg = exp(-x); - 00039 66 0f 57 05 00 - 00 00 00 xorpd xmm0, QWORD PTR __xmm@80000000000000008000000000000000 - 00041 e8 00 00 00 00 call __libm_sse2_exp_precise + 00026 d9 e0 fchs + 00028 e8 00 00 00 00 call __CIexp ; 109 : return (1.0/eneg - eneg) / 2.0; - 00046 f2 0f 10 0d 00 - 00 00 00 movsd xmm1, QWORD PTR __real@3ff0000000000000 - 0004e f2 0f 5e c8 divsd xmm1, xmm0 - 00052 f2 0f 5c c8 subsd xmm1, xmm0 - 00056 f2 0f 59 0d 00 - 00 00 00 mulsd xmm1, QWORD PTR __real@3fe0000000000000 - 0005e f2 0f 11 4d 08 movsd QWORD PTR tv131[ebp], xmm1 - 00063 dd 45 08 fld QWORD PTR tv131[ebp] + 0002d d9 e8 fld1 + 0002f d8 f1 fdiv ST(0), ST(1) + 00031 de e1 fsubrp ST(1), ST(0) + 00033 dc 0d 00 00 00 + 00 fmul QWORD PTR __real@3fe0000000000000 ; 110 : } ; 111 : } - 00066 5d pop ebp - 00067 c3 ret 0 + 00039 5d pop ebp + 0003a c3 ret 0 _sinh ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/sinf.cod b/clib/mscv/CLib/sinf.cod index 88854e183..37ebc3bd5 100644 --- a/clib/mscv/CLib/sinf.cod +++ b/clib/mscv/CLib/sinf.cod @@ -10,13 +10,13 @@ INCLUDELIB MSVCRT INCLUDELIB OLDNAMES PUBLIC _sinf -EXTRN __libm_sse2_sin_precise:PROC +EXTRN __CIsin:PROC EXTRN __fltused:DWORD ; Function compile flags: /Ogtp ; File c:\users\philip\documents\github\mollenos\clib\src\math\sinf.c ; COMDAT _sinf _TEXT SEGMENT -tv70 = 8 ; size = 4 +tv72 = 8 ; size = 4 __X$ = 8 ; size = 4 _sinf PROC ; COMDAT @@ -24,20 +24,18 @@ _sinf PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp - 00003 f3 0f 10 45 08 movss xmm0, DWORD PTR __X$[ebp] ; 12 : return ((float) sin ((double) _X)); - 00008 0f 5a c0 cvtps2pd xmm0, xmm0 - 0000b e8 00 00 00 00 call __libm_sse2_sin_precise - 00010 f2 0f 5a c0 cvtsd2ss xmm0, xmm0 - 00014 f3 0f 11 45 08 movss DWORD PTR tv70[ebp], xmm0 - 00019 d9 45 08 fld DWORD PTR tv70[ebp] + 00003 d9 45 08 fld DWORD PTR __X$[ebp] + 00006 e8 00 00 00 00 call __CIsin + 0000b d9 5d 08 fstp DWORD PTR tv72[ebp] + 0000e d9 45 08 fld DWORD PTR tv72[ebp] ; 13 : } - 0001c 5d pop ebp - 0001d c3 ret 0 + 00011 5d pop ebp + 00012 c3 ret 0 _sinf ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/stream.cod b/clib/mscv/CLib/stream.cod index e4fe52e89..ee6d42da5 100644 --- a/clib/mscv/CLib/stream.cod +++ b/clib/mscv/CLib/stream.cod @@ -10,22 +10,22 @@ INCLUDELIB MSVCRT INCLUDELIB OLDNAMES _DATA SEGMENT -$SG2710 DB '-', 00H +$SG2713 DB '-', 00H ORG $+2 -$SG2713 DB '+', 00H +$SG2716 DB '+', 00H ORG $+2 -$SG2716 DB ' ', 00H +$SG2719 DB ' ', 00H ORG $+2 -?_nullstring@?1??streamout@@9@9 DD FLAT:$SG2755 ; `streamout'::`2'::_nullstring -$SG2755 DB '(null)', 00H +?_nullstring@?1??streamout@@9@9 DD FLAT:$SG2758 ; `streamout'::`2'::_nullstring +$SG2758 DB '(null)', 00H ORG $+1 -$SG2972 DB '-', 00H +$SG2975 DB '-', 00H ORG $+2 -$SG2975 DB '+', 00H +$SG2978 DB '+', 00H ORG $+2 -$SG2978 DB ' ', 00H +$SG2981 DB ' ', 00H ORG $+2 -$SG2982 DB '0', 00H +$SG2985 DB '0', 00H _DATA ENDS CONST SEGMENT ?digits_l@?1??format_float@@9@9 DB '0123456789abcdef0x', 00H ; `format_float'::`2'::digits_l @@ -43,27 +43,27 @@ CONST ENDS PUBLIC _StreamCharacterToUtf8 PUBLIC _format_float PUBLIC _streamout +PUBLIC __real@0000000000000000 PUBLIC __real@3fe0000000000000 PUBLIC __real@3ff0000000000000 PUBLIC __real@4024000000000000 -PUBLIC __xmm@80000000000000008000000000000000 +PUBLIC __real@43e0000000000000 EXTRN _putchar:PROC EXTRN __finite:PROC EXTRN __isnan:PROC EXTRN _wcsnlen:PROC +EXTRN __CIlog10:PROC +EXTRN __CIpow:PROC EXTRN __aulldvrm:PROC EXTRN __aullrem:PROC -EXTRN __dtoul3:PROC -EXTRN __libm_sse2_log10_precise:PROC -EXTRN __libm_sse2_pow_precise:PROC -EXTRN __ultod3:PROC +EXTRN __ftol2:PROC +EXTRN __ftol2_sse:PROC EXTRN _floor:PROC EXTRN _memcpy:PROC EXTRN __fltused:DWORD -; COMDAT __xmm@80000000000000008000000000000000 +; COMDAT __real@43e0000000000000 CONST SEGMENT -__xmm@80000000000000008000000000000000 DB 00H, 00H, 00H, 00H, 00H, 00H, 00H - DB 080H, 00H, 00H, 00H, 00H, 00H, 00H, 00H, 080H +__real@43e0000000000000 DQ 043e0000000000000r ; 9.22337e+018 CONST ENDS ; COMDAT __real@4024000000000000 CONST SEGMENT @@ -77,34 +77,40 @@ CONST ENDS CONST SEGMENT __real@3fe0000000000000 DQ 03fe0000000000000r ; 0.5 CONST ENDS +; COMDAT __real@0000000000000000 +CONST SEGMENT +__real@0000000000000000 DQ 00000000000000000r ; 0 +CONST ENDS ; Function compile flags: /Ogtp ; File c:\users\philip\documents\github\mollenos\clib\src\stdio\stream.c ; COMDAT _streamout _TEXT SEGMENT _buffer$ = -104 ; size = 50 _flags$1$ = -52 ; size = 4 -tv725 = -52 ; size = 4 +tv731 = -52 ; size = 4 _prefixlen$1$ = -48 ; size = 4 -tv658 = -48 ; size = 4 +tv666 = -48 ; size = 4 _prefix$ = -48 ; size = 4 _digits$1$ = -44 ; size = 4 _uLen$1 = -44 ; size = 4 tv599 = -40 ; size = 8 _base$1$ = -36 ; size = 4 -_val64$2$ = -32 ; size = 4 -_string$ = -32 ; size = 4 -_val64$1$ = -28 ; size = 4 -_written$4$ = -28 ; size = 4 +_padding$2$ = -32 ; size = 4 +_padding$1$ = -32 ; size = 4 +_val64$2$ = -28 ; size = 4 +_string$ = -28 ; size = 4 _cnt$ = -24 ; size = 4 _prefix$1$ = -20 ; size = 4 _chr$ = -16 ; size = 1 -_padding$2$ = -12 ; size = 4 -_string$1$ = -8 ; size = 4 -_written_all$1$ = -4 ; size = 4 +_written_all$1$ = -12 ; size = 4 +_val64$1$ = -8 ; size = 4 +_written$4$ = -8 ; size = 4 +_string$1$ = -4 ; size = 4 _out$ = 8 ; size = 4 _precision$2$ = 12 ; size = 4 -tv723 = 12 ; size = 4 -tv657 = 12 ; size = 4 +_precision$1$ = 12 ; size = 4 +tv729 = 12 ; size = 4 +tv665 = 12 ; size = 4 _size$ = 12 ; size = 4 _format$ = 16 ; size = 4 _argptr$ = 20 ; size = 4 @@ -144,10 +150,10 @@ _streamout PROC ; COMDAT 00013 57 push edi 00014 33 ff xor edi, edi 00016 89 45 e8 mov DWORD PTR _cnt$[ebp], eax - 00019 89 55 e4 mov DWORD PTR _written$4$[ebp], edx - 0001c 89 7d fc mov DWORD PTR _written_all$1$[ebp], edi + 00019 89 55 f8 mov DWORD PTR _written$4$[ebp], edx + 0001c 89 7d f4 mov DWORD PTR _written_all$1$[ebp], edi 0001f c6 45 c9 00 mov BYTE PTR _buffer$[ebp+49], 0 -$LN271@streamout: +$LN269@streamout: ; 461 : { ; 462 : /* Get character and advance */ @@ -162,7 +168,7 @@ $LN271@streamout: ; 466 : if (chr == '\0') 00029 84 c0 test al, al - 0002b 0f 84 b5 06 00 + 0002b 0f 84 15 07 00 00 je $LN119@streamout ; 467 : break; @@ -172,13 +178,13 @@ $LN271@streamout: ; 471 : (chr = *format++) == ('%')) 00031 3c 25 cmp al, 37 ; 00000025H - 00033 0f 85 0f 06 00 + 00033 0f 85 6c 06 00 00 jne $LN116@streamout 00039 8a 06 mov al, BYTE PTR [esi] 0003b 46 inc esi 0003c 88 45 f0 mov BYTE PTR _chr$[ebp], al 0003f 3c 25 cmp al, 37 ; 00000025H - 00041 0f 84 01 06 00 + 00041 0f 84 5e 06 00 00 je $LN116@streamout ; 521 : continue; @@ -294,11 +300,11 @@ $LN94@streamout: ; 539 : { ; 540 : fieldwidth = va_arg(argptr, int); - 0009f 8b 7d 14 mov edi, DWORD PTR _argptr$[ebp] - 000a2 83 c7 04 add edi, 4 - 000a5 89 7d 14 mov DWORD PTR _argptr$[ebp], edi - 000a8 8b 4f fc mov ecx, DWORD PTR [edi-4] - 000ab 89 4d f4 mov DWORD PTR _padding$2$[ebp], ecx + 0009f 8b 45 14 mov eax, DWORD PTR _argptr$[ebp] + 000a2 83 c0 04 add eax, 4 + 000a5 89 45 14 mov DWORD PTR _argptr$[ebp], eax + 000a8 8b 48 fc mov ecx, DWORD PTR [eax-4] + 000ab 89 4d e0 mov DWORD PTR _padding$1$[ebp], ecx ; 541 : if (fieldwidth < 0) @@ -313,7 +319,7 @@ $LN94@streamout: ; 544 : fieldwidth = -fieldwidth; 000b5 f7 d9 neg ecx - 000b7 89 4d f4 mov DWORD PTR _padding$2$[ebp], ecx + 000b7 89 4d e0 mov DWORD PTR _padding$1$[ebp], ecx $LN91@streamout: ; 545 : } @@ -326,19 +332,19 @@ $LN91@streamout: ; 547 : } ; 548 : else - 000c0 eb 2e jmp SHORT $LN88@streamout + 000c0 eb 2b jmp SHORT $LN88@streamout $LN92@streamout: ; 549 : { ; 550 : fieldwidth = 0; 000c2 33 c9 xor ecx, ecx - 000c4 89 4d f4 mov DWORD PTR _padding$2$[ebp], ecx + 000c4 89 4d e0 mov DWORD PTR _padding$1$[ebp], ecx ; 551 : while (chr >= ('0') && chr <= ('9')) 000c7 3c 30 cmp al, 48 ; 00000030H - 000c9 7c 22 jl SHORT $LN252@streamout + 000c9 7c 22 jl SHORT $LN88@streamout 000cb eb 03 8d 49 00 npad 5 $LL89@streamout: 000d0 3c 39 cmp al, 57 ; 00000039H @@ -360,9 +366,7 @@ $LL89@streamout: 000e6 3c 30 cmp al, 48 ; 00000030H 000e8 7d e6 jge SHORT $LL89@streamout $LN248@streamout: - 000ea 89 4d f4 mov DWORD PTR _padding$2$[ebp], ecx -$LN252@streamout: - 000ed 8b 7d 14 mov edi, DWORD PTR _argptr$[ebp] + 000ea 89 4d e0 mov DWORD PTR _padding$1$[ebp], ecx $LN88@streamout: ; 555 : } @@ -371,83 +375,86 @@ $LN88@streamout: ; 558 : /* Handle precision modifier */ ; 559 : if (chr == '.') - 000f0 3c 2e cmp al, 46 ; 0000002eH - 000f2 75 43 jne SHORT $LN87@streamout + 000ed 3c 2e cmp al, 46 ; 0000002eH + 000ef 75 4e jne SHORT $LN87@streamout ; 560 : { ; 561 : chr = *format++; - 000f4 8a 06 mov al, BYTE PTR [esi] - 000f6 46 inc esi - 000f7 88 45 f0 mov BYTE PTR _chr$[ebp], al + 000f1 8a 06 mov al, BYTE PTR [esi] + 000f3 46 inc esi + 000f4 88 45 f0 mov BYTE PTR _chr$[ebp], al ; 562 : ; 563 : if (chr == ('*')) - 000fa 3c 2a cmp al, 42 ; 0000002aH - 000fc 75 11 jne SHORT $LN86@streamout + 000f7 3c 2a cmp al, 42 ; 0000002aH + 000f9 75 17 jne SHORT $LN86@streamout ; 564 : { ; 565 : precision = va_arg(argptr, int); + + 000fb 8b 45 14 mov eax, DWORD PTR _argptr$[ebp] + 000fe 83 c0 04 add eax, 4 + 00101 89 45 14 mov DWORD PTR _argptr$[ebp], eax + 00104 8b 48 fc mov ecx, DWORD PTR [eax-4] + ; 566 : chr = *format++; - 000fe 8a 06 mov al, BYTE PTR [esi] - 00100 83 c7 04 add edi, 4 - 00103 89 7d 14 mov DWORD PTR _argptr$[ebp], edi - 00106 46 inc esi - 00107 88 45 f0 mov BYTE PTR _chr$[ebp], al - 0010a 8b 7f fc mov edi, DWORD PTR [edi-4] + 00107 8a 06 mov al, BYTE PTR [esi] + 00109 46 inc esi + 0010a 89 4d 0c mov DWORD PTR _precision$1$[ebp], ecx + 0010d 88 45 f0 mov BYTE PTR _chr$[ebp], al ; 567 : } ; 568 : else - 0010d eb 2b jmp SHORT $LN264@streamout + 00110 eb 34 jmp SHORT $LL81@streamout $LN86@streamout: ; 569 : { ; 570 : precision = 0; - 0010f 33 ff xor edi, edi - 00111 89 7d 0c mov DWORD PTR _precision$2$[ebp], edi + 00112 33 c9 xor ecx, ecx + 00114 89 4d 0c mov DWORD PTR _precision$1$[ebp], ecx ; 571 : while (chr >= ('0') && chr <= ('9')) - 00114 3c 30 cmp al, 48 ; 00000030H - 00116 7c 28 jl SHORT $LL81@streamout + 00117 3c 30 cmp al, 48 ; 00000030H + 00119 7c 2b jl SHORT $LL81@streamout + 0011b eb 03 8d 49 00 npad 5 $LL84@streamout: - 00118 3c 39 cmp al, 57 ; 00000039H - 0011a 7f 24 jg SHORT $LL81@streamout + 00120 3c 39 cmp al, 57 ; 00000039H + 00122 7f 22 jg SHORT $LL81@streamout ; 572 : { ; 573 : precision = precision * 10 + (chr - ('0')); - 0011c 0f be c0 movsx eax, al - 0011f 8d 0c bf lea ecx, DWORD PTR [edi+edi*4] - 00122 8d 79 e8 lea edi, DWORD PTR [ecx-24] - 00125 8d 3c 78 lea edi, DWORD PTR [eax+edi*2] + 00124 0f be c0 movsx eax, al + 00127 8d 0c 89 lea ecx, DWORD PTR [ecx+ecx*4] + 0012a 8d 49 e8 lea ecx, DWORD PTR [ecx-24] + 0012d 8d 0c 48 lea ecx, DWORD PTR [eax+ecx*2] ; 574 : chr = *format++; - 00128 8a 06 mov al, BYTE PTR [esi] - 0012a 46 inc esi - 0012b 89 7d 0c mov DWORD PTR _precision$2$[ebp], edi - 0012e 88 45 f0 mov BYTE PTR _chr$[ebp], al - 00131 3c 30 cmp al, 48 ; 00000030H - 00133 7d e3 jge SHORT $LL84@streamout + 00130 8a 06 mov al, BYTE PTR [esi] + 00132 46 inc esi + 00133 89 4d 0c mov DWORD PTR _precision$1$[ebp], ecx + 00136 88 45 f0 mov BYTE PTR _chr$[ebp], al + 00139 3c 30 cmp al, 48 ; 00000030H + 0013b 7d e3 jge SHORT $LL84@streamout ; 575 : } ; 576 : } - 00135 eb 09 jmp SHORT $LL81@streamout + 0013d eb 07 jmp SHORT $LL81@streamout $LN87@streamout: ; 577 : } ; 578 : else precision = -1; - 00137 83 cf ff or edi, -1 -$LN264@streamout: - 0013a 89 7d 0c mov DWORD PTR _precision$2$[ebp], edi - 0013d 8d 49 00 npad 3 + 0013f c7 45 0c ff ff + ff ff mov DWORD PTR _precision$1$[ebp], -1 $LL81@streamout: ; 579 : @@ -456,8 +463,8 @@ $LL81@streamout: ; 582 : { ; 583 : if (chr == ('h')) flags |= FLAG_SHORT; - 00140 3c 68 cmp al, 104 ; 00000068H - 00142 75 0e jne SHORT $LN78@streamout + 00146 3c 68 cmp al, 104 ; 00000068H + 00148 75 0e jne SHORT $LN78@streamout ; 607 : { ; 608 : flags |= FLAG_INTPTR; @@ -467,22 +474,22 @@ $LL81@streamout: ; 612 : else break; ; 613 : chr = *format++; - 00144 8a 06 mov al, BYTE PTR [esi] - 00146 81 cb 00 01 00 + 0014a 8a 06 mov al, BYTE PTR [esi] + 0014c 81 cb 00 01 00 00 or ebx, 256 ; 00000100H - 0014c 88 45 f0 mov BYTE PTR _chr$[ebp], al - 0014f 46 inc esi + 00152 88 45 f0 mov BYTE PTR _chr$[ebp], al + 00155 46 inc esi ; 614 : } ; 615 : while (USE_MULTISIZE); - 00150 eb ee jmp SHORT $LL81@streamout + 00156 eb ee jmp SHORT $LL81@streamout $LN78@streamout: ; 584 : else if (chr == ('w')) flags |= FLAG_WIDECHAR; - 00152 3c 77 cmp al, 119 ; 00000077H - 00154 75 0e jne SHORT $LN76@streamout + 00158 3c 77 cmp al, 119 ; 00000077H + 0015a 75 0e jne SHORT $LN76@streamout $LN69@streamout: ; 607 : { @@ -493,39 +500,39 @@ $LN69@streamout: ; 612 : else break; ; 613 : chr = *format++; - 00156 8a 06 mov al, BYTE PTR [esi] - 00158 81 cb 00 02 00 + 0015c 8a 06 mov al, BYTE PTR [esi] + 0015e 81 cb 00 02 00 00 or ebx, 512 ; 00000200H - 0015e 88 45 f0 mov BYTE PTR _chr$[ebp], al - 00161 46 inc esi + 00164 88 45 f0 mov BYTE PTR _chr$[ebp], al + 00167 46 inc esi ; 614 : } ; 615 : while (USE_MULTISIZE); - 00162 eb dc jmp SHORT $LL81@streamout + 00168 eb dc jmp SHORT $LL81@streamout $LN76@streamout: ; 585 : else if (chr == ('L')) flags |= 0; // FIXME: long double - 00164 3c 4c cmp al, 76 ; 0000004cH - 00166 74 73 je SHORT $LN60@streamout + 0016a 3c 4c cmp al, 76 ; 0000004cH + 0016c 74 73 je SHORT $LN60@streamout ; 586 : else if (chr == ('F')) flags |= 0; // FIXME: what is that? - 00168 3c 46 cmp al, 70 ; 00000046H - 0016a 74 6f je SHORT $LN60@streamout + 0016e 3c 46 cmp al, 70 ; 00000046H + 00170 74 6f je SHORT $LN60@streamout ; 587 : else if (chr == ('l')) - 0016c 3c 6c cmp al, 108 ; 0000006cH - 0016e 75 13 jne SHORT $LN70@streamout + 00172 3c 6c cmp al, 108 ; 0000006cH + 00174 75 13 jne SHORT $LN70@streamout ; 588 : { ; 589 : /* Check if this is the 2nd 'l' in a row */ ; 590 : if (format[-2] == 'l') flags |= FLAG_INT64; - 00170 38 46 fe cmp BYTE PTR [esi-2], al - 00173 75 e1 jne SHORT $LN69@streamout + 00176 38 46 fe cmp BYTE PTR [esi-2], al + 00179 75 e1 jne SHORT $LN69@streamout ; 607 : { ; 608 : flags |= FLAG_INTPTR; @@ -535,33 +542,33 @@ $LN76@streamout: ; 612 : else break; ; 613 : chr = *format++; - 00175 8a 06 mov al, BYTE PTR [esi] - 00177 81 cb 00 04 00 + 0017b 8a 06 mov al, BYTE PTR [esi] + 0017d 81 cb 00 04 00 00 or ebx, 1024 ; 00000400H - 0017d 88 45 f0 mov BYTE PTR _chr$[ebp], al - 00180 46 inc esi + 00183 88 45 f0 mov BYTE PTR _chr$[ebp], al + 00186 46 inc esi ; 614 : } ; 615 : while (USE_MULTISIZE); - 00181 eb bd jmp SHORT $LL81@streamout + 00187 eb bd jmp SHORT $LL81@streamout $LN70@streamout: ; 591 : else flags |= FLAG_LONG; ; 592 : } ; 593 : else if (chr == ('I')) - 00183 3c 49 cmp al, 73 ; 00000049H - 00185 75 5f jne SHORT $LN79@streamout + 00189 3c 49 cmp al, 73 ; 00000049H + 0018b 75 5f jne SHORT $LN79@streamout ; 594 : { ; 595 : if (format[0] == ('3') && format[1] == ('2')) - 00187 8a 0e mov cl, BYTE PTR [esi] - 00189 80 f9 33 cmp cl, 51 ; 00000033H - 0018c 75 12 jne SHORT $LN65@streamout - 0018e 80 7e 01 32 cmp BYTE PTR [esi+1], 50 ; 00000032H - 00192 75 0c jne SHORT $LN65@streamout + 0018d 8a 0e mov cl, BYTE PTR [esi] + 0018f 80 f9 33 cmp cl, 51 ; 00000033H + 00192 75 12 jne SHORT $LN65@streamout + 00194 80 7e 01 32 cmp BYTE PTR [esi+1], 50 ; 00000032H + 00198 75 0c jne SHORT $LN65@streamout ; 607 : { ; 608 : flags |= FLAG_INTPTR; @@ -571,15 +578,15 @@ $LN70@streamout: ; 612 : else break; ; 613 : chr = *format++; - 00194 8a 46 02 mov al, BYTE PTR [esi+2] - 00197 83 c6 02 add esi, 2 - 0019a 88 45 f0 mov BYTE PTR _chr$[ebp], al - 0019d 46 inc esi + 0019a 8a 46 02 mov al, BYTE PTR [esi+2] + 0019d 83 c6 02 add esi, 2 + 001a0 88 45 f0 mov BYTE PTR _chr$[ebp], al + 001a3 46 inc esi ; 614 : } ; 615 : while (USE_MULTISIZE); - 0019e eb a0 jmp SHORT $LL81@streamout + 001a4 eb a0 jmp SHORT $LL81@streamout $LN65@streamout: ; 596 : { @@ -587,10 +594,10 @@ $LN65@streamout: ; 598 : } ; 599 : else if (format[0] == ('6') && format[1] == ('4')) - 001a0 80 f9 36 cmp cl, 54 ; 00000036H - 001a3 75 18 jne SHORT $LN63@streamout - 001a5 80 7e 01 34 cmp BYTE PTR [esi+1], 52 ; 00000034H - 001a9 75 12 jne SHORT $LN63@streamout + 001a6 80 f9 36 cmp cl, 54 ; 00000036H + 001a9 75 18 jne SHORT $LN63@streamout + 001ab 80 7e 01 34 cmp BYTE PTR [esi+1], 52 ; 00000034H + 001af 75 12 jne SHORT $LN63@streamout ; 607 : { ; 608 : flags |= FLAG_INTPTR; @@ -600,17 +607,17 @@ $LN65@streamout: ; 612 : else break; ; 613 : chr = *format++; - 001ab 8a 46 02 mov al, BYTE PTR [esi+2] - 001ae 83 c6 02 add esi, 2 - 001b1 81 cb 00 04 00 + 001b1 8a 46 02 mov al, BYTE PTR [esi+2] + 001b4 83 c6 02 add esi, 2 + 001b7 81 cb 00 04 00 00 or ebx, 1024 ; 00000400H - 001b7 88 45 f0 mov BYTE PTR _chr$[ebp], al - 001ba 46 inc esi + 001bd 88 45 f0 mov BYTE PTR _chr$[ebp], al + 001c0 46 inc esi ; 614 : } ; 615 : while (USE_MULTISIZE); - 001bb eb 83 jmp SHORT $LL81@streamout + 001c1 eb 83 jmp SHORT $LL81@streamout $LN63@streamout: ; 600 : { @@ -621,18 +628,18 @@ $LN63@streamout: ; 605 : format[0] == ('d') || format[0] == ('i') || ; 606 : format[0] == ('u') || format[0] == ('o')) - 001bd 80 f9 78 cmp cl, 120 ; 00000078H - 001c0 74 19 je SHORT $LN60@streamout - 001c2 80 f9 58 cmp cl, 88 ; 00000058H - 001c5 74 14 je SHORT $LN60@streamout - 001c7 80 f9 64 cmp cl, 100 ; 00000064H - 001ca 74 0f je SHORT $LN60@streamout - 001cc 80 f9 69 cmp cl, 105 ; 00000069H - 001cf 74 0a je SHORT $LN60@streamout - 001d1 80 f9 75 cmp cl, 117 ; 00000075H - 001d4 74 05 je SHORT $LN60@streamout - 001d6 80 f9 6f cmp cl, 111 ; 0000006fH - 001d9 75 0b jne SHORT $LN79@streamout + 001c3 80 f9 78 cmp cl, 120 ; 00000078H + 001c6 74 19 je SHORT $LN60@streamout + 001c8 80 f9 58 cmp cl, 88 ; 00000058H + 001cb 74 14 je SHORT $LN60@streamout + 001cd 80 f9 64 cmp cl, 100 ; 00000064H + 001d0 74 0f je SHORT $LN60@streamout + 001d2 80 f9 69 cmp cl, 105 ; 00000069H + 001d5 74 0a je SHORT $LN60@streamout + 001d7 80 f9 75 cmp cl, 117 ; 00000075H + 001da 74 05 je SHORT $LN60@streamout + 001dc 80 f9 6f cmp cl, 111 ; 0000006fH + 001df 75 0b jne SHORT $LN79@streamout $LN60@streamout: ; 607 : { @@ -643,14 +650,14 @@ $LN60@streamout: ; 612 : else break; ; 613 : chr = *format++; - 001db 8a 06 mov al, BYTE PTR [esi] - 001dd 46 inc esi - 001de 88 45 f0 mov BYTE PTR _chr$[ebp], al + 001e1 8a 06 mov al, BYTE PTR [esi] + 001e3 46 inc esi + 001e4 88 45 f0 mov BYTE PTR _chr$[ebp], al ; 614 : } ; 615 : while (USE_MULTISIZE); - 001e1 e9 5a ff ff ff jmp $LL81@streamout + 001e7 e9 5a ff ff ff jmp $LL81@streamout $LN79@streamout: ; 616 : @@ -658,115 +665,126 @@ $LN79@streamout: ; 618 : digits = digits_l; ; 619 : string = &buffer[BUFFER_SIZE]; - 001e6 8d 4d c9 lea ecx, DWORD PTR _buffer$[ebp+49] + 001ec 8d 4d c9 lea ecx, DWORD PTR _buffer$[ebp+49] ; 620 : base = 10; ; 621 : prefix = 0; ; 622 : switch (chr) - 001e9 0f be c0 movsx eax, al - 001ec 89 4d f8 mov DWORD PTR _string$1$[ebp], ecx - 001ef 83 c0 bf add eax, -65 ; ffffffbfH - 001f2 89 4d e0 mov DWORD PTR _string$[ebp], ecx - 001f5 33 c9 xor ecx, ecx - 001f7 89 75 10 mov DWORD PTR _format$[ebp], esi - 001fa c7 45 d4 00 00 + 001ef 0f be c0 movsx eax, al + 001f2 89 4d fc mov DWORD PTR _string$1$[ebp], ecx + 001f5 83 c0 bf add eax, -65 ; ffffffbfH + 001f8 89 4d e4 mov DWORD PTR _string$[ebp], ecx + 001fb 33 c9 xor ecx, ecx + 001fd 89 75 10 mov DWORD PTR _format$[ebp], esi + 00200 c7 45 d4 00 00 00 00 mov DWORD PTR _digits$1$[ebp], OFFSET ?digits_l@?1??streamout@@9@9 - 00201 c7 45 dc 0a 00 + 00207 c7 45 dc 0a 00 00 00 mov DWORD PTR _base$1$[ebp], 10 ; 0000000aH - 00208 89 4d ec mov DWORD PTR _prefix$1$[ebp], ecx - 0020b 89 4d d0 mov DWORD PTR _prefix$[ebp], ecx - 0020e 83 f8 37 cmp eax, 55 ; 00000037H - 00211 0f 87 28 04 00 + 0020e 89 4d ec mov DWORD PTR _prefix$1$[ebp], ecx + 00211 89 4d d0 mov DWORD PTR _prefix$[ebp], ecx + 00214 83 f8 37 cmp eax, 55 ; 00000037H + 00217 0f 87 82 04 00 00 ja $LN22@streamout - 00217 0f b6 80 00 00 + 0021d 0f b6 80 00 00 00 00 movzx eax, BYTE PTR $LN222@streamout[eax] - 0021e ff 24 85 00 00 - 00 00 jmp DWORD PTR $LN274@streamout[eax*4] + 00224 ff 24 85 00 00 + 00 00 jmp DWORD PTR $LN271@streamout[eax*4] $LN55@streamout: ; 623 : { ; 624 : case ('n'): ; 625 : if (flags & FLAG_INT64) -; 626 : *va_arg(argptr, __int64*) = written_all; - 00225 8b 4d 14 mov ecx, DWORD PTR _argptr$[ebp] - 00228 8b 7d fc mov edi, DWORD PTR _written_all$1$[ebp] - 0022b 83 c1 04 add ecx, 4 - 0022e 89 4d 14 mov DWORD PTR _argptr$[ebp], ecx - 00231 f7 c3 00 04 00 + 0022b f7 c3 00 04 00 00 test ebx, 1024 ; 00000400H - 00237 74 13 je SHORT $LN54@streamout - 00239 8b 49 fc mov ecx, DWORD PTR [ecx-4] - 0023c 8b c7 mov eax, edi - 0023e 99 cdq - 0023f 89 01 mov DWORD PTR [ecx], eax - 00241 89 51 04 mov DWORD PTR [ecx+4], edx - 00244 8b 55 e4 mov edx, DWORD PTR _written$4$[ebp] - 00247 e9 92 04 00 00 jmp $LN163@streamout + 00231 74 1c je SHORT $LN54@streamout + +; 626 : *va_arg(argptr, __int64*) = written_all; + + 00233 8b 5d 14 mov ebx, DWORD PTR _argptr$[ebp] + 00236 8b c7 mov eax, edi + 00238 83 c3 04 add ebx, 4 + 0023b 99 cdq + 0023c 89 5d 14 mov DWORD PTR _argptr$[ebp], ebx + 0023f 8b 4b fc mov ecx, DWORD PTR [ebx-4] + 00242 89 01 mov DWORD PTR [ecx], eax + 00244 89 51 04 mov DWORD PTR [ecx+4], edx + 00247 8b 55 f8 mov edx, DWORD PTR _written$4$[ebp] + 0024a e9 ef 04 00 00 jmp $LN163@streamout $LN54@streamout: ; 627 : else if (flags & FLAG_SHORT) -; 628 : *va_arg(argptr, short*) = (short)written_all; - 0024c 8b 41 fc mov eax, DWORD PTR [ecx-4] 0024f f7 c3 00 01 00 00 test ebx, 256 ; 00000100H - 00255 74 08 je SHORT $LN52@streamout - 00257 66 89 38 mov WORD PTR [eax], di + 00255 74 14 je SHORT $LN52@streamout + +; 628 : *va_arg(argptr, short*) = (short)written_all; + + 00257 8b 4d 14 mov ecx, DWORD PTR _argptr$[ebp] + 0025a 83 c1 04 add ecx, 4 + 0025d 89 4d 14 mov DWORD PTR _argptr$[ebp], ecx + 00260 8b 41 fc mov eax, DWORD PTR [ecx-4] + 00263 66 89 38 mov WORD PTR [eax], di ; 629 : else - 0025a e9 7f 04 00 00 jmp $LN163@streamout + 00266 e9 d3 04 00 00 jmp $LN163@streamout $LN52@streamout: ; 630 : *va_arg(argptr, int*) = written_all; - 0025f 89 38 mov DWORD PTR [eax], edi + 0026b 8b 45 14 mov eax, DWORD PTR _argptr$[ebp] + 0026e 83 c0 04 add eax, 4 + 00271 89 45 14 mov DWORD PTR _argptr$[ebp], eax + 00274 8b 40 fc mov eax, DWORD PTR [eax-4] + 00277 89 38 mov DWORD PTR [eax], edi ; 631 : continue; - 00261 e9 78 04 00 00 jmp $LN163@streamout + 00279 e9 c0 04 00 00 jmp $LN163@streamout $LN50@streamout: ; 632 : ; 633 : case ('C'): ; 634 : case ('c'): ; 635 : string = buffer; + + 0027e 8d 45 98 lea eax, DWORD PTR _buffer$[ebp] + ; 636 : len = 1; ; 637 : ; 638 : /* Get character */ ; 639 : uint32_t uChar = (uint32_t)va_arg(argptr, int); +; 640 : uint32_t uLen = 0; - 00266 8b 4d 14 mov ecx, DWORD PTR _argptr$[ebp] - 00269 8d 45 98 lea eax, DWORD PTR _buffer$[ebp] - 0026c 89 45 f8 mov DWORD PTR _string$1$[ebp], eax - 0026f 83 c1 04 add ecx, 4 + 00281 89 4d d4 mov DWORD PTR _uLen$1[ebp], ecx + 00284 89 45 fc mov DWORD PTR _string$1$[ebp], eax -; 640 : uint32_t uLen = 0; ; 641 : ; 642 : /* Stream it out */ ; 643 : StreamCharacterToUtf8(uChar, string, &uLen); - 00272 8d 45 d4 lea eax, DWORD PTR _uLen$1[ebp] - 00275 89 4d 14 mov DWORD PTR _argptr$[ebp], ecx - 00278 50 push eax - 00279 8d 45 98 lea eax, DWORD PTR _buffer$[ebp] - 0027c c7 45 d4 00 00 - 00 00 mov DWORD PTR _uLen$1[ebp], 0 - 00283 50 push eax - 00284 ff 71 fc push DWORD PTR [ecx-4] - 00287 e8 00 00 00 00 call _StreamCharacterToUtf8 + 00287 8d 4d d4 lea ecx, DWORD PTR _uLen$1[ebp] + 0028a 8b 45 14 mov eax, DWORD PTR _argptr$[ebp] + 0028d 51 push ecx + 0028e 83 c0 04 add eax, 4 + 00291 8d 4d 98 lea ecx, DWORD PTR _buffer$[ebp] + 00294 51 push ecx + 00295 89 45 14 mov DWORD PTR _argptr$[ebp], eax + 00298 ff 70 fc push DWORD PTR [eax-4] + 0029b e8 00 00 00 00 call _StreamCharacterToUtf8 ; 644 : ; 645 : /* Null terminate */ ; 646 : ((char*)string)[uLen] = (char)('\0'); - 0028c 8b 7d d4 mov edi, DWORD PTR _uLen$1[ebp] - 0028f 83 c4 0c add esp, 12 ; 0000000cH - 00292 c6 44 3d 98 00 mov BYTE PTR _buffer$[ebp+edi], 0 -$LN250@streamout: - 00297 8b 4d 0c mov ecx, DWORD PTR _precision$2$[ebp] + 002a0 8b 7d d4 mov edi, DWORD PTR _uLen$1[ebp] + 002a3 83 c4 0c add esp, 12 ; 0000000cH + 002a6 c6 44 3d 98 00 mov BYTE PTR _buffer$[ebp+edi], 0 +$LN251@streamout: + 002ab 8b 55 0c mov edx, DWORD PTR _precision$1$[ebp] $LN131@streamout: ; 768 : } @@ -774,66 +792,70 @@ $LN131@streamout: ; 770 : /* Calculate padding */ ; 771 : prefixlen = prefix ? strlen(prefix) : 0; - 0029a 33 d2 xor edx, edx -$LN268@streamout: + 002ae 33 c9 xor ecx, ecx +$LN266@streamout: ; 772 : if (precision < 0) precision = 0; - 0029c 33 c0 xor eax, eax - 0029e 89 55 d0 mov DWORD PTR _prefixlen$1$[ebp], edx - 002a1 85 c9 test ecx, ecx - 002a3 0f 48 c8 cmovs ecx, eax + 002b0 33 c0 xor eax, eax + 002b2 89 4d d0 mov DWORD PTR _prefixlen$1$[ebp], ecx + 002b5 85 d2 test edx, edx + 002b7 0f 98 c0 sets al + 002ba 48 dec eax + 002bb 23 c2 and eax, edx ; 773 : padding = (int)(fieldwidth - len - prefixlen - precision); - 002a6 8b 45 f4 mov eax, DWORD PTR _padding$2$[ebp] - 002a9 2b c2 sub eax, edx - 002ab 89 4d 0c mov DWORD PTR _precision$2$[ebp], ecx - 002ae 2b c7 sub eax, edi - 002b0 2b c1 sub eax, ecx + 002bd 8b 55 e0 mov edx, DWORD PTR _padding$1$[ebp] + 002c0 2b d1 sub edx, ecx + 002c2 89 45 0c mov DWORD PTR _precision$2$[ebp], eax + 002c5 2b d7 sub edx, edi + 002c7 2b d0 sub edx, eax ; 774 : if (padding < 0) padding = 0; - 002b2 b9 00 00 00 00 mov ecx, 0 - 002b7 0f 48 c1 cmovs eax, ecx - 002ba 89 45 f4 mov DWORD PTR _padding$2$[ebp], eax + 002c9 b8 00 00 00 00 mov eax, 0 + 002ce 0f 98 c0 sets al + 002d1 48 dec eax + 002d2 23 c2 and eax, edx + 002d4 89 45 e0 mov DWORD PTR _padding$2$[ebp], eax ; 775 : ; 776 : /* Optional left space padding */ ; 777 : if ((flags & (FLAG_ALIGN_LEFT | FLAG_PAD_ZERO)) == 0) - 002bd f6 c3 09 test bl, 9 - 002c0 75 2e jne SHORT $LN16@streamout + 002d7 f6 c3 09 test bl, 9 + 002da 75 2e jne SHORT $LN16@streamout ; 778 : { ; 779 : for (; padding > 0; padding--) - 002c2 85 c0 test eax, eax - 002c4 7e 2a jle SHORT $LN16@streamout + 002dc 85 c0 test eax, eax + 002de 7e 2a jle SHORT $LN16@streamout $LL18@streamout: ; 780 : { ; 781 : if ((written = StreamOutCharacter(out, &cnt, (' '))) == 0) return -1; - 002c6 6a 20 push 32 ; 00000020H - 002c8 8d 45 e8 lea eax, DWORD PTR _cnt$[ebp] - 002cb 50 push eax - 002cc ff 75 08 push DWORD PTR _out$[ebp] - 002cf e8 00 00 00 00 call _StreamOutCharacter - 002d4 83 c4 0c add esp, 12 ; 0000000cH - 002d7 85 c0 test eax, eax - 002d9 0f 84 18 04 00 + 002e0 6a 20 push 32 ; 00000020H + 002e2 8d 45 e8 lea eax, DWORD PTR _cnt$[ebp] + 002e5 50 push eax + 002e6 ff 75 08 push DWORD PTR _out$[ebp] + 002e9 e8 00 00 00 00 call _StreamOutCharacter + 002ee 83 c4 0c add esp, 12 ; 0000000cH + 002f1 85 c0 test eax, eax + 002f3 0f 84 5b 04 00 00 je $LN152@streamout ; 782 : written_all += written; - 002df 01 45 fc add DWORD PTR _written_all$1$[ebp], eax - 002e2 8b 45 f4 mov eax, DWORD PTR _padding$2$[ebp] - 002e5 48 dec eax - 002e6 89 45 f4 mov DWORD PTR _padding$2$[ebp], eax - 002e9 85 c0 test eax, eax - 002eb 7f d9 jg SHORT $LL18@streamout - 002ed 8b 55 d0 mov edx, DWORD PTR _prefixlen$1$[ebp] + 002f9 01 45 f4 add DWORD PTR _written_all$1$[ebp], eax + 002fc 8b 45 e0 mov eax, DWORD PTR _padding$2$[ebp] + 002ff 48 dec eax + 00300 89 45 e0 mov DWORD PTR _padding$2$[ebp], eax + 00303 85 c0 test eax, eax + 00305 7f d9 jg SHORT $LL18@streamout + 00307 8b 4d d0 mov ecx, DWORD PTR _prefixlen$1$[ebp] $LN16@streamout: ; 783 : } @@ -842,30 +864,30 @@ $LN16@streamout: ; 786 : /* Optional prefix */ ; 787 : if (prefix) - 002f0 8b 4d ec mov ecx, DWORD PTR _prefix$1$[ebp] - 002f3 85 c9 test ecx, ecx - 002f5 74 1d je SHORT $LN14@streamout + 0030a 8b 45 ec mov eax, DWORD PTR _prefix$1$[ebp] + 0030d 85 c0 test eax, eax + 0030f 74 1d je SHORT $LN14@streamout ; 788 : { ; 789 : written = streamout_string(out, &cnt, prefix, prefixlen); - 002f7 52 push edx - 002f8 51 push ecx - 002f9 8d 45 e8 lea eax, DWORD PTR _cnt$[ebp] - 002fc 50 push eax - 002fd ff 75 08 push DWORD PTR _out$[ebp] - 00300 e8 00 00 00 00 call _StreamOutString - 00305 83 c4 10 add esp, 16 ; 00000010H + 00311 51 push ecx + 00312 50 push eax + 00313 8d 45 e8 lea eax, DWORD PTR _cnt$[ebp] + 00316 50 push eax + 00317 ff 75 08 push DWORD PTR _out$[ebp] + 0031a e8 00 00 00 00 call _StreamOutString + 0031f 83 c4 10 add esp, 16 ; 00000010H ; 790 : if (written == -1) return -1; - 00308 83 f8 ff cmp eax, -1 - 0030b 0f 84 e6 03 00 + 00322 83 f8 ff cmp eax, -1 + 00325 0f 84 29 04 00 00 je $LN152@streamout ; 791 : written_all += written; - 00311 01 45 fc add DWORD PTR _written_all$1$[ebp], eax + 0032b 01 45 f4 add DWORD PTR _written_all$1$[ebp], eax $LN14@streamout: ; 792 : } @@ -873,41 +895,41 @@ $LN14@streamout: ; 794 : /* Optional left '0' padding */ ; 795 : if ((flags & FLAG_ALIGN_LEFT) == 0) precision += padding; - 00314 8b c3 mov eax, ebx - 00316 83 e0 01 and eax, 1 - 00319 89 45 cc mov DWORD PTR tv725[ebp], eax - 0031c 8b 45 0c mov eax, DWORD PTR _precision$2$[ebp] - 0031f 75 03 jne SHORT $LN143@streamout - 00321 03 45 f4 add eax, DWORD PTR _padding$2$[ebp] + 0032e 8b c3 mov eax, ebx + 00330 83 e0 01 and eax, 1 + 00333 89 45 cc mov DWORD PTR tv731[ebp], eax + 00336 8b 45 0c mov eax, DWORD PTR _precision$2$[ebp] + 00339 75 03 jne SHORT $LN143@streamout + 0033b 03 45 e0 add eax, DWORD PTR _padding$2$[ebp] $LN143@streamout: ; 796 : while (precision-- > 0) - 00324 85 c0 test eax, eax - 00326 7e 27 jle SHORT $LN158@streamout + 0033e 85 c0 test eax, eax + 00340 7e 27 jle SHORT $LN158@streamout $LL11@streamout: - 00328 48 dec eax - 00329 89 45 0c mov DWORD PTR _precision$2$[ebp], eax + 00342 48 dec eax + 00343 89 45 0c mov DWORD PTR _precision$2$[ebp], eax ; 797 : { ; 798 : if ((written = StreamOutCharacter(out, &cnt, ('0'))) == 0) return -1; - 0032c 8d 45 e8 lea eax, DWORD PTR _cnt$[ebp] - 0032f 6a 30 push 48 ; 00000030H - 00331 50 push eax - 00332 ff 75 08 push DWORD PTR _out$[ebp] - 00335 e8 00 00 00 00 call _StreamOutCharacter - 0033a 83 c4 0c add esp, 12 ; 0000000cH - 0033d 85 c0 test eax, eax - 0033f 0f 84 b2 03 00 + 00346 8d 45 e8 lea eax, DWORD PTR _cnt$[ebp] + 00349 6a 30 push 48 ; 00000030H + 0034b 50 push eax + 0034c ff 75 08 push DWORD PTR _out$[ebp] + 0034f e8 00 00 00 00 call _StreamOutCharacter + 00354 83 c4 0c add esp, 12 ; 0000000cH + 00357 85 c0 test eax, eax + 00359 0f 84 f5 03 00 00 je $LN152@streamout ; 799 : written_all += written; - 00345 01 45 fc add DWORD PTR _written_all$1$[ebp], eax - 00348 8b 45 0c mov eax, DWORD PTR _precision$2$[ebp] - 0034b 85 c0 test eax, eax - 0034d 7f d9 jg SHORT $LL11@streamout + 0035f 01 45 f4 add DWORD PTR _written_all$1$[ebp], eax + 00362 8b 45 0c mov eax, DWORD PTR _precision$2$[ebp] + 00365 85 c0 test eax, eax + 00367 7f d9 jg SHORT $LL11@streamout $LN158@streamout: ; 800 : } @@ -916,22 +938,22 @@ $LN158@streamout: ; 803 : if (flags & FLAG_WIDECHAR) ; 804 : written = StreamOutWString(out, &cnt, (wchar_t*)string, len); - 0034f 8d 45 e8 lea eax, DWORD PTR _cnt$[ebp] - 00352 57 push edi - 00353 ff 75 f8 push DWORD PTR _string$1$[ebp] - 00356 50 push eax - 00357 ff 75 08 push DWORD PTR _out$[ebp] - 0035a f7 c3 00 02 00 + 00369 8d 45 e8 lea eax, DWORD PTR _cnt$[ebp] + 0036c 57 push edi + 0036d ff 75 fc push DWORD PTR _string$1$[ebp] + 00370 50 push eax + 00371 ff 75 08 push DWORD PTR _out$[ebp] + 00374 f7 c3 00 02 00 00 test ebx, 512 ; 00000200H - 00360 0f 84 79 02 00 + 0037a 0f 84 bf 02 00 00 je $LN8@streamout - 00366 e8 00 00 00 00 call _StreamOutWString - 0036b 8b d0 mov edx, eax - 0036d 89 55 e4 mov DWORD PTR _written$4$[ebp], edx + 00380 e8 00 00 00 00 call _StreamOutWString + 00385 8b d0 mov edx, eax + 00387 89 55 f8 mov DWORD PTR _written$4$[ebp], edx ; 805 : else - 00370 e9 74 02 00 00 jmp $LN269@streamout + 0038a e9 ba 02 00 00 jmp $LN267@streamout $LN49@streamout: ; 647 : len = (size_t)uLen; @@ -942,36 +964,36 @@ $LN49@streamout: ; 652 : case ('Z'): ; 653 : nt_string = va_arg(argptr, void*); - 00375 8b 4d 14 mov ecx, DWORD PTR _argptr$[ebp] - 00378 83 c1 04 add ecx, 4 - 0037b 89 4d 14 mov DWORD PTR _argptr$[ebp], ecx - 0037e 8b 49 fc mov ecx, DWORD PTR [ecx-4] + 0038f 8b 45 14 mov eax, DWORD PTR _argptr$[ebp] + 00392 83 c0 04 add eax, 4 + 00395 89 45 14 mov DWORD PTR _argptr$[ebp], eax + 00398 8b 48 fc mov ecx, DWORD PTR [eax-4] ; 654 : if (nt_string && (string = nt_string->Buffer)) - 00381 85 c9 test ecx, ecx - 00383 74 52 je SHORT $LN208@streamout - 00385 8b 41 04 mov eax, DWORD PTR [ecx+4] - 00388 89 45 f8 mov DWORD PTR _string$1$[ebp], eax - 0038b 85 c0 test eax, eax - 0038d 74 48 je SHORT $LN208@streamout + 0039b 85 c9 test ecx, ecx + 0039d 74 52 je SHORT $LN208@streamout + 0039f 8b 41 04 mov eax, DWORD PTR [ecx+4] + 003a2 89 45 fc mov DWORD PTR _string$1$[ebp], eax + 003a5 85 c0 test eax, eax + 003a7 74 48 je SHORT $LN208@streamout ; 655 : { ; 656 : len = nt_string->Length; - 0038f 0f b7 39 movzx edi, WORD PTR [ecx] + 003a9 0f b7 39 movzx edi, WORD PTR [ecx] ; 657 : if (flags & FLAG_WIDECHAR) len /= sizeof(wchar_t); - 00392 f7 c3 00 02 00 + 003ac f7 c3 00 02 00 00 test ebx, 512 ; 00000200H - 00398 0f 84 f9 fe ff - ff je $LN250@streamout - 0039e d1 ef shr edi, 1 + 003b2 0f 84 f3 fe ff + ff je $LN251@streamout + 003b8 d1 ef shr edi, 1 ; 658 : break; - 003a0 e9 f2 fe ff ff jmp $LN250@streamout + 003ba e9 ec fe ff ff jmp $LN251@streamout $LN46@streamout: ; 659 : } @@ -981,100 +1003,101 @@ $LN46@streamout: ; 663 : case ('S'): ; 664 : string = va_arg(argptr, void*); - 003a5 8b 4d 14 mov ecx, DWORD PTR _argptr$[ebp] - 003a8 83 c1 04 add ecx, 4 - 003ab 89 4d 14 mov DWORD PTR _argptr$[ebp], ecx - 003ae 8b 41 fc mov eax, DWORD PTR [ecx-4] - 003b1 89 45 f8 mov DWORD PTR _string$1$[ebp], eax + 003bf 8b 45 14 mov eax, DWORD PTR _argptr$[ebp] + 003c2 83 c0 04 add eax, 4 + 003c5 89 45 14 mov DWORD PTR _argptr$[ebp], eax + 003c8 8b 40 fc mov eax, DWORD PTR [eax-4] + 003cb 89 45 fc mov DWORD PTR _string$1$[ebp], eax ; 665 : if (!(flags & FLAG_SHORT)) flags |= FLAG_WIDECHAR; - 003b4 f7 c3 00 01 00 + 003ce f7 c3 00 01 00 00 test ebx, 256 ; 00000100H - 003ba 75 17 jne SHORT $case_string$275 - 003bc 81 cb 00 02 00 + 003d4 75 17 jne SHORT $case_string$272 + 003d6 81 cb 00 02 00 00 or ebx, 512 ; 00000200H ; 666 : goto case_string; - 003c2 eb 0f jmp SHORT $case_string$275 + 003dc eb 0f jmp SHORT $case_string$272 $LN44@streamout: ; 667 : ; 668 : case ('s'): ; 669 : string = va_arg(argptr, void*); - 003c4 8b 4d 14 mov ecx, DWORD PTR _argptr$[ebp] - 003c7 83 c1 04 add ecx, 4 - 003ca 89 4d 14 mov DWORD PTR _argptr$[ebp], ecx - 003cd 8b 41 fc mov eax, DWORD PTR [ecx-4] - 003d0 89 45 f8 mov DWORD PTR _string$1$[ebp], eax -$case_string$275: + 003de 8b 45 14 mov eax, DWORD PTR _argptr$[ebp] + 003e1 83 c0 04 add eax, 4 + 003e4 89 45 14 mov DWORD PTR _argptr$[ebp], eax + 003e7 8b 40 fc mov eax, DWORD PTR [eax-4] + 003ea 89 45 fc mov DWORD PTR _string$1$[ebp], eax +$case_string$272: ; 670 : ; 671 : case_string: ; 672 : if (!string) - 003d3 85 c0 test eax, eax - 003d5 75 0e jne SHORT $LN43@streamout + 003ed 85 c0 test eax, eax + 003ef 75 0e jne SHORT $LN43@streamout $LN208@streamout: ; 673 : { ; 674 : string = (char*)_nullstring; - 003d7 a1 00 00 00 00 mov eax, DWORD PTR ?_nullstring@?1??streamout@@9@9 + 003f1 a1 00 00 00 00 mov eax, DWORD PTR ?_nullstring@?1??streamout@@9@9 ; 675 : flags &= ~FLAG_WIDECHAR; - 003dc 81 e3 ff fd ff + 003f6 81 e3 ff fd ff ff and ebx, -513 ; fffffdffH - 003e2 89 45 f8 mov DWORD PTR _string$1$[ebp], eax + 003fc 89 45 fc mov DWORD PTR _string$1$[ebp], eax $LN43@streamout: ; 676 : } ; 677 : ; 678 : if (flags & FLAG_WIDECHAR) - 003e5 f7 c3 00 02 00 + 003ff f7 c3 00 02 00 00 test ebx, 512 ; 00000200H - 003eb 74 13 je SHORT $LN42@streamout + 00405 74 16 je SHORT $LN42@streamout ; 679 : len = wcsnlen((wchar_t*)string, (unsigned)precision); - 003ed 57 push edi - 003ee 50 push eax - 003ef e8 00 00 00 00 call _wcsnlen - 003f4 83 c4 08 add esp, 8 - 003f7 8b f8 mov edi, eax + 00407 8b 55 0c mov edx, DWORD PTR _precision$1$[ebp] + 0040a 52 push edx + 0040b 50 push eax + 0040c e8 00 00 00 00 call _wcsnlen + 00411 83 c4 08 add esp, 8 + 00414 8b f8 mov edi, eax ; 682 : precision = 0; - 003f9 33 c9 xor ecx, ecx + 00416 33 d2 xor edx, edx ; 683 : break; - 003fb e9 9a fe ff ff jmp $LN131@streamout + 00418 e9 91 fe ff ff jmp $LN131@streamout $LN42@streamout: ; 680 : else ; 681 : len = strlen((char*)string); - 00400 8b f8 mov edi, eax - 00402 8d 4f 01 lea ecx, DWORD PTR [edi+1] + 0041d 8b f8 mov edi, eax + 0041f 8d 4f 01 lea ecx, DWORD PTR [edi+1] $LL223@streamout: - 00405 8a 07 mov al, BYTE PTR [edi] - 00407 47 inc edi - 00408 84 c0 test al, al - 0040a 75 f9 jne SHORT $LL223@streamout - 0040c 2b f9 sub edi, ecx + 00422 8a 07 mov al, BYTE PTR [edi] + 00424 47 inc edi + 00425 84 c0 test al, al + 00427 75 f9 jne SHORT $LL223@streamout + 00429 2b f9 sub edi, ecx ; 682 : precision = 0; - 0040e 33 c9 xor ecx, ecx + 0042b 33 d2 xor edx, edx ; 683 : break; - 00410 e9 85 fe ff ff jmp $LN131@streamout + 0042d e9 7c fe ff ff jmp $LN131@streamout $LN40@streamout: ; 684 : @@ -1093,41 +1116,42 @@ $LN40@streamout: ; 697 : /* Use external function, one for kernel one for user mode */ ; 698 : format_float(chr, flags, precision, &string, &prefix, &argptr); - 00415 8d 45 14 lea eax, DWORD PTR _argptr$[ebp] - 00418 81 e3 ff fd ff + 00432 8b 55 0c mov edx, DWORD PTR _precision$1$[ebp] + 00435 8d 45 14 lea eax, DWORD PTR _argptr$[ebp] + 00438 50 push eax + 00439 8d 45 d0 lea eax, DWORD PTR _prefix$[ebp] + 0043c 81 e3 ff fd ff ff and ebx, -513 ; fffffdffH - 0041e 50 push eax - 0041f 8d 45 d0 lea eax, DWORD PTR _prefix$[ebp] - 00422 50 push eax - 00423 8d 45 e0 lea eax, DWORD PTR _string$[ebp] - 00426 50 push eax - 00427 57 push edi - 00428 53 push ebx - 00429 ff 75 f0 push DWORD PTR _chr$[ebp] - 0042c e8 00 00 00 00 call _format_float + 00442 50 push eax + 00443 8d 45 e4 lea eax, DWORD PTR _string$[ebp] + 00446 50 push eax + 00447 52 push edx + 00448 53 push ebx + 00449 ff 75 f0 push DWORD PTR _chr$[ebp] + 0044c e8 00 00 00 00 call _format_float ; 699 : len = strlen(string); - 00431 8b 45 e0 mov eax, DWORD PTR _string$[ebp] - 00434 83 c4 18 add esp, 24 ; 00000018H - 00437 8b f8 mov edi, eax - 00439 89 45 f8 mov DWORD PTR _string$1$[ebp], eax - 0043c 8d 4f 01 lea ecx, DWORD PTR [edi+1] - 0043f 90 npad 1 + 00451 8b 45 e4 mov eax, DWORD PTR _string$[ebp] + 00454 83 c4 18 add esp, 24 ; 00000018H + 00457 8b f8 mov edi, eax + 00459 89 45 fc mov DWORD PTR _string$1$[ebp], eax + 0045c 8d 4f 01 lea ecx, DWORD PTR [edi+1] + 0045f 90 npad 1 $LL224@streamout: - 00440 8a 07 mov al, BYTE PTR [edi] - 00442 47 inc edi - 00443 84 c0 test al, al - 00445 75 f9 jne SHORT $LL224@streamout + 00460 8a 07 mov al, BYTE PTR [edi] + 00462 47 inc edi + 00463 84 c0 test al, al + 00465 75 f9 jne SHORT $LL224@streamout ; 700 : precision = 0; ; 701 : break; - 00447 8b 45 d0 mov eax, DWORD PTR _prefix$[ebp] - 0044a 2b f9 sub edi, ecx - 0044c 33 c9 xor ecx, ecx - 0044e 89 45 ec mov DWORD PTR _prefix$1$[ebp], eax - 00451 e9 69 01 00 00 jmp $LN56@streamout + 00467 8b 45 d0 mov eax, DWORD PTR _prefix$[ebp] + 0046a 2b f9 sub edi, ecx + 0046c 33 d2 xor edx, edx + 0046e 89 45 ec mov DWORD PTR _prefix$1$[ebp], eax + 00471 e9 e9 00 00 00 jmp $LN56@streamout $LN39@streamout: ; 702 : @@ -1135,124 +1159,235 @@ $LN39@streamout: ; 704 : case ('i'): ; 705 : val64 = (__int64)va_arg_f(argptr, flags); - 00456 8b 4d 14 mov ecx, DWORD PTR _argptr$[ebp] - 00459 f7 c3 00 04 00 + 00476 f7 c3 00 04 00 00 test ebx, 1024 ; 00000400H - 0045f 74 0d je SHORT $LN125@streamout - 00461 8b 01 mov eax, DWORD PTR [ecx] - 00463 83 c1 08 add ecx, 8 - 00466 89 4d 14 mov DWORD PTR _argptr$[ebp], ecx - 00469 8b 51 fc mov edx, DWORD PTR [ecx-4] - 0046c eb 18 jmp SHORT $LN265@streamout + 0047c 74 11 je SHORT $LN125@streamout + 0047e 8b 4d 14 mov ecx, DWORD PTR _argptr$[ebp] + 00481 83 c1 08 add ecx, 8 + 00484 89 4d 14 mov DWORD PTR _argptr$[ebp], ecx + 00487 8b 41 f8 mov eax, DWORD PTR [ecx-8] + 0048a 8b 51 fc mov edx, DWORD PTR [ecx-4] + 0048d eb 24 jmp SHORT $LN264@streamout $LN125@streamout: - 0046e 83 c1 04 add ecx, 4 - 00471 89 4d 14 mov DWORD PTR _argptr$[ebp], ecx - 00474 f7 c3 00 01 00 + 0048f f7 c3 00 01 00 00 test ebx, 256 ; 00000100H - 0047a 74 06 je SHORT $LN123@streamout - 0047c 0f bf 41 fc movsx eax, WORD PTR [ecx-4] - 00480 eb 03 jmp SHORT $LN124@streamout + 00495 74 0f je SHORT $LN123@streamout + 00497 8b 4d 14 mov ecx, DWORD PTR _argptr$[ebp] + 0049a 83 c1 04 add ecx, 4 + 0049d 89 4d 14 mov DWORD PTR _argptr$[ebp], ecx + 004a0 0f bf 41 fc movsx eax, WORD PTR [ecx-4] + 004a4 eb 0c jmp SHORT $LN124@streamout $LN123@streamout: - 00482 8b 41 fc mov eax, DWORD PTR [ecx-4] + 004a6 8b 45 14 mov eax, DWORD PTR _argptr$[ebp] + 004a9 83 c0 04 add eax, 4 + 004ac 89 45 14 mov DWORD PTR _argptr$[ebp], eax + 004af 8b 40 fc mov eax, DWORD PTR [eax-4] $LN124@streamout: - 00485 99 cdq -$LN265@streamout: - 00486 89 55 e0 mov DWORD PTR _val64$2$[ebp], edx - 00489 89 45 e4 mov DWORD PTR _val64$1$[ebp], eax + 004b2 99 cdq +$LN264@streamout: + 004b3 89 55 e4 mov DWORD PTR _val64$2$[ebp], edx + 004b6 89 45 f8 mov DWORD PTR _val64$1$[ebp], eax ; 706 : ; 707 : if ((__int64)val64 < 0) - 0048c 85 d2 test edx, edx - 0048e 7f 19 jg SHORT $LN38@streamout - 00490 7c 04 jl SHORT $LN225@streamout - 00492 85 c0 test eax, eax - 00494 73 13 jae SHORT $LN38@streamout + 004b9 85 d2 test edx, edx + 004bb 0f 8f be 00 00 + 00 jg $LN38@streamout + 004c1 7c 08 jl SHORT $LN225@streamout + 004c3 85 c0 test eax, eax + 004c5 0f 83 b4 00 00 + 00 jae $LN38@streamout $LN225@streamout: ; 708 : { ; 709 : val64 = -(__int64)val64; - 00496 f7 d8 neg eax + 004cb f7 d8 neg eax ; 710 : prefix = ("-"); - 00498 c7 45 ec 00 00 - 00 00 mov DWORD PTR _prefix$1$[ebp], OFFSET $SG2972 - 0049f 83 d2 00 adc edx, 0 - 004a2 f7 da neg edx - 004a4 e9 97 00 00 00 jmp $LN272@streamout + 004cd c7 45 ec 00 00 + 00 00 mov DWORD PTR _prefix$1$[ebp], OFFSET $SG2975 + 004d4 89 45 f8 mov DWORD PTR _val64$1$[ebp], eax + 004d7 83 d2 00 adc edx, 0 + 004da f7 da neg edx + 004dc 89 55 e4 mov DWORD PTR _val64$2$[ebp], edx +$LN252@streamout: + 004df 8b 4d f8 mov ecx, DWORD PTR _val64$1$[ebp] +$case_number$273: + +; 748 : +; 749 : case_number: +; 750 : flags &= ~FLAG_WIDECHAR; +; 751 : if (precision < 0) precision = 1; + + 004e2 8b 7d 0c mov edi, DWORD PTR _precision$1$[ebp] + 004e5 81 e3 ff fd ff + ff and ebx, -513 ; fffffdffH + 004eb 89 5d cc mov DWORD PTR _flags$1$[ebp], ebx + 004ee 85 ff test edi, edi + 004f0 79 08 jns SHORT $LN141@streamout + 004f2 bf 01 00 00 00 mov edi, 1 + 004f7 89 7d 0c mov DWORD PTR _precision$1$[ebp], edi +$LN141@streamout: + +; 752 : +; 753 : /* Gather digits in reverse order */ +; 754 : while (val64) + + 004fa 8b c1 mov eax, ecx + 004fc 0b c2 or eax, edx + 004fe 74 47 je SHORT $LN23@streamout + 00500 8b 45 dc mov eax, DWORD PTR _base$1$[ebp] + 00503 8b 75 fc mov esi, DWORD PTR _string$1$[ebp] + 00506 8b 5d f8 mov ebx, DWORD PTR _val64$1$[ebp] + 00509 99 cdq + 0050a 8b c8 mov ecx, eax + 0050c 8b c2 mov eax, edx + 0050e 8b 55 e4 mov edx, DWORD PTR _val64$2$[ebp] + 00511 89 4d d0 mov DWORD PTR tv666[ebp], ecx + 00514 89 45 0c mov DWORD PTR tv665[ebp], eax +$LL24@streamout: + +; 755 : { +; 756 : *--string = digits[val64 % base]; + + 00517 50 push eax + 00518 51 push ecx + 00519 52 push edx + 0051a 53 push ebx + 0051b 4e dec esi + 0051c e8 00 00 00 00 call __aulldvrm + 00521 89 5d dc mov DWORD PTR tv599[ebp+4], ebx + +; 757 : val64 /= base; +; 758 : precision--; + + 00524 4f dec edi + 00525 8b d8 mov ebx, eax + 00527 8b 45 d4 mov eax, DWORD PTR _digits$1$[ebp] + 0052a 8a 04 01 mov al, BYTE PTR [ecx+eax] + 0052d 8b 4d d0 mov ecx, DWORD PTR tv666[ebp] + 00530 88 06 mov BYTE PTR [esi], al + 00532 8b c3 mov eax, ebx + 00534 0b c2 or eax, edx + 00536 8b 45 0c mov eax, DWORD PTR tv665[ebp] + 00539 75 dc jne SHORT $LL24@streamout + 0053b 8b 5d cc mov ebx, DWORD PTR _flags$1$[ebp] + 0053e 89 75 fc mov DWORD PTR _string$1$[ebp], esi + 00541 8b 75 10 mov esi, DWORD PTR _format$[ebp] + 00544 89 7d 0c mov DWORD PTR _precision$1$[ebp], edi +$LN23@streamout: + +; 759 : } +; 760 : +; 761 : len = strlen(string); + + 00547 8b 7d fc mov edi, DWORD PTR _string$1$[ebp] + 0054a 8d 4f 01 lea ecx, DWORD PTR [edi+1] + 0054d 8d 49 00 npad 3 +$LL226@streamout: + 00550 8a 07 mov al, BYTE PTR [edi] + 00552 47 inc edi + 00553 84 c0 test al, al + 00555 75 f9 jne SHORT $LL226@streamout + 00557 8b 55 0c mov edx, DWORD PTR _precision$1$[ebp] + 0055a 2b f9 sub edi, ecx + 0055c 8b 45 ec mov eax, DWORD PTR _prefix$1$[ebp] +$LN56@streamout: + +; 768 : } +; 769 : +; 770 : /* Calculate padding */ +; 771 : prefixlen = prefix ? strlen(prefix) : 0; + + 0055f 85 c0 test eax, eax + 00561 0f 84 47 fd ff + ff je $LN131@streamout + 00567 8b c8 mov ecx, eax + 00569 8d 41 01 lea eax, DWORD PTR [ecx+1] + 0056c 89 45 0c mov DWORD PTR tv729[ebp], eax + 0056f 90 npad 1 +$LL227@streamout: + 00570 8a 01 mov al, BYTE PTR [ecx] + 00572 41 inc ecx + 00573 84 c0 test al, al + 00575 75 f9 jne SHORT $LL227@streamout + 00577 2b 4d 0c sub ecx, DWORD PTR tv729[ebp] + 0057a e9 31 fd ff ff jmp $LN266@streamout $LN38@streamout: ; 711 : } ; 712 : else if (flags & FLAG_FORCE_SIGN) - 004a9 f6 c3 02 test bl, 2 - 004ac 74 0d je SHORT $LN36@streamout + 0057f f6 c3 02 test bl, 2 + 00582 74 0c je SHORT $LN36@streamout ; 713 : prefix = ("+"); - 004ae b9 00 00 00 00 mov ecx, OFFSET $SG2975 - 004b3 89 4d ec mov DWORD PTR _prefix$1$[ebp], ecx - 004b6 e9 8b 00 00 00 jmp $case_number$276 + 00584 c7 45 ec 00 00 + 00 00 mov DWORD PTR _prefix$1$[ebp], OFFSET $SG2978 + 0058b e9 4f ff ff ff jmp $LN252@streamout $LN36@streamout: ; 714 : else if (flags & FLAG_FORCE_SIGNSP) - 004bb f6 c3 04 test bl, 4 - 004be 0f 84 82 00 00 - 00 je $case_number$276 + 00590 f6 c3 04 test bl, 4 + 00593 0f 84 46 ff ff + ff je $LN252@streamout ; 715 : prefix = (" "); - 004c4 b9 00 00 00 00 mov ecx, OFFSET $SG2978 - 004c9 89 4d ec mov DWORD PTR _prefix$1$[ebp], ecx + 00599 b8 00 00 00 00 mov eax, OFFSET $SG2981 + 0059e 89 45 ec mov DWORD PTR _prefix$1$[ebp], eax ; 716 : ; 717 : goto case_number; - 004cc eb 78 jmp SHORT $case_number$276 + 005a1 e9 39 ff ff ff jmp $LN252@streamout $LN33@streamout: ; 718 : ; 719 : case ('o'): ; 720 : base = 8; - 004ce c7 45 dc 08 00 + 005a6 c7 45 dc 08 00 00 00 mov DWORD PTR _base$1$[ebp], 8 ; 721 : if (flags & FLAG_SPECIAL) - 004d5 f6 c3 10 test bl, 16 ; 00000010H - 004d8 74 35 je SHORT $case_unsigned$277 + 005ad f6 c3 10 test bl, 16 ; 00000010H + 005b0 74 3d je SHORT $case_unsigned$274 ; 722 : { ; 723 : prefix = ("0"); - - 004da c7 45 ec 00 00 - 00 00 mov DWORD PTR _prefix$1$[ebp], OFFSET $SG2982 - ; 724 : if (precision > 0) precision--; - 004e1 85 ff test edi, edi - 004e3 7e 2a jle SHORT $case_unsigned$277 - 004e5 4f dec edi + 005b2 8b 55 0c mov edx, DWORD PTR _precision$1$[ebp] + 005b5 c7 45 ec 00 00 + 00 00 mov DWORD PTR _prefix$1$[ebp], OFFSET $SG2985 + 005bc 85 d2 test edx, edx + 005be 7e 2f jle SHORT $case_unsigned$274 + 005c0 4a dec edx + 005c1 89 55 0c mov DWORD PTR _precision$1$[ebp], edx ; 725 : } ; 726 : goto case_unsigned; - 004e6 eb 27 jmp SHORT $case_unsigned$277 + 005c4 eb 29 jmp SHORT $case_unsigned$274 $LN30@streamout: ; 727 : ; 728 : case ('p'): ; 729 : precision = 2 * sizeof(void*); - 004e8 bf 08 00 00 00 mov edi, 8 + 005c6 c7 45 0c 08 00 + 00 00 mov DWORD PTR _precision$1$[ebp], 8 ; 730 : flags &= ~FLAG_PAD_ZERO; - 004ed 83 e3 f7 and ebx, -9 ; fffffff7H + 005cd 83 e3 f7 and ebx, -9 ; fffffff7H $LN29@streamout: ; 731 : flags |= FLAG_INTPTR; @@ -1261,11 +1396,11 @@ $LN29@streamout: ; 734 : case ('X'): ; 735 : digits = digits_u; - 004f0 b8 00 00 00 00 mov eax, OFFSET ?digits_u@?1??streamout@@9@9 - 004f5 89 45 d4 mov DWORD PTR _digits$1$[ebp], eax - 004f8 eb 03 jmp SHORT $LN28@streamout + 005d0 b8 00 00 00 00 mov eax, OFFSET ?digits_u@?1??streamout@@9@9 + 005d5 89 45 d4 mov DWORD PTR _digits$1$[ebp], eax + 005d8 eb 03 jmp SHORT $LN28@streamout $LN253@streamout: - 004fa 8b 45 d4 mov eax, DWORD PTR _digits$1$[ebp] + 005da 8b 45 d4 mov eax, DWORD PTR _digits$1$[ebp] $LN28@streamout: ; 736 : /* Fall through */ @@ -1273,20 +1408,20 @@ $LN28@streamout: ; 738 : case ('x'): ; 739 : base = 16; - 004fd c7 45 dc 10 00 + 005dd c7 45 dc 10 00 00 00 mov DWORD PTR _base$1$[ebp], 16 ; 00000010H ; 740 : if (flags & FLAG_SPECIAL) - 00504 f6 c3 10 test bl, 16 ; 00000010H - 00507 74 06 je SHORT $case_unsigned$277 + 005e4 f6 c3 10 test bl, 16 ; 00000010H + 005e7 74 06 je SHORT $case_unsigned$274 ; 741 : { ; 742 : prefix = &digits[16]; - 00509 8d 48 10 lea ecx, DWORD PTR [eax+16] - 0050c 89 4d ec mov DWORD PTR _prefix$1$[ebp], ecx -$case_unsigned$277: + 005e9 83 c0 10 add eax, 16 ; 00000010H + 005ec 89 45 ec mov DWORD PTR _prefix$1$[ebp], eax +$case_unsigned$274: ; 743 : } ; 744 : @@ -1294,150 +1429,54 @@ $case_unsigned$277: ; 746 : case_unsigned: ; 747 : val64 = va_arg_fu(argptr, flags); - 0050f 8b 4d 14 mov ecx, DWORD PTR _argptr$[ebp] - 00512 f7 c3 00 04 00 + 005ef 8b 45 14 mov eax, DWORD PTR _argptr$[ebp] + 005f2 f7 c3 00 04 00 00 test ebx, 1024 ; 00000400H - 00518 74 0d je SHORT $LN129@streamout - 0051a 8b 01 mov eax, DWORD PTR [ecx] - 0051c 83 c1 08 add ecx, 8 - 0051f 89 4d 14 mov DWORD PTR _argptr$[ebp], ecx - 00522 8b 51 fc mov edx, DWORD PTR [ecx-4] - 00525 eb 19 jmp SHORT $LN272@streamout + 005f8 74 16 je SHORT $LN129@streamout + 005fa 8b 08 mov ecx, DWORD PTR [eax] + 005fc 83 c0 08 add eax, 8 + 005ff 89 45 14 mov DWORD PTR _argptr$[ebp], eax + 00602 89 4d f8 mov DWORD PTR _val64$1$[ebp], ecx + 00605 8b 50 fc mov edx, DWORD PTR [eax-4] + 00608 89 55 e4 mov DWORD PTR _val64$2$[ebp], edx + 0060b e9 d2 fe ff ff jmp $case_number$273 $LN129@streamout: - 00527 83 c1 04 add ecx, 4 - 0052a 89 4d 14 mov DWORD PTR _argptr$[ebp], ecx - 0052d f7 c3 00 01 00 + 00610 83 c0 04 add eax, 4 + 00613 89 45 14 mov DWORD PTR _argptr$[ebp], eax + 00616 f7 c3 00 01 00 00 test ebx, 256 ; 00000100H - 00533 74 06 je SHORT $LN127@streamout - 00535 0f b7 41 fc movzx eax, WORD PTR [ecx-4] - 00539 eb 03 jmp SHORT $LN267@streamout + 0061c 74 11 je SHORT $LN127@streamout + 0061e 0f b7 48 fc movzx ecx, WORD PTR [eax-4] + 00622 33 d2 xor edx, edx + 00624 89 4d f8 mov DWORD PTR _val64$1$[ebp], ecx + 00627 89 55 e4 mov DWORD PTR _val64$2$[ebp], edx + 0062a e9 b3 fe ff ff jmp $case_number$273 $LN127@streamout: - 0053b 8b 41 fc mov eax, DWORD PTR [ecx-4] -$LN267@streamout: - 0053e 33 d2 xor edx, edx -$LN272@streamout: - 00540 89 45 e4 mov DWORD PTR _val64$1$[ebp], eax - 00543 89 55 e0 mov DWORD PTR _val64$2$[ebp], edx -$case_number$276: - -; 748 : -; 749 : case_number: -; 750 : flags &= ~FLAG_WIDECHAR; - - 00546 81 e3 ff fd ff - ff and ebx, -513 ; fffffdffH - -; 751 : if (precision < 0) precision = 1; - - 0054c b9 01 00 00 00 mov ecx, 1 - 00551 85 ff test edi, edi - 00553 89 5d cc mov DWORD PTR _flags$1$[ebp], ebx - 00556 0f 48 f9 cmovs edi, ecx - -; 752 : -; 753 : /* Gather digits in reverse order */ -; 754 : while (val64) - - 00559 0b c2 or eax, edx - 0055b 89 7d 0c mov DWORD PTR _precision$2$[ebp], edi - 0055e 74 47 je SHORT $LN23@streamout - 00560 8b 45 dc mov eax, DWORD PTR _base$1$[ebp] - 00563 8b 75 f8 mov esi, DWORD PTR _string$1$[ebp] - 00566 8b 5d e4 mov ebx, DWORD PTR _val64$1$[ebp] - 00569 99 cdq - 0056a 8b c8 mov ecx, eax - 0056c 8b c2 mov eax, edx - 0056e 8b 55 e0 mov edx, DWORD PTR _val64$2$[ebp] - 00571 89 4d d0 mov DWORD PTR tv658[ebp], ecx - 00574 89 45 0c mov DWORD PTR tv657[ebp], eax -$LL24@streamout: - -; 755 : { -; 756 : *--string = digits[val64 % base]; - - 00577 50 push eax - 00578 51 push ecx - 00579 52 push edx - 0057a 53 push ebx - 0057b 4e dec esi - 0057c e8 00 00 00 00 call __aulldvrm - 00581 89 5d dc mov DWORD PTR tv599[ebp+4], ebx - -; 757 : val64 /= base; -; 758 : precision--; - - 00584 4f dec edi - 00585 8b d8 mov ebx, eax - 00587 8b 45 d4 mov eax, DWORD PTR _digits$1$[ebp] - 0058a 8a 04 01 mov al, BYTE PTR [ecx+eax] - 0058d 8b 4d d0 mov ecx, DWORD PTR tv658[ebp] - 00590 88 06 mov BYTE PTR [esi], al - 00592 8b c3 mov eax, ebx - 00594 0b c2 or eax, edx - 00596 8b 45 0c mov eax, DWORD PTR tv657[ebp] - 00599 75 dc jne SHORT $LL24@streamout - 0059b 8b 5d cc mov ebx, DWORD PTR _flags$1$[ebp] - 0059e 89 75 f8 mov DWORD PTR _string$1$[ebp], esi - 005a1 8b 75 10 mov esi, DWORD PTR _format$[ebp] - 005a4 89 7d 0c mov DWORD PTR _precision$2$[ebp], edi -$LN23@streamout: - -; 759 : } -; 760 : -; 761 : len = strlen(string); - - 005a7 8b 7d f8 mov edi, DWORD PTR _string$1$[ebp] - 005aa 8d 4f 01 lea ecx, DWORD PTR [edi+1] - 005ad 8d 49 00 npad 3 -$LL226@streamout: - 005b0 8a 07 mov al, BYTE PTR [edi] - 005b2 47 inc edi - 005b3 84 c0 test al, al - 005b5 75 f9 jne SHORT $LL226@streamout - 005b7 8b 45 ec mov eax, DWORD PTR _prefix$1$[ebp] - 005ba 2b f9 sub edi, ecx - 005bc 8b 4d 0c mov ecx, DWORD PTR _precision$2$[ebp] -$LN56@streamout: - -; 768 : } -; 769 : -; 770 : /* Calculate padding */ -; 771 : prefixlen = prefix ? strlen(prefix) : 0; - - 005bf 85 c0 test eax, eax - 005c1 0f 84 d3 fc ff - ff je $LN131@streamout - 005c7 8b d0 mov edx, eax - 005c9 8d 42 01 lea eax, DWORD PTR [edx+1] - 005cc 89 45 0c mov DWORD PTR tv723[ebp], eax - 005cf 90 npad 1 -$LL227@streamout: - 005d0 8a 02 mov al, BYTE PTR [edx] - 005d2 42 inc edx - 005d3 84 c0 test al, al - 005d5 75 f9 jne SHORT $LL227@streamout - 005d7 2b 55 0c sub edx, DWORD PTR tv723[ebp] - 005da e9 bd fc ff ff jmp $LN268@streamout + 0062f 8b 48 fc mov ecx, DWORD PTR [eax-4] + 00632 33 d2 xor edx, edx + 00634 89 4d f8 mov DWORD PTR _val64$1$[ebp], ecx + 00637 89 55 e4 mov DWORD PTR _val64$2$[ebp], edx + 0063a e9 a3 fe ff ff jmp $case_number$273 $LN8@streamout: ; 806 : written = StreamOutString(out, &cnt, (char*)string, len); - 005df e8 00 00 00 00 call _StreamOutString - 005e4 8b d0 mov edx, eax - 005e6 89 45 e4 mov DWORD PTR _written$4$[ebp], eax -$LN269@streamout: - 005e9 83 c4 10 add esp, 16 ; 00000010H + 0063f e8 00 00 00 00 call _StreamOutString + 00644 8b d0 mov edx, eax + 00646 89 45 f8 mov DWORD PTR _written$4$[ebp], eax +$LN267@streamout: + 00649 83 c4 10 add esp, 16 ; 00000010H ; 807 : if (written == -1) return -1; - 005ec 83 fa ff cmp edx, -1 - 005ef 0f 84 02 01 00 + 0064c 83 fa ff cmp edx, -1 + 0064f 0f 84 ff 00 00 00 je $LN152@streamout ; 808 : written_all += written; - 005f5 8b 7d fc mov edi, DWORD PTR _written_all$1$[ebp] - 005f8 03 fa add edi, edx + 00655 8b 7d f4 mov edi, DWORD PTR _written_all$1$[ebp] + 00658 03 fa add edi, edx ; 809 : ; 810 : #if 0 && SUPPORT_FLOAT @@ -1453,49 +1492,49 @@ $LN269@streamout: ; 820 : /* Optional right padding */ ; 821 : if (flags & FLAG_ALIGN_LEFT) - 005fa 83 7d cc 00 cmp DWORD PTR tv725[ebp], 0 - 005fe 89 7d fc mov DWORD PTR _written_all$1$[ebp], edi - 00601 0f 84 d7 00 00 + 0065a 83 7d cc 00 cmp DWORD PTR tv731[ebp], 0 + 0065e 89 7d f4 mov DWORD PTR _written_all$1$[ebp], edi + 00661 0f 84 d7 00 00 00 je $LN163@streamout ; 822 : { ; 823 : while (padding-- > 0) - 00607 8b 5d f4 mov ebx, DWORD PTR _padding$2$[ebp] - 0060a 85 db test ebx, ebx - 0060c 0f 8e cc 00 00 + 00667 8b 5d e0 mov ebx, DWORD PTR _padding$2$[ebp] + 0066a 85 db test ebx, ebx + 0066c 0f 8e cc 00 00 00 jle $LN163@streamout $LL4@streamout: ; 824 : { ; 825 : if ((written = StreamOutCharacter(out, &cnt, (' '))) == 0) return -1; - 00612 6a 20 push 32 ; 00000020H - 00614 8d 45 e8 lea eax, DWORD PTR _cnt$[ebp] - 00617 4b dec ebx - 00618 50 push eax - 00619 ff 75 08 push DWORD PTR _out$[ebp] - 0061c e8 00 00 00 00 call _StreamOutCharacter - 00621 8b d0 mov edx, eax - 00623 83 c4 0c add esp, 12 ; 0000000cH - 00626 89 55 e4 mov DWORD PTR _written$4$[ebp], edx - 00629 85 d2 test edx, edx - 0062b 0f 84 c6 00 00 + 00672 6a 20 push 32 ; 00000020H + 00674 8d 45 e8 lea eax, DWORD PTR _cnt$[ebp] + 00677 4b dec ebx + 00678 50 push eax + 00679 ff 75 08 push DWORD PTR _out$[ebp] + 0067c e8 00 00 00 00 call _StreamOutCharacter + 00681 8b d0 mov edx, eax + 00683 83 c4 0c add esp, 12 ; 0000000cH + 00686 89 55 f8 mov DWORD PTR _written$4$[ebp], edx + 00689 85 d2 test edx, edx + 0068b 0f 84 c3 00 00 00 je $LN152@streamout ; 826 : written_all += written; - 00631 03 fa add edi, edx - 00633 89 7d fc mov DWORD PTR _written_all$1$[ebp], edi - 00636 85 db test ebx, ebx - 00638 7f d8 jg SHORT $LL4@streamout + 00691 03 fa add edi, edx + 00693 89 7d f4 mov DWORD PTR _written_all$1$[ebp], edi + 00696 85 db test ebx, ebx + 00698 7f d8 jg SHORT $LL4@streamout ; 827 : } ; 828 : } ; 829 : ; 830 : } - 0063a e9 9f 00 00 00 jmp $LN163@streamout + 0069a e9 9f 00 00 00 jmp $LN163@streamout $LN22@streamout: ; 762 : break; @@ -1503,21 +1542,22 @@ $LN22@streamout: ; 764 : default: ; 765 : /* Treat anything else as a new character */ ; 766 : format--; + + 0069f 4e dec esi + ; 767 : continue; - 0063f 8b 7d fc mov edi, DWORD PTR _written_all$1$[ebp] - 00642 4e dec esi - 00643 e9 96 00 00 00 jmp $LN163@streamout + 006a0 e9 99 00 00 00 jmp $LN163@streamout $LN116@streamout: ; 472 : { ; 473 : /* Sanity */ ; 474 : if (IsUTF8(chr)) - 00648 8a c8 mov cl, al - 0064a 80 e1 c0 and cl, 192 ; 000000c0H - 0064d 80 f9 80 cmp cl, 128 ; 00000080H - 00650 75 6d jne SHORT $LN115@streamout + 006a5 8a c8 mov cl, al + 006a7 80 e1 c0 and cl, 192 ; 000000c0H + 006aa 80 f9 80 cmp cl, 128 ; 00000080H + 006ad 75 70 jne SHORT $LN115@streamout ; 475 : { ; 476 : /* Build UTF-8 */ @@ -1527,17 +1567,18 @@ $LN116@streamout: ; 480 : /* Iterate */ ; 481 : while (*format && IsUTF8(*format)) - 00652 8a 16 mov dl, BYTE PTR [esi] - 00654 33 db xor ebx, ebx - 00656 0f be c8 movsx ecx, al - 00659 84 d2 test dl, dl - 0065b 74 1b je SHORT $LN249@streamout - 0065d 8d 49 00 npad 3 + 006af 8a 16 mov dl, BYTE PTR [esi] + 006b1 33 db xor ebx, ebx + 006b3 0f be c8 movsx ecx, al + 006b6 84 d2 test dl, dl + 006b8 74 1e je SHORT $LN249@streamout + 006ba 8d 9b 00 00 00 + 00 npad 6 $LL114@streamout: - 00660 8a c2 mov al, dl - 00662 24 c0 and al, 192 ; 000000c0H - 00664 3c 80 cmp al, 128 ; 00000080H - 00666 75 10 jne SHORT $LN249@streamout + 006c0 8a c2 mov al, dl + 006c2 24 c0 and al, 192 ; 000000c0H + 006c4 3c 80 cmp al, 128 ; 00000080H + 006c6 75 10 jne SHORT $LN249@streamout ; 482 : { ; 483 : /* Move */ @@ -1550,14 +1591,14 @@ $LL114@streamout: ; 490 : Size++; ; 491 : format++; - 00668 46 inc esi - 00669 c1 e1 06 shl ecx, 6 - 0066c 0f b6 c2 movzx eax, dl - 0066f 43 inc ebx - 00670 03 c8 add ecx, eax - 00672 8a 16 mov dl, BYTE PTR [esi] - 00674 84 d2 test dl, dl - 00676 75 e8 jne SHORT $LL114@streamout + 006c8 46 inc esi + 006c9 c1 e1 06 shl ecx, 6 + 006cc 0f b6 c2 movzx eax, dl + 006cf 43 inc ebx + 006d0 03 c8 add ecx, eax + 006d2 8a 16 mov dl, BYTE PTR [esi] + 006d4 84 d2 test dl, dl + 006d6 75 e8 jne SHORT $LL114@streamout $LN249@streamout: ; 492 : } @@ -1565,90 +1606,90 @@ $LN249@streamout: ; 494 : /* Move */ ; 495 : uChar <<= 6; - 00678 c1 e1 06 shl ecx, 6 + 006d8 c1 e1 06 shl ecx, 6 ; 496 : ; 497 : /* Add the last byte */ ; 498 : if (Size == 1) - 0067b 83 fb 01 cmp ebx, 1 - 0067e 75 08 jne SHORT $LN112@streamout + 006db 83 fb 01 cmp ebx, 1 + 006de 75 08 jne SHORT $LN112@streamout ; 499 : uChar |= (((unsigned char)*format) & 0x1F); - 00680 0f b6 06 movzx eax, BYTE PTR [esi] - 00683 83 e0 1f and eax, 31 ; 0000001fH - 00686 eb 18 jmp SHORT $LN270@streamout + 006e0 0f b6 06 movzx eax, BYTE PTR [esi] + 006e3 83 e0 1f and eax, 31 ; 0000001fH + 006e6 eb 18 jmp SHORT $LN268@streamout $LN112@streamout: ; 500 : else if (Size == 2) - 00688 83 fb 02 cmp ebx, 2 - 0068b 75 08 jne SHORT $LN110@streamout + 006e8 83 fb 02 cmp ebx, 2 + 006eb 75 08 jne SHORT $LN110@streamout ; 501 : uChar |= (((unsigned char)*format) & 0xF); - 0068d 0f b6 06 movzx eax, BYTE PTR [esi] - 00690 83 e0 0f and eax, 15 ; 0000000fH - 00693 eb 0b jmp SHORT $LN270@streamout + 006ed 0f b6 06 movzx eax, BYTE PTR [esi] + 006f0 83 e0 0f and eax, 15 ; 0000000fH + 006f3 eb 0b jmp SHORT $LN268@streamout $LN110@streamout: ; 502 : else if (Size == 3) - 00695 83 fb 03 cmp ebx, 3 - 00698 75 08 jne SHORT $LN108@streamout + 006f5 83 fb 03 cmp ebx, 3 + 006f8 75 08 jne SHORT $LN108@streamout ; 503 : uChar |= (((unsigned char)*format) & 0x7); - 0069a 0f b6 06 movzx eax, BYTE PTR [esi] - 0069d 83 e0 07 and eax, 7 -$LN270@streamout: - 006a0 0b c8 or ecx, eax + 006fa 0f b6 06 movzx eax, BYTE PTR [esi] + 006fd 83 e0 07 and eax, 7 +$LN268@streamout: + 00700 0b c8 or ecx, eax $LN108@streamout: ; 504 : ; 505 : /* Write the character to the stream */ ; 506 : if ((written = StreamOutCharacter(out, &cnt, uChar)) == 0) - 006a2 8b 5d 08 mov ebx, DWORD PTR _out$[ebp] - 006a5 8d 45 e8 lea eax, DWORD PTR _cnt$[ebp] - 006a8 51 push ecx - 006a9 50 push eax - 006aa 53 push ebx - 006ab e8 00 00 00 00 call _StreamOutCharacter - 006b0 8b d0 mov edx, eax - 006b2 83 c4 0c add esp, 12 ; 0000000cH - 006b5 89 55 e4 mov DWORD PTR _written$4$[ebp], edx - 006b8 85 d2 test edx, edx - 006ba 74 3b je SHORT $LN152@streamout + 00702 8b 5d 08 mov ebx, DWORD PTR _out$[ebp] + 00705 8d 45 e8 lea eax, DWORD PTR _cnt$[ebp] + 00708 51 push ecx + 00709 50 push eax + 0070a 53 push ebx + 0070b e8 00 00 00 00 call _StreamOutCharacter + 00710 8b d0 mov edx, eax + 00712 83 c4 0c add esp, 12 ; 0000000cH + 00715 89 55 f8 mov DWORD PTR _written$4$[ebp], edx + 00718 85 d2 test edx, edx + 0071a 74 38 je SHORT $LN152@streamout ; 508 : ; 509 : /* Skip */ ; 510 : format++; - 006bc 46 inc esi + 0071c 46 inc esi ; 511 : } ; 512 : else - 006bd eb 1a jmp SHORT $LN105@streamout + 0071d eb 1a jmp SHORT $LN105@streamout $LN115@streamout: ; 513 : { ; 514 : /* Write the character to the stream */ ; 515 : if ((written = StreamOutCharacter(out, &cnt, (uint32_t)chr)) == 0) - 006bf 0f be c0 movsx eax, al - 006c2 50 push eax - 006c3 8d 45 e8 lea eax, DWORD PTR _cnt$[ebp] - 006c6 50 push eax - 006c7 53 push ebx - 006c8 e8 00 00 00 00 call _StreamOutCharacter - 006cd 8b d0 mov edx, eax - 006cf 89 45 e4 mov DWORD PTR _written$4$[ebp], eax - 006d2 83 c4 0c add esp, 12 ; 0000000cH - 006d5 85 d2 test edx, edx - 006d7 74 1e je SHORT $LN152@streamout + 0071f 0f be c0 movsx eax, al + 00722 50 push eax + 00723 8d 45 e8 lea eax, DWORD PTR _cnt$[ebp] + 00726 50 push eax + 00727 53 push ebx + 00728 e8 00 00 00 00 call _StreamOutCharacter + 0072d 8b d0 mov edx, eax + 0072f 89 45 f8 mov DWORD PTR _written$4$[ebp], eax + 00732 83 c4 0c add esp, 12 ; 0000000cH + 00735 85 d2 test edx, edx + 00737 74 1b je SHORT $LN152@streamout $LN105@streamout: ; 516 : return -1; @@ -1657,151 +1698,162 @@ $LN105@streamout: ; 519 : /* Done */ ; 520 : written_all += written; - 006d9 03 fa add edi, edx - 006db 89 7d fc mov DWORD PTR _written_all$1$[ebp], edi + 00739 03 fa add edi, edx + 0073b 89 7d f4 mov DWORD PTR _written_all$1$[ebp], edi $LN163@streamout: ; 458 : ; 459 : /* Iterate String */ ; 460 : while (written >= 0) - 006de 85 d2 test edx, edx - 006e0 0f 89 3d f9 ff - ff jns $LN271@streamout + 0073e 85 d2 test edx, edx + 00740 0f 89 dd f8 ff + ff jns $LN269@streamout $LN119@streamout: ; 831 : ; 832 : if (written == -1) return -1; - 006e6 83 c8 ff or eax, -1 - 006e9 3b d0 cmp edx, eax - 006eb 0f 44 f8 cmove edi, eax - 006ee 8b c7 mov eax, edi - 006f0 5f pop edi - 006f1 5e pop esi - 006f2 5b pop ebx + 00746 83 fa ff cmp edx, -1 + 00749 74 09 je SHORT $LN152@streamout ; 833 : ; 834 : return written_all; + + 0074b 8b c7 mov eax, edi + 0074d 5f pop edi + 0074e 5e pop esi + 0074f 5b pop ebx + ; 835 : } - 006f3 8b e5 mov esp, ebp - 006f5 5d pop ebp - 006f6 c3 ret 0 + 00750 8b e5 mov esp, ebp + 00752 5d pop ebp + 00753 c3 ret 0 $LN152@streamout: - 006f7 5f pop edi - 006f8 5e pop esi + 00754 5f pop edi + 00755 5e pop esi ; 507 : return -1; - 006f9 83 c8 ff or eax, -1 - 006fc 5b pop ebx + 00756 83 c8 ff or eax, -1 + 00759 5b pop ebx -; 833 : -; 834 : return written_all; ; 835 : } - 006fd 8b e5 mov esp, ebp - 006ff 5d pop ebp - 00700 c3 ret 0 - 00701 8d 49 00 npad 3 -$LN274@streamout: - 00704 00 00 00 00 DD $LN40@streamout - 00708 00 00 00 00 DD $LN50@streamout - 0070c 00 00 00 00 DD $LN46@streamout - 00710 00 00 00 00 DD $LN29@streamout - 00714 00 00 00 00 DD $LN49@streamout - 00718 00 00 00 00 DD $LN39@streamout - 0071c 00 00 00 00 DD $LN55@streamout - 00720 00 00 00 00 DD $LN33@streamout - 00724 00 00 00 00 DD $LN30@streamout - 00728 00 00 00 00 DD $LN44@streamout - 0072c 00 00 00 00 DD $case_unsigned$277 - 00730 00 00 00 00 DD $LN253@streamout - 00734 00 00 00 00 DD $LN22@streamout + 0075a 8b e5 mov esp, ebp + 0075c 5d pop ebp + 0075d c3 ret 0 + 0075e 8b ff npad 2 +$LN271@streamout: + 00760 00 00 00 00 DD $LN40@streamout + 00764 00 00 00 00 DD $LN50@streamout + 00768 00 00 00 00 DD $LN46@streamout + 0076c 00 00 00 00 DD $LN29@streamout + 00770 00 00 00 00 DD $LN49@streamout + 00774 00 00 00 00 DD $LN39@streamout + 00778 00 00 00 00 DD $LN55@streamout + 0077c 00 00 00 00 DD $LN33@streamout + 00780 00 00 00 00 DD $LN30@streamout + 00784 00 00 00 00 DD $LN44@streamout + 00788 00 00 00 00 DD $case_unsigned$274 + 0078c 00 00 00 00 DD $LN253@streamout + 00790 00 00 00 00 DD $LN22@streamout $LN222@streamout: - 00738 00 DB 0 - 00739 0c DB 12 ; 0000000cH - 0073a 01 DB 1 - 0073b 0c DB 12 ; 0000000cH - 0073c 00 DB 0 - 0073d 0c DB 12 ; 0000000cH - 0073e 00 DB 0 - 0073f 0c DB 12 ; 0000000cH - 00740 0c DB 12 ; 0000000cH - 00741 0c DB 12 ; 0000000cH - 00742 0c DB 12 ; 0000000cH - 00743 0c DB 12 ; 0000000cH - 00744 0c DB 12 ; 0000000cH - 00745 0c DB 12 ; 0000000cH - 00746 0c DB 12 ; 0000000cH - 00747 0c DB 12 ; 0000000cH - 00748 0c DB 12 ; 0000000cH - 00749 0c DB 12 ; 0000000cH - 0074a 02 DB 2 - 0074b 0c DB 12 ; 0000000cH - 0074c 0c DB 12 ; 0000000cH - 0074d 0c DB 12 ; 0000000cH - 0074e 0c DB 12 ; 0000000cH - 0074f 03 DB 3 - 00750 0c DB 12 ; 0000000cH - 00751 04 DB 4 - 00752 0c DB 12 ; 0000000cH - 00753 0c DB 12 ; 0000000cH - 00754 0c DB 12 ; 0000000cH - 00755 0c DB 12 ; 0000000cH - 00756 0c DB 12 ; 0000000cH - 00757 0c DB 12 ; 0000000cH - 00758 00 DB 0 - 00759 0c DB 12 ; 0000000cH - 0075a 01 DB 1 - 0075b 05 DB 5 - 0075c 00 DB 0 - 0075d 00 DB 0 - 0075e 00 DB 0 - 0075f 0c DB 12 ; 0000000cH - 00760 05 DB 5 - 00761 0c DB 12 ; 0000000cH - 00762 0c DB 12 ; 0000000cH - 00763 0c DB 12 ; 0000000cH - 00764 0c DB 12 ; 0000000cH - 00765 06 DB 6 - 00766 07 DB 7 - 00767 08 DB 8 - 00768 0c DB 12 ; 0000000cH - 00769 0c DB 12 ; 0000000cH - 0076a 09 DB 9 - 0076b 0c DB 12 ; 0000000cH - 0076c 0a DB 10 ; 0000000aH - 0076d 0c DB 12 ; 0000000cH - 0076e 0c DB 12 ; 0000000cH - 0076f 0b DB 11 ; 0000000bH + 00794 00 DB 0 + 00795 0c DB 12 ; 0000000cH + 00796 01 DB 1 + 00797 0c DB 12 ; 0000000cH + 00798 00 DB 0 + 00799 0c DB 12 ; 0000000cH + 0079a 00 DB 0 + 0079b 0c DB 12 ; 0000000cH + 0079c 0c DB 12 ; 0000000cH + 0079d 0c DB 12 ; 0000000cH + 0079e 0c DB 12 ; 0000000cH + 0079f 0c DB 12 ; 0000000cH + 007a0 0c DB 12 ; 0000000cH + 007a1 0c DB 12 ; 0000000cH + 007a2 0c DB 12 ; 0000000cH + 007a3 0c DB 12 ; 0000000cH + 007a4 0c DB 12 ; 0000000cH + 007a5 0c DB 12 ; 0000000cH + 007a6 02 DB 2 + 007a7 0c DB 12 ; 0000000cH + 007a8 0c DB 12 ; 0000000cH + 007a9 0c DB 12 ; 0000000cH + 007aa 0c DB 12 ; 0000000cH + 007ab 03 DB 3 + 007ac 0c DB 12 ; 0000000cH + 007ad 04 DB 4 + 007ae 0c DB 12 ; 0000000cH + 007af 0c DB 12 ; 0000000cH + 007b0 0c DB 12 ; 0000000cH + 007b1 0c DB 12 ; 0000000cH + 007b2 0c DB 12 ; 0000000cH + 007b3 0c DB 12 ; 0000000cH + 007b4 00 DB 0 + 007b5 0c DB 12 ; 0000000cH + 007b6 01 DB 1 + 007b7 05 DB 5 + 007b8 00 DB 0 + 007b9 00 DB 0 + 007ba 00 DB 0 + 007bb 0c DB 12 ; 0000000cH + 007bc 05 DB 5 + 007bd 0c DB 12 ; 0000000cH + 007be 0c DB 12 ; 0000000cH + 007bf 0c DB 12 ; 0000000cH + 007c0 0c DB 12 ; 0000000cH + 007c1 06 DB 6 + 007c2 07 DB 7 + 007c3 08 DB 8 + 007c4 0c DB 12 ; 0000000cH + 007c5 0c DB 12 ; 0000000cH + 007c6 09 DB 9 + 007c7 0c DB 12 ; 0000000cH + 007c8 0a DB 10 ; 0000000aH + 007c9 0c DB 12 ; 0000000cH + 007ca 0c DB 12 ; 0000000cH + 007cb 0b DB 11 ; 0000000bH _streamout ENDP _TEXT ENDS ; Function compile flags: /Ogtp ; File c:\users\philip\documents\github\mollenos\clib\src\stdio\stream.c ; COMDAT _format_float _TEXT SEGMENT -tv570 = -44 ; size = 8 -tv516 = -44 ; size = 8 -tv490 = -44 ; size = 8 -tv366 = -44 ; size = 8 -tv578 = -36 ; size = 8 -_fpval$1$ = -28 ; size = 8 -_padding$1$ = -20 ; size = 4 +tv566 = -48 ; size = 8 +tv559 = -48 ; size = 8 +tv493 = -48 ; size = 8 +tv358 = -48 ; size = 8 +tv351 = -48 ; size = 8 +tv81 = -48 ; size = 8 +tv486 = -40 ; size = 8 +tv471 = -40 ; size = 8 +tv425 = -40 ; size = 8 +tv421 = -40 ; size = 8 +tv393 = -40 ; size = 8 +tv385 = -40 ; size = 8 +_fpval$1$ = -32 ; size = 8 +_padding$1$ = -24 ; size = 4 +_exponent$1$ = -20 ; size = 4 _fpval2$1$ = -16 ; size = 8 -tv535 = -16 ; size = 8 -tv85 = -16 ; size = 8 -_fpval2$ = -16 ; size = 8 -_sign$1$ = -12 ; size = 4 -_exponent$1$ = -8 ; size = 4 -_digits$1$ = -4 ; size = 4 -_num_digits$2$ = 8 ; size = 4 -_val32$1$ = 8 ; size = 4 +_sign$ = -12 ; size = 4 +_digits$1$ = -8 ; size = 4 +_precision$1$ = -4 ; size = 4 +tv398 = 8 ; size = 4 +tv79 = 8 ; size = 4 _chr$ = 8 ; size = 1 _flags$ = 12 ; size = 4 +tv733 = 16 ; size = 4 +tv487 = 16 ; size = 4 +tv472 = 16 ; size = 4 +tv386 = 16 ; size = 4 +tv130 = 16 ; size = 4 +tv76 = 16 ; size = 4 +_num_digits$2$ = 16 ; size = 4 +_num_digits$1$ = 16 ; size = 4 _precision$ = 16 ; size = 4 -_num_digits$1$ = 20 ; size = 4 _string$ = 20 ; size = 4 _prefix$ = 24 ; size = 4 _argptr$ = 28 ; size = 4 @@ -1811,8 +1863,8 @@ _format_float PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp - 00003 83 ec 2c sub esp, 44 ; 0000002cH - 00006 56 push esi + 00003 83 ec 30 sub esp, 48 ; 00000030H + 00006 53 push ebx ; 302 : static const char digits_l[] = ("0123456789abcdef0x"); ; 303 : static const char digits_u[] = ("0123456789ABCDEF0X"); @@ -1823,39 +1875,42 @@ _format_float PROC ; COMDAT ; 308 : long double fpval, fpval2; ; 309 : int padding = 0, num_digits, val32, base = 10; - 00007 33 f6 xor esi, esi - 00009 c7 45 fc 00 00 + 00007 33 db xor ebx, ebx + 00009 c7 45 f8 00 00 00 00 mov DWORD PTR _digits$1$[ebp], OFFSET ?digits_l@?1??format_float@@9@9 - 00010 89 75 ec mov DWORD PTR _padding$1$[ebp], esi + 00010 89 5d e8 mov DWORD PTR _padding$1$[ebp], ebx ; 310 : ; 311 : /* Normalize the precision */ ; 312 : if (precision < 0) precision = 6; - 00013 8b 75 10 mov esi, DWORD PTR _precision$[ebp] - 00016 57 push edi - 00017 85 f6 test esi, esi - 00019 79 07 jns SHORT $LN37@format_flo - 0001b be 06 00 00 00 mov esi, 6 - 00020 eb 10 jmp SHORT $LN84@format_flo + 00013 8b 5d 10 mov ebx, DWORD PTR _precision$[ebp] + 00016 89 5d fc mov DWORD PTR _precision$1$[ebp], ebx + 00019 56 push esi + 0001a 57 push edi + 0001b 85 db test ebx, ebx + 0001d 79 07 jns SHORT $LN37@format_flo + 0001f bb 06 00 00 00 mov ebx, 6 + 00024 eb 10 jmp SHORT $LN168@format_flo $LN37@format_flo: ; 313 : else if (precision > 17) - 00022 83 fe 11 cmp esi, 17 ; 00000011H - 00025 7e 0e jle SHORT $LN35@format_flo + 00026 83 fb 11 cmp ebx, 17 ; 00000011H + 00029 7e 11 jle SHORT $LN35@format_flo ; 314 : { ; 315 : padding = precision - 17; - 00027 83 c6 ef add esi, -17 ; ffffffefH - 0002a 89 75 ec mov DWORD PTR _padding$1$[ebp], esi + 0002b 83 c3 ef add ebx, -17 ; ffffffefH + 0002e 89 5d e8 mov DWORD PTR _padding$1$[ebp], ebx ; 316 : precision = 17; - 0002d be 11 00 00 00 mov esi, 17 ; 00000011H -$LN84@format_flo: - 00032 89 75 10 mov DWORD PTR _precision$[ebp], esi + 00031 bb 11 00 00 00 mov ebx, 17 ; 00000011H +$LN168@format_flo: + 00036 89 5d 10 mov DWORD PTR _precision$[ebp], ebx + 00039 89 5d fc mov DWORD PTR _precision$1$[ebp], ebx $LN35@format_flo: ; 317 : } @@ -1863,244 +1918,310 @@ $LN35@format_flo: ; 319 : /* Get the float value and calculate the exponent */ ; 320 : fpval = va_arg_ffp(*argptr, flags); - 00035 8b 45 1c mov eax, DWORD PTR _argptr$[ebp] - 00038 0f 57 c9 xorps xmm1, xmm1 - 0003b 83 00 08 add DWORD PTR [eax], 8 - 0003e 8b 00 mov eax, DWORD PTR [eax] - 00040 f2 0f 10 40 f8 movsd xmm0, QWORD PTR [eax-8] + 0003c 8b 45 1c mov eax, DWORD PTR _argptr$[ebp] + 0003f 83 00 08 add DWORD PTR [eax], 8 + 00042 8b 00 mov eax, DWORD PTR [eax] + 00044 dd 40 f8 fld QWORD PTR [eax-8] + 00047 dd 55 e0 fst QWORD PTR _fpval$1$[ebp] ; 321 : exponent = get_exp((double)fpval); - 00045 66 0f 2e c1 ucomisd xmm0, xmm1 - 00049 f2 0f 11 45 e4 movsd QWORD PTR _fpval$1$[ebp], xmm0 - 0004e 9f lahf - 0004f f6 c4 44 test ah, 68 ; 00000044H - 00052 7a 07 jp SHORT $LN44@format_flo - 00054 f2 0f 11 4d f0 movsd QWORD PTR tv85[ebp], xmm1 - 00059 eb 18 jmp SHORT $LN43@format_flo + 0004a d9 ee fldz + 0004c dd e1 fucom ST(1) + 0004e df e0 fnstsw ax + 00050 f6 c4 44 test ah, 68 ; 00000044H + 00053 7a 04 jp SHORT $LN44@format_flo + 00055 dd d9 fstp ST(1) + 00057 eb 10 jmp SHORT $LN43@format_flo $LN44@format_flo: - 0005b 66 0f 2f c1 comisd xmm0, xmm1 - 0005f 73 08 jae SHORT $LN85@format_flo - 00061 66 0f 57 05 00 - 00 00 00 xorpd xmm0, QWORD PTR __xmm@80000000000000008000000000000000 -$LN85@format_flo: - 00069 e8 00 00 00 00 call __libm_sse2_log10_precise - 0006e f2 0f 11 45 f0 movsd QWORD PTR tv85[ebp], xmm0 + 00059 d8 d9 fcomp ST(1) + 0005b df e0 fnstsw ax + 0005d f6 c4 41 test ah, 65 ; 00000041H + 00060 7b 02 jnp SHORT $LN169@format_flo + 00062 d9 e0 fchs +$LN169@format_flo: + 00064 e8 00 00 00 00 call __CIlog10 $LN43@format_flo: - 00073 dd 45 f0 fld QWORD PTR tv85[ebp] - 00076 83 ec 08 sub esp, 8 - 00079 dd 1c 24 fstp QWORD PTR [esp] - 0007c e8 00 00 00 00 call _floor + 00069 83 ec 08 sub esp, 8 + 0006c dd 1c 24 fstp QWORD PTR [esp] + 0006f e8 00 00 00 00 call _floor + 00074 83 c4 08 add esp, 8 + 00077 e8 00 00 00 00 call __ftol2_sse ; 322 : sign = fpval < 0 ? -1 : 1; - 00081 f2 0f 10 45 e4 movsd xmm0, QWORD PTR _fpval$1$[ebp] - 00086 33 d2 xor edx, edx + 0007c dd 45 e0 fld QWORD PTR _fpval$1$[ebp] + 0007f 8b f0 mov esi, eax + 00081 d9 ee fldz + 00083 d8 d9 fcomp ST(1) + 00085 89 75 ec mov DWORD PTR _exponent$1$[ebp], esi + 00088 df e0 fnstsw ax + 0008a c7 45 f4 ff ff + ff ff mov DWORD PTR _sign$[ebp], -1 + 00091 f6 c4 41 test ah, 65 ; 00000041H + 00094 74 07 je SHORT $LN47@format_flo + 00096 c7 45 f4 01 00 + 00 00 mov DWORD PTR _sign$[ebp], 1 +$LN47@format_flo: ; 323 : ; 324 : switch (chr) - 00088 8b 45 08 mov eax, DWORD PTR _chr$[ebp] - 0008b 83 c4 08 add esp, 8 - 0008e 8b 7d 14 mov edi, DWORD PTR _string$[ebp] - 00091 0f 57 c9 xorps xmm1, xmm1 - 00094 66 0f 2f c8 comisd xmm1, xmm0 - 00098 0f be c0 movsx eax, al - 0009b dd 5d dc fstp QWORD PTR tv578[ebp] - 0009e f2 0f 2c 4d dc cvttsd2si ecx, QWORD PTR tv578[ebp] - 000a3 0f 96 c2 setbe dl + 0009d 8b 45 08 mov eax, DWORD PTR _chr$[ebp] + 000a0 8b 7d 14 mov edi, DWORD PTR _string$[ebp] + 000a3 0f be c0 movsx eax, al 000a6 83 c0 bf add eax, -65 ; ffffffbfH - 000a9 8d 14 55 ff ff - ff ff lea edx, DWORD PTR [edx*2-1] - 000b0 89 55 f4 mov DWORD PTR _sign$1$[ebp], edx - 000b3 89 4d f8 mov DWORD PTR _exponent$1$[ebp], ecx - 000b6 83 f8 26 cmp eax, 38 ; 00000026H - 000b9 0f 87 11 02 00 - 00 ja $LN19@format_flo - 000bf 0f b6 80 00 00 - 00 00 movzx eax, BYTE PTR $LN82@format_flo[eax] - 000c6 ff 24 85 00 00 - 00 00 jmp DWORD PTR $LN87@format_flo[eax*4] + 000a9 83 f8 26 cmp eax, 38 ; 00000026H + 000ac 0f 87 57 02 00 + 00 ja $LN102@format_flo + 000b2 0f b6 80 00 00 + 00 00 movzx eax, BYTE PTR $LN84@format_flo[eax] + 000b9 ff 24 85 00 00 + 00 00 jmp DWORD PTR $LN173@format_flo[eax*4] $LN32@format_flo: ; 325 : { ; 326 : case ('G'): ; 327 : digits = digits_u; - 000cd c7 45 fc 00 00 + 000c0 c7 45 f8 00 00 00 00 mov DWORD PTR _digits$1$[ebp], OFFSET ?digits_u@?1??format_float@@9@9 $LN31@format_flo: ; 328 : case ('g'): ; 329 : if (precision > 0) precision--; - 000d4 85 f6 test esi, esi - 000d6 7e 04 jle SHORT $LN30@format_flo - 000d8 4e dec esi - 000d9 89 75 10 mov DWORD PTR _precision$[ebp], esi + 000c7 85 db test ebx, ebx + 000c9 7e 07 jle SHORT $LN30@format_flo + 000cb 4b dec ebx + 000cc 89 5d fc mov DWORD PTR _precision$1$[ebp], ebx + 000cf 89 5d 10 mov DWORD PTR _precision$[ebp], ebx $LN30@format_flo: ; 330 : if (exponent < -4 || exponent >= precision) goto case_e; - 000dc 83 f9 fc cmp ecx, -4 ; fffffffcH - 000df 0f 8c a2 00 00 - 00 jl $case_e$88 - 000e5 3b ce cmp ecx, esi - 000e7 0f 8d 9a 00 00 - 00 jge $case_e$88 + 000d2 83 fe fc cmp esi, -4 ; fffffffcH + 000d5 0f 8c bb 00 00 + 00 jl $case_e$174 + 000db 3b f3 cmp esi, ebx + 000dd 0f 8d b3 00 00 + 00 jge $case_e$174 ; 331 : ; 332 : /* Shift the decimal point and round */ ; 333 : fpval2 = round(sign * (double)fpval * pow(10., precision)); - 000ed f2 0f 10 05 00 - 00 00 00 movsd xmm0, QWORD PTR __real@4024000000000000 - 000f5 66 0f 6e ce movd xmm1, esi - 000f9 f3 0f e6 c9 cvtdq2pd xmm1, xmm1 - 000fd e8 00 00 00 00 call __libm_sse2_pow_precise - 00102 66 0f 6e 4d f4 movd xmm1, DWORD PTR _sign$1$[ebp] - 00107 83 ec 08 sub esp, 8 - 0010a f3 0f e6 c9 cvtdq2pd xmm1, xmm1 - 0010e f2 0f 59 4d e4 mulsd xmm1, QWORD PTR _fpval$1$[ebp] - 00113 f2 0f 59 c1 mulsd xmm0, xmm1 - 00117 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3fe0000000000000 - 0011f f2 0f 11 45 d4 movsd QWORD PTR tv570[ebp], xmm0 - 00124 dd 45 d4 fld QWORD PTR tv570[ebp] - 00127 dd 1c 24 fstp QWORD PTR [esp] - 0012a e8 00 00 00 00 call _floor - 0012f 83 c4 08 add esp, 8 - 00132 dd 5d f0 fstp QWORD PTR _fpval2$[ebp] + 000e3 dd d8 fstp ST(0) + 000e5 db 45 10 fild DWORD PTR _precision$[ebp] + 000e8 dd 5d d0 fstp QWORD PTR tv566[ebp] + 000eb dd 05 00 00 00 + 00 fld QWORD PTR __real@4024000000000000 + 000f1 dd 45 d0 fld QWORD PTR tv566[ebp] + 000f4 e8 00 00 00 00 call __CIpow + 000f9 db 45 f4 fild DWORD PTR _sign$[ebp] + 000fc 83 ec 08 sub esp, 8 + 000ff dd 5d d0 fstp QWORD PTR tv559[ebp] + 00102 dd 45 d0 fld QWORD PTR tv559[ebp] + 00105 dc 4d e0 fmul QWORD PTR _fpval$1$[ebp] + 00108 de c9 fmulp ST(1), ST(0) + 0010a dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fe0000000000000 + 00110 dd 1c 24 fstp QWORD PTR [esp] + 00113 e8 00 00 00 00 call _floor + 00118 83 c4 08 add esp, 8 + 0011b dd 55 f0 fst QWORD PTR _fpval2$1$[ebp] ; 334 : ; 335 : /* Skip trailing zeroes */ ; 336 : while (precision && (unsigned __int64)fpval2 % 10 == 0) - 00135 85 f6 test esi, esi - 00137 0f 84 db 01 00 - 00 je $LN83@format_flo - 0013d f2 0f 10 4d f0 movsd xmm1, QWORD PTR _fpval2$[ebp] - 00142 f2 0f 11 4d f0 movsd QWORD PTR _fpval2$1$[ebp], xmm1 -$LL27@format_flo: - 00147 66 0f 28 c1 movapd xmm0, xmm1 - 0014b e8 00 00 00 00 call __dtoul3 - 00150 6a 00 push 0 - 00152 6a 0a push 10 ; 0000000aH - 00154 52 push edx - 00155 50 push eax - 00156 e8 00 00 00 00 call __aullrem - 0015b 0b c2 or eax, edx - 0015d 0f 85 bf 01 00 - 00 jne $LN33@format_flo + 0011e 85 db test ebx, ebx + 00120 0f 84 22 02 00 + 00 je $LN170@format_flo + 00126 dd 05 00 00 00 + 00 fld QWORD PTR __real@43e0000000000000 + 0012c eb 02 jmp SHORT $LN27@format_flo +$LN137@format_flo: + 0012e d9 c9 fxch ST(1) +$LN27@format_flo: + 00130 d9 c1 fld ST(1) + 00132 33 c9 xor ecx, ecx + 00134 d8 d1 fcom ST(1) + 00136 89 4d 10 mov DWORD PTR tv733[ebp], ecx + 00139 df e0 fnstsw ax + 0013b 33 f6 xor esi, esi + 0013d f6 c4 01 test ah, 1 + 00140 75 16 jne SHORT $LN85@format_flo + 00142 d8 e1 fsub ST(0), ST(1) + 00144 d8 d1 fcom ST(1) + 00146 df e0 fnstsw ax + 00148 f6 c4 05 test ah, 5 + 0014b 7a 0b jp SHORT $LN85@format_flo + 0014d 03 f1 add esi, ecx + 0014f 81 d1 00 00 00 + 80 adc ecx, -2147483648 ; 80000000H + 00155 89 4d 10 mov DWORD PTR tv733[ebp], ecx +$LN85@format_flo: + 00158 e8 00 00 00 00 call __ftol2 + 0015d 03 c6 add eax, esi + 0015f 6a 00 push 0 + 00161 13 55 10 adc edx, DWORD PTR tv733[ebp] + 00164 6a 0a push 10 ; 0000000aH + 00166 52 push edx + 00167 50 push eax + 00168 e8 00 00 00 00 call __aullrem + 0016d 0b c2 or eax, edx + 0016f 0f 85 d1 01 00 + 00 jne $LN133@format_flo ; 337 : { ; 338 : precision--; ; 339 : fpval2 /= 10; - 00163 f2 0f 10 4d f0 movsd xmm1, QWORD PTR _fpval2$1$[ebp] - 00168 4e dec esi - 00169 f2 0f 5e 0d 00 - 00 00 00 divsd xmm1, QWORD PTR __real@4024000000000000 - 00171 89 75 10 mov DWORD PTR _precision$[ebp], esi - 00174 f2 0f 11 4d f0 movsd QWORD PTR _fpval2$1$[ebp], xmm1 - 00179 75 cc jne SHORT $LL27@format_flo + 00175 dd 05 00 00 00 + 00 fld QWORD PTR __real@4024000000000000 + 0017b 4b dec ebx + 0017c de fa fdivp ST(2), ST(0) + 0017e d9 c9 fxch ST(1) + 00180 89 5d fc mov DWORD PTR _precision$1$[ebp], ebx + 00183 dd 55 f0 fst QWORD PTR _fpval2$1$[ebp] + 00186 75 a6 jne SHORT $LN137@format_flo + 00188 dd d8 fstp ST(0) ; 340 : } ; 341 : break; - 0017b e9 a2 01 00 00 jmp $LN33@format_flo + 0018a e9 b9 01 00 00 jmp $LN170@format_flo $LN25@format_flo: ; 342 : ; 343 : case ('E'): ; 344 : digits = digits_u; - 00180 c7 45 fc 00 00 + 0018f c7 45 f8 00 00 00 00 mov DWORD PTR _digits$1$[ebp], OFFSET ?digits_u@?1??format_float@@9@9 -$case_e$88: - 00187 66 0f 6e ca movd xmm1, edx +$case_e$174: ; 345 : case ('e'): ; 346 : case_e: ; 347 : /* Shift the decimal point and round */ ; 348 : fpval2 = round(sign * (double)fpval * pow(10., precision - exponent)); - 0018b 8b c6 mov eax, esi - 0018d f3 0f e6 c9 cvtdq2pd xmm1, xmm1 - 00191 2b c1 sub eax, ecx - 00193 f2 0f 59 c8 mulsd xmm1, xmm0 - 00197 f2 0f 10 05 00 - 00 00 00 movsd xmm0, QWORD PTR __real@4024000000000000 - 0019f f2 0f 11 4d d4 movsd QWORD PTR tv366[ebp], xmm1 - 001a4 66 0f 6e c8 movd xmm1, eax - 001a8 f3 0f e6 c9 cvtdq2pd xmm1, xmm1 - 001ac e8 00 00 00 00 call __libm_sse2_pow_precise - 001b1 f2 0f 59 45 d4 mulsd xmm0, QWORD PTR tv366[ebp] - 001b6 83 ec 08 sub esp, 8 - 001b9 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3fe0000000000000 - 001c1 f2 0f 11 45 f0 movsd QWORD PTR tv535[ebp], xmm0 - 001c6 dd 45 f0 fld QWORD PTR tv535[ebp] + 00196 db 45 f4 fild DWORD PTR _sign$[ebp] + 00199 8b c3 mov eax, ebx + 0019b 2b c6 sub eax, esi + 0019d 89 45 10 mov DWORD PTR tv487[ebp], eax + 001a0 dd 5d d0 fstp QWORD PTR tv493[ebp] + 001a3 dc 4d d0 fmul QWORD PTR tv493[ebp] + 001a6 dd 5d d0 fstp QWORD PTR tv81[ebp] + 001a9 db 45 10 fild DWORD PTR tv487[ebp] + 001ac dd 5d d8 fstp QWORD PTR tv486[ebp] + 001af dd 05 00 00 00 + 00 fld QWORD PTR __real@4024000000000000 + 001b5 dd 45 d8 fld QWORD PTR tv486[ebp] + 001b8 e8 00 00 00 00 call __CIpow + 001bd dc 4d d0 fmul QWORD PTR tv81[ebp] + 001c0 83 ec 08 sub esp, 8 + 001c3 dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fe0000000000000 001c9 dd 1c 24 fstp QWORD PTR [esp] 001cc e8 00 00 00 00 call _floor + 001d1 dd 5d f0 fstp QWORD PTR _fpval2$1$[ebp] ; 349 : ; 350 : /* Compensate for changed exponent through rounding */ ; 351 : if (fpval2 >= (unsigned __int64)pow(10., precision + 1)) - 001d1 f2 0f 10 05 00 - 00 00 00 movsd xmm0, QWORD PTR __real@4024000000000000 - 001d9 8d 46 01 lea eax, DWORD PTR [esi+1] - 001dc 66 0f 6e c8 movd xmm1, eax - 001e0 83 c4 08 add esp, 8 - 001e3 f3 0f e6 c9 cvtdq2pd xmm1, xmm1 - 001e7 dd 5d f0 fstp QWORD PTR _fpval2$[ebp] - 001ea e8 00 00 00 00 call __libm_sse2_pow_precise - 001ef e8 00 00 00 00 call __dtoul3 - 001f4 8b c8 mov ecx, eax - 001f6 e8 00 00 00 00 call __ultod3 - 001fb f2 0f 10 4d f0 movsd xmm1, QWORD PTR _fpval2$[ebp] - 00200 66 0f 2f c8 comisd xmm1, xmm0 - 00204 f2 0f 11 4d f0 movsd QWORD PTR _fpval2$1$[ebp], xmm1 - 00209 72 52 jb SHORT $LN23@format_flo + 001d4 8d 43 01 lea eax, DWORD PTR [ebx+1] + 001d7 83 c4 08 add esp, 8 + 001da 89 45 10 mov DWORD PTR tv472[ebp], eax + 001dd db 45 10 fild DWORD PTR tv472[ebp] + 001e0 dd 5d d8 fstp QWORD PTR tv471[ebp] + 001e3 dd 05 00 00 00 + 00 fld QWORD PTR __real@4024000000000000 + 001e9 dd 45 d8 fld QWORD PTR tv471[ebp] + 001ec e8 00 00 00 00 call __CIpow + 001f1 dd 05 00 00 00 + 00 fld QWORD PTR __real@43e0000000000000 + 001f7 33 c9 xor ecx, ecx + 001f9 d8 d1 fcom ST(1) + 001fb 89 4d 10 mov DWORD PTR tv76[ebp], ecx + 001fe df e0 fnstsw ax + 00200 33 d2 xor edx, edx + 00202 89 55 08 mov DWORD PTR tv79[ebp], edx + 00205 f6 c4 41 test ah, 65 ; 00000041H + 00208 7a 1b jp SHORT $LN116@format_flo + 0020a dc e9 fsub ST(1), ST(0) + 0020c d8 d9 fcomp ST(1) + 0020e df e0 fnstsw ax + 00210 f6 c4 41 test ah, 65 ; 00000041H + 00213 75 12 jne SHORT $LN86@format_flo + 00215 03 c9 add ecx, ecx + 00217 89 4d 10 mov DWORD PTR tv76[ebp], ecx + 0021a 81 d2 00 00 00 + 80 adc edx, -2147483648 ; 80000000H + 00220 89 55 08 mov DWORD PTR tv79[ebp], edx + 00223 eb 02 jmp SHORT $LN86@format_flo +$LN116@format_flo: + 00225 dd d8 fstp ST(0) +$LN86@format_flo: + 00227 e8 00 00 00 00 call __ftol2 + 0022c 03 45 10 add eax, DWORD PTR tv76[ebp] + 0022f 89 45 d8 mov DWORD PTR tv425[ebp], eax + 00232 13 55 08 adc edx, DWORD PTR tv79[ebp] + 00235 8b c2 mov eax, edx + 00237 81 e2 ff ff ff + 7f and edx, 2147483647 ; 7fffffffH + 0023d 89 55 dc mov DWORD PTR tv425[ebp+4], edx + 00240 25 00 00 00 80 and eax, -2147483648 ; 80000000H + 00245 df 6d d8 fild QWORD PTR tv425[ebp] + 00248 89 45 dc mov DWORD PTR tv421[ebp+4], eax + 0024b c7 45 d8 00 00 + 00 00 mov DWORD PTR tv421[ebp], 0 + 00252 df 6d d8 fild QWORD PTR tv421[ebp] + 00255 d9 e0 fchs + 00257 de c1 faddp ST(1), ST(0) + 00259 dd 5d d8 fstp QWORD PTR tv393[ebp] + 0025c dd 45 d8 fld QWORD PTR tv393[ebp] + 0025f dc 5d f0 fcomp QWORD PTR _fpval2$1$[ebp] + 00262 df e0 fnstsw ax + 00264 f6 c4 41 test ah, 65 ; 00000041H + 00267 7a 39 jp SHORT $LN23@format_flo ; 352 : { ; 353 : exponent++; - 0020b f2 0f 2c 4d dc cvttsd2si ecx, QWORD PTR tv578[ebp] + 00269 46 inc esi ; 354 : fpval2 = round(sign * (double)fpval * pow(10., precision - exponent)); - 00210 8b c6 mov eax, esi - 00212 f2 0f 10 05 00 - 00 00 00 movsd xmm0, QWORD PTR __real@4024000000000000 - 0021a 41 inc ecx - 0021b 2b c1 sub eax, ecx - 0021d 89 4d f8 mov DWORD PTR _exponent$1$[ebp], ecx - 00220 66 0f 6e c8 movd xmm1, eax - 00224 f3 0f e6 c9 cvtdq2pd xmm1, xmm1 - 00228 e8 00 00 00 00 call __libm_sse2_pow_precise - 0022d f2 0f 59 45 d4 mulsd xmm0, QWORD PTR tv366[ebp] - 00232 83 ec 08 sub esp, 8 - 00235 f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3fe0000000000000 - 0023d f2 0f 11 45 d4 movsd QWORD PTR tv516[ebp], xmm0 - 00242 dd 45 d4 fld QWORD PTR tv516[ebp] - 00245 dd 1c 24 fstp QWORD PTR [esp] - 00248 e8 00 00 00 00 call _floor - 0024d dd 5d f0 fstp QWORD PTR _fpval2$[ebp] - 00250 f2 0f 10 45 f0 movsd xmm0, QWORD PTR _fpval2$[ebp] - 00255 83 c4 08 add esp, 8 - 00258 f2 0f 11 45 f0 movsd QWORD PTR _fpval2$1$[ebp], xmm0 + 0026a 8b c3 mov eax, ebx + 0026c 2b c6 sub eax, esi + 0026e 89 75 ec mov DWORD PTR _exponent$1$[ebp], esi + 00271 89 45 10 mov DWORD PTR tv386[ebp], eax + 00274 db 45 10 fild DWORD PTR tv386[ebp] + 00277 dd 5d d8 fstp QWORD PTR tv385[ebp] + 0027a dd 05 00 00 00 + 00 fld QWORD PTR __real@4024000000000000 + 00280 dd 45 d8 fld QWORD PTR tv385[ebp] + 00283 e8 00 00 00 00 call __CIpow + 00288 dc 4d d0 fmul QWORD PTR tv81[ebp] + 0028b 83 ec 08 sub esp, 8 + 0028e dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fe0000000000000 + 00294 dd 1c 24 fstp QWORD PTR [esp] + 00297 e8 00 00 00 00 call _floor + 0029c dd 5d f0 fstp QWORD PTR _fpval2$1$[ebp] + 0029f 83 c4 08 add esp, 8 $LN23@format_flo: ; 355 : } ; 356 : ; 357 : val32 = exponent >= 0 ? exponent : -exponent; - 0025d 8b 45 f8 mov eax, DWORD PTR _exponent$1$[ebp] - 00260 99 cdq - 00261 8b c8 mov ecx, eax + 002a2 8b c6 mov eax, esi + 002a4 99 cdq + 002a5 8b d8 mov ebx, eax ; 358 : ; 359 : // FIXME: handle length of exponent field: @@ -2108,75 +2229,72 @@ $LN23@format_flo: ; 361 : num_digits = 3; ; 362 : while (num_digits--) - 00263 b8 03 00 00 00 mov eax, 3 - 00268 33 ca xor ecx, edx - 0026a 2b ca sub ecx, edx - 0026c 89 4d 08 mov DWORD PTR _val32$1$[ebp], ecx - 0026f 90 npad 1 + 002a7 b8 03 00 00 00 mov eax, 3 + 002ac 33 da xor ebx, edx + 002ae 2b da sub ebx, edx $LL22@format_flo: - 00270 48 dec eax + 002b0 48 dec eax ; 363 : { ; 364 : *--(*string) = digits[val32 % 10]; - 00271 ff 0f dec DWORD PTR [edi] - 00273 89 45 14 mov DWORD PTR _num_digits$1$[ebp], eax - 00276 b8 67 66 66 66 mov eax, 1717986919 ; 66666667H - 0027b f7 e9 imul ecx - 0027d 8b 37 mov esi, DWORD PTR [edi] - 0027f c1 fa 02 sar edx, 2 - 00282 8b ca mov ecx, edx - 00284 c1 e9 1f shr ecx, 31 ; 0000001fH - 00287 03 ca add ecx, edx - 00289 8b 55 08 mov edx, DWORD PTR _val32$1$[ebp] + 002b1 ff 0f dec DWORD PTR [edi] + 002b3 89 45 10 mov DWORD PTR _num_digits$1$[ebp], eax + 002b6 b8 67 66 66 66 mov eax, 1717986919 ; 66666667H + 002bb 8b 37 mov esi, DWORD PTR [edi] + 002bd f7 eb imul ebx + 002bf c1 fa 02 sar edx, 2 + 002c2 8b ca mov ecx, edx + 002c4 c1 e9 1f shr ecx, 31 ; 0000001fH + 002c7 03 ca add ecx, edx + 002c9 8b 55 f8 mov edx, DWORD PTR _digits$1$[ebp] + 002cc 8d 04 89 lea eax, DWORD PTR [ecx+ecx*4] + 002cf 03 c0 add eax, eax + 002d1 2b d8 sub ebx, eax + 002d3 8a 04 13 mov al, BYTE PTR [ebx+edx] ; 365 : val32 /= 10; - 0028c 89 4d 08 mov DWORD PTR _val32$1$[ebp], ecx - 0028f 8d 04 89 lea eax, DWORD PTR [ecx+ecx*4] - 00292 03 c0 add eax, eax - 00294 2b d0 sub edx, eax - 00296 8b 45 fc mov eax, DWORD PTR _digits$1$[ebp] - 00299 8a 04 02 mov al, BYTE PTR [edx+eax] - 0029c 88 06 mov BYTE PTR [esi], al - 0029e 8b 45 14 mov eax, DWORD PTR _num_digits$1$[ebp] - 002a1 85 c0 test eax, eax - 002a3 75 cb jne SHORT $LL22@format_flo + 002d6 8b d9 mov ebx, ecx + 002d8 88 06 mov BYTE PTR [esi], al + 002da 8b 45 10 mov eax, DWORD PTR _num_digits$1$[ebp] + 002dd 85 c0 test eax, eax + 002df 75 cf jne SHORT $LL22@format_flo ; 366 : } ; 367 : ; 368 : /* Sign for the exponent */ ; 369 : *--(*string) = (exponent >= 0 ? ('+') : ('-')); - 002a5 ff 0f dec DWORD PTR [edi] - 002a7 39 45 f8 cmp DWORD PTR _exponent$1$[ebp], eax - 002aa 8b 0f mov ecx, DWORD PTR [edi] + 002e1 ff 0f dec DWORD PTR [edi] + 002e3 39 45 ec cmp DWORD PTR _exponent$1$[ebp], eax + 002e6 8b 0f mov ecx, DWORD PTR [edi] ; 370 : ; 371 : /* Add 'e' or 'E' separator */ ; 372 : *--(*string) = digits[0xe]; ; 373 : break; - 002ac 8b 75 10 mov esi, DWORD PTR _precision$[ebp] - 002af 0f 9c c0 setl al - 002b2 8d 04 45 2b 00 + 002e8 8b 5d fc mov ebx, DWORD PTR _precision$1$[ebp] + 002eb 0f 9c c0 setl al + 002ee 8d 04 45 2b 00 00 00 lea eax, DWORD PTR [eax*2+43] - 002b9 88 01 mov BYTE PTR [ecx], al - 002bb ff 0f dec DWORD PTR [edi] - 002bd 8b 45 fc mov eax, DWORD PTR _digits$1$[ebp] - 002c0 8b 0f mov ecx, DWORD PTR [edi] - 002c2 8a 40 0e mov al, BYTE PTR [eax+14] - 002c5 88 01 mov BYTE PTR [ecx], al - 002c7 eb 59 jmp SHORT $LN33@format_flo -$LN20@format_flo: + 002f5 88 01 mov BYTE PTR [ecx], al + 002f7 ff 0f dec DWORD PTR [edi] + 002f9 8b 0f mov ecx, DWORD PTR [edi] + 002fb 8a 42 0e mov al, BYTE PTR [edx+14] + 002fe 88 01 mov BYTE PTR [ecx], al + 00300 eb 48 jmp SHORT $LN33@format_flo +$LN103@format_flo: ; 374 : ; 375 : case ('A'): ; 376 : digits = digits_u; - 002c9 c7 45 fc 00 00 + 00302 c7 45 f8 00 00 00 00 mov DWORD PTR _digits$1$[ebp], OFFSET ?digits_u@?1??format_float@@9@9 -$LN19@format_flo: +$LN102@format_flo: + 00309 dd d8 fstp ST(0) ; 377 : case ('a'): ; 378 : // base = 16; @@ -2187,27 +2305,29 @@ $LN19@format_flo: ; 383 : /* Shift the decimal point and round */ ; 384 : fpval2 = round(sign * (double)fpval * pow(10., precision)); - 002d0 f2 0f 10 05 00 - 00 00 00 movsd xmm0, QWORD PTR __real@4024000000000000 - 002d8 66 0f 6e ce movd xmm1, esi - 002dc f3 0f e6 c9 cvtdq2pd xmm1, xmm1 - 002e0 e8 00 00 00 00 call __libm_sse2_pow_precise - 002e5 66 0f 6e 4d f4 movd xmm1, DWORD PTR _sign$1$[ebp] - 002ea 83 ec 08 sub esp, 8 - 002ed f3 0f e6 c9 cvtdq2pd xmm1, xmm1 - 002f1 f2 0f 59 4d e4 mulsd xmm1, QWORD PTR _fpval$1$[ebp] - 002f6 f2 0f 59 c1 mulsd xmm0, xmm1 - 002fa f2 0f 58 05 00 - 00 00 00 addsd xmm0, QWORD PTR __real@3fe0000000000000 - 00302 f2 0f 11 45 d4 movsd QWORD PTR tv490[ebp], xmm0 - 00307 dd 45 d4 fld QWORD PTR tv490[ebp] - 0030a dd 1c 24 fstp QWORD PTR [esp] - 0030d e8 00 00 00 00 call _floor - 00312 dd 5d f0 fstp QWORD PTR _fpval2$[ebp] - 00315 83 c4 08 add esp, 8 -$LN83@format_flo: - 00318 f2 0f 10 45 f0 movsd xmm0, QWORD PTR _fpval2$[ebp] - 0031d f2 0f 11 45 f0 movsd QWORD PTR _fpval2$1$[ebp], xmm0 + 0030b db 45 10 fild DWORD PTR _precision$[ebp] + 0030e dd 5d d0 fstp QWORD PTR tv358[ebp] + 00311 dd 05 00 00 00 + 00 fld QWORD PTR __real@4024000000000000 + 00317 dd 45 d0 fld QWORD PTR tv358[ebp] + 0031a e8 00 00 00 00 call __CIpow + 0031f db 45 f4 fild DWORD PTR _sign$[ebp] + 00322 83 ec 08 sub esp, 8 + 00325 dd 5d d0 fstp QWORD PTR tv351[ebp] + 00328 dd 45 d0 fld QWORD PTR tv351[ebp] + 0032b dc 4d e0 fmul QWORD PTR _fpval$1$[ebp] + 0032e de c9 fmulp ST(1), ST(0) + 00330 dc 05 00 00 00 + 00 fadd QWORD PTR __real@3fe0000000000000 + 00336 dd 1c 24 fstp QWORD PTR [esp] + 00339 e8 00 00 00 00 call _floor + 0033e dd 5d f0 fstp QWORD PTR _fpval2$1$[ebp] + 00341 83 c4 08 add esp, 8 + 00344 eb 04 jmp SHORT $LN33@format_flo +$LN133@format_flo: + 00346 dd d9 fstp ST(1) +$LN170@format_flo: + 00348 dd d8 fstp ST(0) $LN33@format_flo: ; 385 : break; @@ -2216,204 +2336,245 @@ $LN33@format_flo: ; 388 : /* Handle sign */ ; 389 : if (fpval < 0) - 00322 f2 0f 10 45 e4 movsd xmm0, QWORD PTR _fpval$1$[ebp] - 00327 0f 57 c9 xorps xmm1, xmm1 - 0032a 66 0f 2f c8 comisd xmm1, xmm0 - 0032e 76 0b jbe SHORT $LN18@format_flo + 0034a dd 45 e0 fld QWORD PTR _fpval$1$[ebp] + 0034d d9 ee fldz + 0034f d8 d9 fcomp ST(1) + 00351 df e0 fnstsw ax + 00353 f6 c4 41 test ah, 65 ; 00000041H + 00356 75 0b jne SHORT $LN18@format_flo ; 390 : { ; 391 : *prefix = ("-"); - 00330 8b 45 18 mov eax, DWORD PTR _prefix$[ebp] - 00333 c7 00 00 00 00 - 00 mov DWORD PTR [eax], OFFSET $SG2710 - 00339 eb 1f jmp SHORT $LN14@format_flo + 00358 8b 45 18 mov eax, DWORD PTR _prefix$[ebp] + 0035b c7 00 00 00 00 + 00 mov DWORD PTR [eax], OFFSET $SG2713 + 00361 eb 1f jmp SHORT $LN14@format_flo $LN18@format_flo: ; 392 : } ; 393 : else if (flags & FLAG_FORCE_SIGN) - 0033b 8b 45 0c mov eax, DWORD PTR _flags$[ebp] - 0033e a8 02 test al, 2 - 00340 74 0b je SHORT $LN16@format_flo + 00363 8b 45 0c mov eax, DWORD PTR _flags$[ebp] + 00366 a8 02 test al, 2 + 00368 74 0b je SHORT $LN16@format_flo ; 394 : *prefix = ("+"); - 00342 8b 45 18 mov eax, DWORD PTR _prefix$[ebp] - 00345 c7 00 00 00 00 - 00 mov DWORD PTR [eax], OFFSET $SG2713 - 0034b eb 0d jmp SHORT $LN14@format_flo + 0036a 8b 45 18 mov eax, DWORD PTR _prefix$[ebp] + 0036d c7 00 00 00 00 + 00 mov DWORD PTR [eax], OFFSET $SG2716 + 00373 eb 0d jmp SHORT $LN14@format_flo $LN16@format_flo: ; 395 : else if (flags & FLAG_FORCE_SIGNSP) - 0034d a8 04 test al, 4 - 0034f 74 09 je SHORT $LN14@format_flo + 00375 a8 04 test al, 4 + 00377 74 09 je SHORT $LN14@format_flo ; 396 : *prefix = (" "); - 00351 8b 45 18 mov eax, DWORD PTR _prefix$[ebp] - 00354 c7 00 00 00 00 - 00 mov DWORD PTR [eax], OFFSET $SG2716 + 00379 8b 45 18 mov eax, DWORD PTR _prefix$[ebp] + 0037c c7 00 00 00 00 + 00 mov DWORD PTR [eax], OFFSET $SG2719 $LN14@format_flo: ; 397 : ; 398 : /* Handle special cases first */ ; 399 : if (_isnan((double)fpval)) - 0035a 83 ec 08 sub esp, 8 - 0035d f2 0f 11 04 24 movsd QWORD PTR [esp], xmm0 - 00362 e8 00 00 00 00 call __isnan - 00367 83 c4 08 add esp, 8 - 0036a 85 c0 test eax, eax - 0036c 74 2a je SHORT $LN13@format_flo + 00382 83 ec 08 sub esp, 8 + 00385 dd 1c 24 fstp QWORD PTR [esp] + 00388 e8 00 00 00 00 call __isnan + 0038d 83 c4 08 add esp, 8 + 00390 85 c0 test eax, eax + 00392 74 21 je SHORT $LN13@format_flo ; 400 : { ; 401 : (*string) -= sizeof(_nan) / sizeof(char) - 1; - 0036e 83 07 fb add DWORD PTR [edi], -5 ; fffffffbH + 00394 83 07 fb add DWORD PTR [edi], -5 ; fffffffbH ; 402 : strcpy((*string), _nan); - 00371 b9 00 00 00 00 mov ecx, OFFSET ?_nan@?1??format_float@@9@9 - 00376 8b 17 mov edx, DWORD PTR [edi] -$LL46@format_flo: - 00378 8a 01 mov al, BYTE PTR [ecx] - 0037a 8d 49 01 lea ecx, DWORD PTR [ecx+1] - 0037d 88 02 mov BYTE PTR [edx], al - 0037f 8d 52 01 lea edx, DWORD PTR [edx+1] - 00382 84 c0 test al, al - 00384 75 f2 jne SHORT $LL46@format_flo + 00397 b9 00 00 00 00 mov ecx, OFFSET ?_nan@?1??format_float@@9@9 + 0039c 8b 17 mov edx, DWORD PTR [edi] + 0039e 8b ff npad 2 +$LL48@format_flo: + 003a0 8a 01 mov al, BYTE PTR [ecx] + 003a2 8d 49 01 lea ecx, DWORD PTR [ecx+1] + 003a5 88 02 mov BYTE PTR [edx], al + 003a7 8d 52 01 lea edx, DWORD PTR [edx+1] + 003aa 84 c0 test al, al + 003ac 75 f2 jne SHORT $LL48@format_flo ; 403 : fpval2 = 1; - 00386 f2 0f 10 05 00 - 00 00 00 movsd xmm0, QWORD PTR __real@3ff0000000000000 - 0038e f2 0f 11 45 f0 movsd QWORD PTR _fpval2$1$[ebp], xmm0 - 00393 e9 a1 00 00 00 jmp $LN60@format_flo + 003ae d9 e8 fld1 + 003b0 e9 b2 00 00 00 jmp $LN171@format_flo $LN13@format_flo: ; 404 : } ; 405 : else if (!_finite((double)fpval)) - 00398 f2 0f 10 55 e4 movsd xmm2, QWORD PTR _fpval$1$[ebp] - 0039d 83 ec 08 sub esp, 8 - 003a0 f2 0f 11 14 24 movsd QWORD PTR [esp], xmm2 - 003a5 e8 00 00 00 00 call __finite - 003aa 83 c4 08 add esp, 8 - 003ad 85 c0 test eax, eax - 003af 75 2c jne SHORT $LN52@format_flo + 003b5 dd 45 e0 fld QWORD PTR _fpval$1$[ebp] + 003b8 83 ec 08 sub esp, 8 + 003bb dd 1c 24 fstp QWORD PTR [esp] + 003be e8 00 00 00 00 call __finite + 003c3 83 c4 08 add esp, 8 + 003c6 85 c0 test eax, eax + 003c8 75 1f jne SHORT $LN54@format_flo ; 406 : { ; 407 : (*string) -= sizeof(_infinity) / sizeof(char) - 1; - 003b1 83 07 fc add DWORD PTR [edi], -4 ; fffffffcH + 003ca 83 07 fc add DWORD PTR [edi], -4 ; fffffffcH ; 408 : strcpy((*string), _infinity); - 003b4 b9 00 00 00 00 mov ecx, OFFSET ?_infinity@?1??format_float@@9@9 - 003b9 8b 17 mov edx, DWORD PTR [edi] - 003bb eb 03 8d 49 00 npad 5 -$LL47@format_flo: - 003c0 8a 01 mov al, BYTE PTR [ecx] - 003c2 8d 49 01 lea ecx, DWORD PTR [ecx+1] - 003c5 88 02 mov BYTE PTR [edx], al - 003c7 8d 52 01 lea edx, DWORD PTR [edx+1] - 003ca 84 c0 test al, al - 003cc 75 f2 jne SHORT $LL47@format_flo + 003cd b9 00 00 00 00 mov ecx, OFFSET ?_infinity@?1??format_float@@9@9 + 003d2 8b 17 mov edx, DWORD PTR [edi] +$LL49@format_flo: + 003d4 8a 01 mov al, BYTE PTR [ecx] + 003d6 8d 49 01 lea ecx, DWORD PTR [ecx+1] + 003d9 88 02 mov BYTE PTR [edx], al + 003db 8d 52 01 lea edx, DWORD PTR [edx+1] + 003de 84 c0 test al, al + 003e0 75 f2 jne SHORT $LL49@format_flo ; 409 : fpval2 = 1; - 003ce f2 0f 10 05 00 - 00 00 00 movsd xmm0, QWORD PTR __real@3ff0000000000000 - 003d6 f2 0f 11 45 f0 movsd QWORD PTR _fpval2$1$[ebp], xmm0 + 003e2 d9 e8 fld1 ; 410 : } ; 411 : else - 003db eb 5c jmp SHORT $LN60@format_flo -$LN52@format_flo: + 003e4 e9 7e 00 00 00 jmp $LN171@format_flo +$LN54@format_flo: ; 412 : { ; 413 : /* Zero padding */ ; 414 : while (padding-- > 0) *--(*string) = ('0'); - 003dd 8b 4d ec mov ecx, DWORD PTR _padding$1$[ebp] - 003e0 85 c9 test ecx, ecx - 003e2 7e 0c jle SHORT $LN58@format_flo -$LL9@format_flo: - 003e4 ff 0f dec DWORD PTR [edi] - 003e6 49 dec ecx - 003e7 8b 07 mov eax, DWORD PTR [edi] - 003e9 c6 00 30 mov BYTE PTR [eax], 48 ; 00000030H + 003e9 8b 4d e8 mov ecx, DWORD PTR _padding$1$[ebp] 003ec 85 c9 test ecx, ecx - 003ee 7f f4 jg SHORT $LL9@format_flo -$LN58@format_flo: + 003ee 7e 0c jle SHORT $LN60@format_flo +$LL9@format_flo: + 003f0 ff 0f dec DWORD PTR [edi] + 003f2 49 dec ecx + 003f3 8b 07 mov eax, DWORD PTR [edi] + 003f5 c6 00 30 mov BYTE PTR [eax], 48 ; 00000030H + 003f8 85 c9 test ecx, ecx + 003fa 7f f4 jg SHORT $LL9@format_flo +$LN60@format_flo: ; 415 : ; 416 : /* Digits after the decimal point */ ; 417 : num_digits = precision; - 003f0 8b c6 mov eax, esi + 003fc 89 5d 10 mov DWORD PTR _num_digits$2$[ebp], ebx ; 418 : while (num_digits-- > 0) - 003f2 85 f6 test esi, esi - 003f4 7e 49 jle SHORT $LN80@format_flo - 003f6 f2 0f 10 45 f0 movsd xmm0, QWORD PTR _fpval2$1$[ebp] - 003fb eb 03 8d 49 00 npad 5 -$LL7@format_flo: + 003ff 85 db test ebx, ebx + 00401 7e 6b jle SHORT $LN82@format_flo + 00403 dd 45 f0 fld QWORD PTR _fpval2$1$[ebp] +$LN7@format_flo: ; 419 : { ; 420 : *--(*string) = digits[(unsigned __int64)fpval2 % 10]; - 00400 ff 0f dec DWORD PTR [edi] - 00402 48 dec eax - 00403 8b 37 mov esi, DWORD PTR [edi] - 00405 89 45 08 mov DWORD PTR _num_digits$2$[ebp], eax - 00408 e8 00 00 00 00 call __dtoul3 - 0040d 6a 00 push 0 - 0040f 6a 0a push 10 ; 0000000aH - 00411 52 push edx - 00412 50 push eax - 00413 e8 00 00 00 00 call __aullrem + 00406 ff 0f dec DWORD PTR [edi] + 00408 d9 c0 fld ST(0) + 0040a dd 05 00 00 00 + 00 fld QWORD PTR __real@43e0000000000000 + 00410 33 c9 xor ecx, ecx + 00412 d8 d1 fcom ST(1) + 00414 89 4d 10 mov DWORD PTR tv130[ebp], ecx + 00417 df e0 fnstsw ax + 00419 4b dec ebx + 0041a 33 f6 xor esi, esi + 0041c f6 c4 41 test ah, 65 ; 00000041H + 0041f 7a 18 jp SHORT $LN149@format_flo + 00421 dc e9 fsub ST(1), ST(0) + 00423 d8 d9 fcomp ST(1) + 00425 df e0 fnstsw ax + 00427 f6 c4 41 test ah, 65 ; 00000041H + 0042a 75 0f jne SHORT $LN87@format_flo + 0042c 03 f1 add esi, ecx + 0042e 81 d1 00 00 00 + 80 adc ecx, -2147483648 ; 80000000H + 00434 89 4d 10 mov DWORD PTR tv130[ebp], ecx + 00437 eb 02 jmp SHORT $LN87@format_flo +$LN149@format_flo: + 00439 dd d8 fstp ST(0) +$LN87@format_flo: + 0043b e8 00 00 00 00 call __ftol2 + 00440 03 c6 add eax, esi + 00442 6a 00 push 0 + 00444 13 55 10 adc edx, DWORD PTR tv130[ebp] + 00447 6a 0a push 10 ; 0000000aH + 00449 52 push edx + 0044a 50 push eax + 0044b e8 00 00 00 00 call __aullrem + 00450 8b 4d f8 mov ecx, DWORD PTR _digits$1$[ebp] ; 421 : fpval2 /= base; - 00418 f2 0f 10 45 f0 movsd xmm0, QWORD PTR _fpval2$1$[ebp] - 0041d f2 0f 5e 05 00 - 00 00 00 divsd xmm0, QWORD PTR __real@4024000000000000 - 00425 8b 4d fc mov ecx, DWORD PTR _digits$1$[ebp] - 00428 8a 04 08 mov al, BYTE PTR [eax+ecx] - 0042b 88 06 mov BYTE PTR [esi], al - 0042d 8b 45 08 mov eax, DWORD PTR _num_digits$2$[ebp] - 00430 f2 0f 11 45 f0 movsd QWORD PTR _fpval2$1$[ebp], xmm0 - 00435 85 c0 test eax, eax - 00437 7f c7 jg SHORT $LL7@format_flo -$LN60@format_flo: + 00453 dc 35 00 00 00 + 00 fdiv QWORD PTR __real@4024000000000000 + 00459 8a 04 08 mov al, BYTE PTR [eax+ecx] + 0045c 8b 0f mov ecx, DWORD PTR [edi] + 0045e 88 01 mov BYTE PTR [ecx], al + 00460 85 db test ebx, ebx + 00462 7f a2 jg SHORT $LN7@format_flo + 00464 8b 5d fc mov ebx, DWORD PTR _precision$1$[ebp] +$LN171@format_flo: + 00467 dd 5d f0 fstp QWORD PTR _fpval2$1$[ebp] ; 422 : } ; 423 : } ; 424 : ; 425 : if (precision > 0 || flags & FLAG_SPECIAL) - 00439 83 7d 10 00 cmp DWORD PTR _precision$[ebp], 0 - 0043d 7f 06 jg SHORT $LN4@format_flo -$LN80@format_flo: - 0043f f6 45 0c 10 test BYTE PTR _flags$[ebp], 16 ; 00000010H - 00443 74 07 je SHORT $LN81@format_flo + 0046a 85 db test ebx, ebx + 0046c 7f 06 jg SHORT $LN4@format_flo +$LN82@format_flo: + 0046e f6 45 0c 10 test BYTE PTR _flags$[ebp], 16 ; 00000010H + 00472 74 07 je SHORT $LN83@format_flo $LN4@format_flo: ; 426 : *--(*string) = ('.'); - 00445 ff 0f dec DWORD PTR [edi] - 00447 8b 07 mov eax, DWORD PTR [edi] - 00449 c6 00 2e mov BYTE PTR [eax], 46 ; 0000002eH -$LN81@format_flo: - 0044c f2 0f 10 45 f0 movsd xmm0, QWORD PTR _fpval2$1$[ebp] - 00451 e8 00 00 00 00 call __dtoul3 - 00456 8b c8 mov ecx, eax -$LL3@format_flo: + 00474 ff 0f dec DWORD PTR [edi] + 00476 8b 07 mov eax, DWORD PTR [edi] + 00478 c6 00 2e mov BYTE PTR [eax], 46 ; 0000002eH +$LN83@format_flo: + 0047b dd 45 f0 fld QWORD PTR _fpval2$1$[ebp] + 0047e 33 f6 xor esi, esi + 00480 d9 c0 fld ST(0) + 00482 33 db xor ebx, ebx + 00484 dd 05 00 00 00 + 00 fld QWORD PTR __real@43e0000000000000 + 0048a d8 d1 fcom ST(1) + 0048c df e0 fnstsw ax + 0048e f6 c4 41 test ah, 65 ; 00000041H + 00491 7a 13 jp SHORT $LN88@format_flo + 00493 dc e9 fsub ST(1), ST(0) + 00495 d8 d1 fcom ST(1) + 00497 df e0 fnstsw ax + 00499 f6 c4 41 test ah, 65 ; 00000041H + 0049c 75 08 jne SHORT $LN88@format_flo + 0049e 03 f3 add esi, ebx + 004a0 81 d3 00 00 00 + 80 adc ebx, -2147483648 ; 80000000H +$LN88@format_flo: + 004a6 d9 c9 fxch ST(1) + 004a8 e8 00 00 00 00 call __ftol2 + 004ad 8b c8 mov ecx, eax + 004af 03 ce add ecx, esi + 004b1 13 d3 adc edx, ebx +$LN3@format_flo: ; 427 : ; 428 : /* Digits before the decimal point */ @@ -2421,88 +2582,108 @@ $LL3@format_flo: ; 430 : { ; 431 : *--(*string) = digits[(unsigned __int64)fpval2 % base]; - 00458 ff 0f dec DWORD PTR [edi] - 0045a 8b 37 mov esi, DWORD PTR [edi] - 0045c 6a 00 push 0 - 0045e 6a 0a push 10 ; 0000000aH - 00460 52 push edx - 00461 51 push ecx - 00462 e8 00 00 00 00 call __aullrem + 004b3 ff 0f dec DWORD PTR [edi] + 004b5 8b 37 mov esi, DWORD PTR [edi] + 004b7 6a 00 push 0 + 004b9 6a 0a push 10 ; 0000000aH + 004bb 52 push edx + 004bc 51 push ecx + 004bd e8 00 00 00 00 call __aullrem ; 432 : fpval2 /= base; - 00467 f2 0f 10 45 f0 movsd xmm0, QWORD PTR _fpval2$1$[ebp] - 0046c f2 0f 5e 05 00 - 00 00 00 divsd xmm0, QWORD PTR __real@4024000000000000 - 00474 8b 4d fc mov ecx, DWORD PTR _digits$1$[ebp] - 00477 8a 04 08 mov al, BYTE PTR [eax+ecx] - 0047a 88 06 mov BYTE PTR [esi], al - 0047c f2 0f 11 45 f0 movsd QWORD PTR _fpval2$1$[ebp], xmm0 + 004c2 dd 05 00 00 00 + 00 fld QWORD PTR __real@4024000000000000 ; 433 : } ; 434 : while ((unsigned __int64)fpval2); - 00481 e8 00 00 00 00 call __dtoul3 - 00486 8b c8 mov ecx, eax - 00488 0b c2 or eax, edx - 0048a 75 cc jne SHORT $LL3@format_flo - 0048c 5f pop edi - 0048d 5e pop esi + 004c8 33 db xor ebx, ebx + 004ca de fa fdivp ST(2), ST(0) + 004cc 8b 4d f8 mov ecx, DWORD PTR _digits$1$[ebp] + 004cf 8a 04 08 mov al, BYTE PTR [eax+ecx] + 004d2 88 06 mov BYTE PTR [esi], al + 004d4 33 f6 xor esi, esi + 004d6 d9 c1 fld ST(1) + 004d8 d8 d1 fcom ST(1) + 004da df e0 fnstsw ax + 004dc f6 c4 01 test ah, 1 + 004df 75 13 jne SHORT $LN89@format_flo + 004e1 d8 e1 fsub ST(0), ST(1) + 004e3 d8 d1 fcom ST(1) + 004e5 df e0 fnstsw ax + 004e7 f6 c4 05 test ah, 5 + 004ea 7a 08 jp SHORT $LN89@format_flo + 004ec 03 f3 add esi, ebx + 004ee 81 d3 00 00 00 + 80 adc ebx, -2147483648 ; 80000000H +$LN89@format_flo: + 004f4 e8 00 00 00 00 call __ftol2 + 004f9 8b c8 mov ecx, eax + 004fb 03 ce add ecx, esi + 004fd 8b c1 mov eax, ecx + 004ff 13 d3 adc edx, ebx + 00501 0b c2 or eax, edx + 00503 75 ae jne SHORT $LN3@format_flo + 00505 5f pop edi + 00506 dd d9 fstp ST(1) + 00508 5e pop esi + 00509 dd d8 fstp ST(0) + 0050b 5b pop ebx ; 435 : ; 436 : } - 0048e 8b e5 mov esp, ebp - 00490 5d pop ebp - 00491 c3 ret 0 - 00492 8b ff npad 2 -$LN87@format_flo: - 00494 00 00 00 00 DD $LN20@format_flo - 00498 00 00 00 00 DD $LN25@format_flo - 0049c 00 00 00 00 DD $LN32@format_flo - 004a0 00 00 00 00 DD $case_e$88 - 004a4 00 00 00 00 DD $LN31@format_flo - 004a8 00 00 00 00 DD $LN19@format_flo -$LN82@format_flo: - 004ac 00 DB 0 - 004ad 05 DB 5 - 004ae 05 DB 5 - 004af 05 DB 5 - 004b0 01 DB 1 - 004b1 05 DB 5 - 004b2 02 DB 2 - 004b3 05 DB 5 - 004b4 05 DB 5 - 004b5 05 DB 5 - 004b6 05 DB 5 - 004b7 05 DB 5 - 004b8 05 DB 5 - 004b9 05 DB 5 - 004ba 05 DB 5 - 004bb 05 DB 5 - 004bc 05 DB 5 - 004bd 05 DB 5 - 004be 05 DB 5 - 004bf 05 DB 5 - 004c0 05 DB 5 - 004c1 05 DB 5 - 004c2 05 DB 5 - 004c3 05 DB 5 - 004c4 05 DB 5 - 004c5 05 DB 5 - 004c6 05 DB 5 - 004c7 05 DB 5 - 004c8 05 DB 5 - 004c9 05 DB 5 - 004ca 05 DB 5 - 004cb 05 DB 5 - 004cc 05 DB 5 - 004cd 05 DB 5 - 004ce 05 DB 5 - 004cf 05 DB 5 - 004d0 03 DB 3 - 004d1 05 DB 5 - 004d2 04 DB 4 + 0050c 8b e5 mov esp, ebp + 0050e 5d pop ebp + 0050f c3 ret 0 +$LN173@format_flo: + 00510 00 00 00 00 DD $LN103@format_flo + 00514 00 00 00 00 DD $LN25@format_flo + 00518 00 00 00 00 DD $LN32@format_flo + 0051c 00 00 00 00 DD $case_e$174 + 00520 00 00 00 00 DD $LN31@format_flo + 00524 00 00 00 00 DD $LN102@format_flo +$LN84@format_flo: + 00528 00 DB 0 + 00529 05 DB 5 + 0052a 05 DB 5 + 0052b 05 DB 5 + 0052c 01 DB 1 + 0052d 05 DB 5 + 0052e 02 DB 2 + 0052f 05 DB 5 + 00530 05 DB 5 + 00531 05 DB 5 + 00532 05 DB 5 + 00533 05 DB 5 + 00534 05 DB 5 + 00535 05 DB 5 + 00536 05 DB 5 + 00537 05 DB 5 + 00538 05 DB 5 + 00539 05 DB 5 + 0053a 05 DB 5 + 0053b 05 DB 5 + 0053c 05 DB 5 + 0053d 05 DB 5 + 0053e 05 DB 5 + 0053f 05 DB 5 + 00540 05 DB 5 + 00541 05 DB 5 + 00542 05 DB 5 + 00543 05 DB 5 + 00544 05 DB 5 + 00545 05 DB 5 + 00546 05 DB 5 + 00547 05 DB 5 + 00548 05 DB 5 + 00549 05 DB 5 + 0054a 05 DB 5 + 0054b 05 DB 5 + 0054c 03 DB 3 + 0054d 05 DB 5 + 0054e 04 DB 4 _format_float ENDP _TEXT ENDS ; Function compile flags: /Ogtp @@ -3035,93 +3216,94 @@ _StreamCharacterToUtf8 PROC ; COMDAT ; 84 : if (Character <= 0x7F) /* 0XXX XXXX one byte */ 00006 8b 4d 08 mov ecx, DWORD PTR _Character$[ebp] - 00009 0f 57 c0 xorps xmm0, xmm0 - 0000c 56 push esi - 0000d 57 push edi - 0000e 33 f6 xor esi, esi - 00010 c6 45 f4 00 mov BYTE PTR _TmpBuffer$[ebp], 0 - 00014 33 ff xor edi, edi - 00016 66 0f d6 45 f5 movq QWORD PTR _TmpBuffer$[ebp+1], xmm0 - 0001b c6 45 fd 00 mov BYTE PTR _TmpBuffer$[ebp+9], 0 - 0001f 83 f9 7f cmp ecx, 127 ; 0000007fH - 00022 77 0b ja SHORT $LN18@StreamChar + 00009 33 c0 xor eax, eax + 0000b 56 push esi + 0000c 57 push edi + 0000d 33 f6 xor esi, esi + 0000f c6 45 f4 00 mov BYTE PTR _TmpBuffer$[ebp], 0 + 00013 33 ff xor edi, edi + 00015 89 45 f5 mov DWORD PTR _TmpBuffer$[ebp+1], eax + 00018 89 45 f9 mov DWORD PTR _TmpBuffer$[ebp+5], eax + 0001b 88 45 fd mov BYTE PTR _TmpBuffer$[ebp+9], al + 0001e 83 f9 7f cmp ecx, 127 ; 0000007fH + 00021 77 0b ja SHORT $LN18@StreamChar ; 85 : { ; 86 : TmpBuffer[0] = (char)(Character & 0xFF); - 00024 88 4d f4 mov BYTE PTR _TmpBuffer$[ebp], cl + 00023 88 4d f4 mov BYTE PTR _TmpBuffer$[ebp], cl ; 87 : NumBytes = 1; - 00027 8d 77 01 lea esi, DWORD PTR [edi+1] - 0002a e9 bc 00 00 00 jmp $LN21@StreamChar + 00026 8d 70 01 lea esi, DWORD PTR [eax+1] + 00029 e9 bc 00 00 00 jmp $LN21@StreamChar $LN18@StreamChar: ; 88 : } ; 89 : else if (Character <= 0x7FF) /* 110X XXXX two bytes */ - 0002f 81 f9 ff 07 00 + 0002e 81 f9 ff 07 00 00 cmp ecx, 2047 ; 000007ffH - 00035 77 1d ja SHORT $LN16@StreamChar + 00034 77 1d ja SHORT $LN16@StreamChar ; 90 : { ; 91 : TmpBuffer[0] = (char)(0xC0 | (Character >> 6)); - 00037 8b c1 mov eax, ecx + 00036 8b c1 mov eax, ecx ; 92 : TmpBuffer[1] = (char)(0x80 | (Character & 0x3F)); ; 93 : NumBytes = 2; - 00039 be 02 00 00 00 mov esi, 2 - 0003e c1 e8 06 shr eax, 6 - 00041 80 e1 3f and cl, 63 ; 0000003fH - 00044 0c c0 or al, -64 ; ffffffc0H - 00046 80 c9 80 or cl, -128 ; ffffff80H - 00049 88 45 f4 mov BYTE PTR _TmpBuffer$[ebp], al - 0004c 88 4d f5 mov BYTE PTR _TmpBuffer$[ebp+1], cl - 0004f e9 97 00 00 00 jmp $LN21@StreamChar + 00038 be 02 00 00 00 mov esi, 2 + 0003d c1 e8 06 shr eax, 6 + 00040 80 e1 3f and cl, 63 ; 0000003fH + 00043 0c c0 or al, -64 ; ffffffc0H + 00045 80 c9 80 or cl, -128 ; ffffff80H + 00048 88 45 f4 mov BYTE PTR _TmpBuffer$[ebp], al + 0004b 88 4d f5 mov BYTE PTR _TmpBuffer$[ebp+1], cl + 0004e e9 97 00 00 00 jmp $LN21@StreamChar $LN16@StreamChar: ; 94 : } ; 95 : else if (Character <= 0xFFFF) /* 1110 XXXX three bytes */ - 00054 81 f9 ff ff 00 + 00053 81 f9 ff ff 00 00 cmp ecx, 65535 ; 0000ffffH - 0005a 77 4f ja SHORT $LN14@StreamChar + 00059 77 4f ja SHORT $LN14@StreamChar ; 96 : { ; 97 : TmpBuffer[0] = (char)(0xE0 | (Character >> 12)); - 0005c 8b c1 mov eax, ecx + 0005b 8b c1 mov eax, ecx ; 98 : TmpBuffer[1] = (char)(0x80 | ((Character >> 6) & 0x3F)); ; 99 : TmpBuffer[2] = (char)(0x80 | (Character & 0x3F)); ; 100 : NumBytes = 3; - 0005e be 03 00 00 00 mov esi, 3 - 00063 c1 e8 0c shr eax, 12 ; 0000000cH - 00066 0c e0 or al, -32 ; ffffffe0H - 00068 88 45 f4 mov BYTE PTR _TmpBuffer$[ebp], al - 0006b 8b c1 mov eax, ecx - 0006d c1 e8 06 shr eax, 6 - 00070 24 3f and al, 63 ; 0000003fH - 00072 0c 80 or al, -128 ; ffffff80H - 00074 88 45 f5 mov BYTE PTR _TmpBuffer$[ebp+1], al - 00077 8a c1 mov al, cl - 00079 24 3f and al, 63 ; 0000003fH - 0007b 0c 80 or al, -128 ; ffffff80H - 0007d 88 45 f6 mov BYTE PTR _TmpBuffer$[ebp+2], al + 0005d be 03 00 00 00 mov esi, 3 + 00062 c1 e8 0c shr eax, 12 ; 0000000cH + 00065 0c e0 or al, -32 ; ffffffe0H + 00067 88 45 f4 mov BYTE PTR _TmpBuffer$[ebp], al + 0006a 8b c1 mov eax, ecx + 0006c c1 e8 06 shr eax, 6 + 0006f 24 3f and al, 63 ; 0000003fH + 00071 0c 80 or al, -128 ; ffffff80H + 00073 88 45 f5 mov BYTE PTR _TmpBuffer$[ebp+1], al + 00076 8a c1 mov al, cl + 00078 24 3f and al, 63 ; 0000003fH + 0007a 0c 80 or al, -128 ; ffffff80H + 0007c 88 45 f6 mov BYTE PTR _TmpBuffer$[ebp+2], al ; 101 : ; 102 : /* Sanity no special characters */ ; 103 : if (Character == 0xFFFE || Character == 0xFFFF) - 00080 81 f9 fe ff 00 + 0007f 81 f9 fe ff 00 00 cmp ecx, 65534 ; 0000fffeH - 00086 74 08 je SHORT $LN5@StreamChar - 00088 81 f9 ff ff 00 + 00085 74 08 je SHORT $LN5@StreamChar + 00087 81 f9 ff ff 00 00 cmp ecx, 65535 ; 0000ffffH - 0008e 75 5b jne SHORT $LN21@StreamChar + 0008d 75 5b jne SHORT $LN21@StreamChar $LN5@StreamChar: ; 128 : { @@ -3137,128 +3319,128 @@ $LN5@StreamChar: ; 138 : else ; 139 : Error = 1; - 00090 bf 01 00 00 00 mov edi, 1 + 0008f bf 01 00 00 00 mov edi, 1 $LN3@StreamChar: ; 144 : ; 145 : /* We want the length */ ; 146 : *Length = NumBytes; - 00095 8b 45 10 mov eax, DWORD PTR _Length$[ebp] - 00098 89 30 mov DWORD PTR [eax], esi + 00094 8b 45 10 mov eax, DWORD PTR _Length$[ebp] + 00097 89 30 mov DWORD PTR [eax], esi ; 147 : ; 148 : /* Sanity */ ; 149 : if (Error) - 0009a 85 ff test edi, edi - 0009c 0f 84 98 00 00 + 00099 85 ff test edi, edi + 0009b 0f 84 98 00 00 00 je $LN2@StreamChar ; 150 : return -1; - 000a2 5f pop edi - 000a3 83 c8 ff or eax, -1 - 000a6 5e pop esi + 000a1 5f pop edi + 000a2 83 c8 ff or eax, -1 + 000a5 5e pop esi ; 153 : } - 000a7 8b e5 mov esp, ebp - 000a9 5d pop ebp - 000aa c3 ret 0 + 000a6 8b e5 mov esp, ebp + 000a8 5d pop ebp + 000a9 c3 ret 0 $LN14@StreamChar: ; 104 : Error = 1; ; 105 : } ; 106 : else if (Character <= 0x1FFFFF) /* 1111 0XXX four bytes */ - 000ab 81 f9 ff ff 1f + 000aa 81 f9 ff ff 1f 00 cmp ecx, 2097151 ; 001fffffH - 000b1 77 4f ja SHORT $LN10@StreamChar + 000b0 77 4f ja SHORT $LN10@StreamChar ; 107 : { ; 108 : TmpBuffer[0] = (char)(0xF0 | (Character >> 18)); - 000b3 8b c1 mov eax, ecx + 000b2 8b c1 mov eax, ecx ; 109 : TmpBuffer[1] = (char)(0x80 | ((Character >> 12) & 0x3F)); ; 110 : TmpBuffer[2] = (char)(0x80 | ((Character >> 6) & 0x3F)); ; 111 : TmpBuffer[3] = (char)(0x80 | (Character & 0x3F)); ; 112 : NumBytes = 4; - 000b5 be 04 00 00 00 mov esi, 4 - 000ba c1 e8 12 shr eax, 18 ; 00000012H - 000bd 0c f0 or al, -16 ; fffffff0H - 000bf 88 45 f4 mov BYTE PTR _TmpBuffer$[ebp], al - 000c2 8b c1 mov eax, ecx - 000c4 c1 e8 0c shr eax, 12 ; 0000000cH - 000c7 24 3f and al, 63 ; 0000003fH - 000c9 0c 80 or al, -128 ; ffffff80H - 000cb 88 45 f5 mov BYTE PTR _TmpBuffer$[ebp+1], al - 000ce 8b c1 mov eax, ecx - 000d0 c1 e8 06 shr eax, 6 - 000d3 24 3f and al, 63 ; 0000003fH - 000d5 0c 80 or al, -128 ; ffffff80H - 000d7 88 45 f6 mov BYTE PTR _TmpBuffer$[ebp+2], al - 000da 8a c1 mov al, cl - 000dc 24 3f and al, 63 ; 0000003fH - 000de 0c 80 or al, -128 ; ffffff80H - 000e0 88 45 f7 mov BYTE PTR _TmpBuffer$[ebp+3], al + 000b4 be 04 00 00 00 mov esi, 4 + 000b9 c1 e8 12 shr eax, 18 ; 00000012H + 000bc 0c f0 or al, -16 ; fffffff0H + 000be 88 45 f4 mov BYTE PTR _TmpBuffer$[ebp], al + 000c1 8b c1 mov eax, ecx + 000c3 c1 e8 0c shr eax, 12 ; 0000000cH + 000c6 24 3f and al, 63 ; 0000003fH + 000c8 0c 80 or al, -128 ; ffffff80H + 000ca 88 45 f5 mov BYTE PTR _TmpBuffer$[ebp+1], al + 000cd 8b c1 mov eax, ecx + 000cf c1 e8 06 shr eax, 6 + 000d2 24 3f and al, 63 ; 0000003fH + 000d4 0c 80 or al, -128 ; ffffff80H + 000d6 88 45 f6 mov BYTE PTR _TmpBuffer$[ebp+2], al + 000d9 8a c1 mov al, cl + 000db 24 3f and al, 63 ; 0000003fH + 000dd 0c 80 or al, -128 ; ffffff80H + 000df 88 45 f7 mov BYTE PTR _TmpBuffer$[ebp+3], al ; 113 : ; 114 : if (Character > 0x10FFFF) - 000e3 81 f9 ff ff 10 + 000e2 81 f9 ff ff 10 00 cmp ecx, 1114111 ; 0010ffffH - 000e9 77 a5 ja SHORT $LN5@StreamChar + 000e8 77 a5 ja SHORT $LN5@StreamChar $LN21@StreamChar: ; 140 : ; 141 : /* Write buffer only if it's a valid byte sequence */ ; 142 : if (!Error && oBuffer != NULL) - 000eb 8b 45 0c mov eax, DWORD PTR _oBuffer$[ebp] - 000ee 85 c0 test eax, eax - 000f0 74 a3 je SHORT $LN3@StreamChar + 000ea 8b 45 0c mov eax, DWORD PTR _oBuffer$[ebp] + 000ed 85 c0 test eax, eax + 000ef 74 a3 je SHORT $LN3@StreamChar ; 143 : memcpy(oBuffer, BufPtr, NumBytes); - 000f2 56 push esi - 000f3 8d 4d f4 lea ecx, DWORD PTR _TmpBuffer$[ebp] - 000f6 51 push ecx - 000f7 50 push eax - 000f8 e8 00 00 00 00 call _memcpy - 000fd 83 c4 0c add esp, 12 ; 0000000cH - 00100 eb 93 jmp SHORT $LN3@StreamChar + 000f1 56 push esi + 000f2 8d 4d f4 lea ecx, DWORD PTR _TmpBuffer$[ebp] + 000f5 51 push ecx + 000f6 50 push eax + 000f7 e8 00 00 00 00 call _memcpy + 000fc 83 c4 0c add esp, 12 ; 0000000cH + 000ff eb 93 jmp SHORT $LN3@StreamChar $LN10@StreamChar: ; 115 : Error = 1; ; 116 : } ; 117 : else if (Character <= 0x3FFFFFF) /* 1111 10XX five bytes */ - 00102 81 f9 ff ff ff + 00101 81 f9 ff ff ff 03 cmp ecx, 67108863 ; 03ffffffH - 00108 77 12 ja SHORT $LN7@StreamChar + 00107 77 12 ja SHORT $LN7@StreamChar ; 144 : ; 145 : /* We want the length */ ; 146 : *Length = NumBytes; - 0010a 8b 45 10 mov eax, DWORD PTR _Length$[ebp] - 0010d 5f pop edi - 0010e 5e pop esi - 0010f c7 00 05 00 00 + 00109 8b 45 10 mov eax, DWORD PTR _Length$[ebp] + 0010c 5f pop edi + 0010d 5e pop esi + 0010e c7 00 05 00 00 00 mov DWORD PTR [eax], 5 ; 150 : return -1; - 00115 83 c8 ff or eax, -1 + 00114 83 c8 ff or eax, -1 ; 153 : } - 00118 8b e5 mov esp, ebp - 0011a 5d pop ebp - 0011b c3 ret 0 + 00117 8b e5 mov esp, ebp + 00119 5d pop ebp + 0011a c3 ret 0 $LN7@StreamChar: ; 118 : { @@ -3272,44 +3454,44 @@ $LN7@StreamChar: ; 126 : } ; 127 : else if (Character <= 0x7FFFFFFF) /* 1111 110X six bytes */ - 0011c 81 f9 ff ff ff + 0011b 81 f9 ff ff ff 7f cmp ecx, 2147483647 ; 7fffffffH - 00122 0f 87 68 ff ff + 00121 0f 87 68 ff ff ff ja $LN5@StreamChar ; 144 : ; 145 : /* We want the length */ ; 146 : *Length = NumBytes; - 00128 8b 45 10 mov eax, DWORD PTR _Length$[ebp] - 0012b 5f pop edi - 0012c 5e pop esi - 0012d c7 00 06 00 00 + 00127 8b 45 10 mov eax, DWORD PTR _Length$[ebp] + 0012a 5f pop edi + 0012b 5e pop esi + 0012c c7 00 06 00 00 00 mov DWORD PTR [eax], 6 ; 150 : return -1; - 00133 83 c8 ff or eax, -1 + 00132 83 c8 ff or eax, -1 ; 153 : } - 00136 8b e5 mov esp, ebp - 00138 5d pop ebp - 00139 c3 ret 0 + 00135 8b e5 mov esp, ebp + 00137 5d pop ebp + 00138 c3 ret 0 $LN2@StreamChar: - 0013a 5f pop edi + 00139 5f pop edi ; 151 : else ; 152 : return 0; - 0013b 33 c0 xor eax, eax - 0013d 5e pop esi + 0013a 33 c0 xor eax, eax + 0013c 5e pop esi ; 153 : } - 0013e 8b e5 mov esp, ebp - 00140 5d pop ebp - 00141 c3 ret 0 + 0013d 8b e5 mov esp, ebp + 0013f 5d pop ebp + 00140 c3 ret 0 _StreamCharacterToUtf8 ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/strpbrk.cod b/clib/mscv/CLib/strpbrk.cod index e4136a26f..143ffd789 100644 --- a/clib/mscv/CLib/strpbrk.cod +++ b/clib/mscv/CLib/strpbrk.cod @@ -81,7 +81,7 @@ $LL6@strpbrk: 00034 eb 05 jmp SHORT $LN23@strpbrk $LN14@strpbrk: 00036 80 38 00 cmp BYTE PTR [eax], 0 - 00039 75 0f jne SHORT $LN1@strpbrk + 00039 75 11 jne SHORT $LN1@strpbrk $LN23@strpbrk: ; 39 : @@ -101,24 +101,25 @@ $LN23@strpbrk: ; 53 : ; 54 : if (*c == '\0') - 00043 33 c9 xor ecx, ecx - 00045 38 08 cmp BYTE PTR [eax], cl - 00047 0f 44 f1 cmove esi, ecx + 00043 0f be 00 movsx eax, BYTE PTR [eax] + 00046 f7 d8 neg eax + 00048 1b c0 sbb eax, eax + 0004a 23 f0 and esi, eax $LN1@strpbrk: ; 55 : s1 = NULL; ; 56 : ; 57 : return (char *) s1; - 0004a 5f pop edi - 0004b 5b pop ebx - 0004c 8b c6 mov eax, esi - 0004e 5e pop esi + 0004c 5f pop edi + 0004d 5b pop ebx + 0004e 8b c6 mov eax, esi + 00050 5e pop esi ; 58 : } - 0004f 5d pop ebp - 00050 c3 ret 0 + 00051 5d pop ebp + 00052 c3 ret 0 _strpbrk ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/strstr.cod b/clib/mscv/CLib/strstr.cod index 375647084..aa2a357a1 100644 --- a/clib/mscv/CLib/strstr.cod +++ b/clib/mscv/CLib/strstr.cod @@ -18,16 +18,15 @@ EXTRN _strchr:PROC _TEXT SEGMENT _shift_table$ = -1044 ; size = 1024 _haystack_len$2$ = -20 ; size = 4 -tv721 = -16 ; size = 4 -tv720 = -16 ; size = 4 -_period$2$ = -12 ; size = 4 -_period$ = -12 ; size = 4 -_j$1$ = -8 ; size = 4 -_haystack_len$4$ = -8 ; size = 4 -_suffix$1$ = -4 ; size = 4 +tv737 = -16 ; size = 4 +tv736 = -16 ; size = 4 +_suffix$1$ = -12 ; size = 4 +_period$2$ = -8 ; size = 4 +_period$ = -8 ; size = 4 +_j$1$ = -4 ; size = 4 +_haystack_len$4$ = -4 ; size = 4 _haystack$ = 8 ; size = 4 _haystack_len$ = 12 ; size = 4 -tv719 = 16 ; size = 4 _needle$ = 16 ; size = 4 _needle_len$ = 20 ; size = 4 _two_way_long_needle PROC ; COMDAT @@ -52,7 +51,7 @@ _two_way_long_needle PROC ; COMDAT ; 304 : suffix = critical_factorization (needle, needle_len, &period); 0000a 8b 5d 14 mov ebx, DWORD PTR _needle_len$[ebp] - 0000d 8d 45 f4 lea eax, DWORD PTR _period$[ebp] + 0000d 8d 45 f8 lea eax, DWORD PTR _period$[ebp] 00010 56 push esi 00011 57 push edi 00012 50 push eax @@ -72,7 +71,7 @@ _two_way_long_needle PROC ; COMDAT 0001e 8d bd ec fb ff ff lea edi, DWORD PTR _shift_table$[ebp] 00024 b9 00 01 00 00 mov ecx, 256 ; 00000100H - 00029 89 75 fc mov DWORD PTR _suffix$1$[ebp], esi + 00029 89 75 f4 mov DWORD PTR _suffix$1$[ebp], esi 0002c 8b c3 mov eax, ebx 0002e 83 c4 0c add esp, 12 ; 0000000cH 00031 f3 ab rep stosd @@ -104,46 +103,46 @@ $LN24@two_way_lo: ; 316 : first. */ ; 317 : if (CMP_FUNC (needle, needle + period, suffix) == 0) - 00055 8b 55 f4 mov edx, DWORD PTR _period$[ebp] + 00055 8b 55 f8 mov edx, DWORD PTR _period$[ebp] 00058 8b cf mov ecx, edi 0005a 03 d7 add edx, edi 0005c 83 ee 04 sub esi, 4 - 0005f 72 11 jb SHORT $LN73@two_way_lo -$LL74@two_way_lo: + 0005f 72 11 jb SHORT $LN75@two_way_lo +$LL76@two_way_lo: 00061 8b 01 mov eax, DWORD PTR [ecx] 00063 3b 02 cmp eax, DWORD PTR [edx] - 00065 75 14 jne SHORT $LN72@two_way_lo + 00065 75 14 jne SHORT $LN74@two_way_lo 00067 83 c1 04 add ecx, 4 0006a 83 c2 04 add edx, 4 0006d 83 ee 04 sub esi, 4 - 00070 73 ef jae SHORT $LL74@two_way_lo -$LN73@two_way_lo: + 00070 73 ef jae SHORT $LL76@two_way_lo +$LN75@two_way_lo: 00072 83 fe fc cmp esi, -4 ; fffffffcH - 00075 0f 84 1b 01 00 - 00 je $LN71@two_way_lo -$LN72@two_way_lo: + 00075 0f 84 2a 01 00 + 00 je $LN73@two_way_lo +$LN74@two_way_lo: 0007b 8a 01 mov al, BYTE PTR [ecx] 0007d 3a 02 cmp al, BYTE PTR [edx] 0007f 75 37 jne SHORT $LN23@two_way_lo 00081 83 fe fd cmp esi, -3 ; fffffffdH - 00084 0f 84 0c 01 00 - 00 je $LN71@two_way_lo + 00084 0f 84 1b 01 00 + 00 je $LN73@two_way_lo 0008a 8a 41 01 mov al, BYTE PTR [ecx+1] 0008d 3a 42 01 cmp al, BYTE PTR [edx+1] 00090 75 26 jne SHORT $LN23@two_way_lo 00092 83 fe fe cmp esi, -2 ; fffffffeH - 00095 0f 84 fb 00 00 - 00 je $LN71@two_way_lo + 00095 0f 84 0a 01 00 + 00 je $LN73@two_way_lo 0009b 8a 41 02 mov al, BYTE PTR [ecx+2] 0009e 3a 42 02 cmp al, BYTE PTR [edx+2] 000a1 75 15 jne SHORT $LN23@two_way_lo 000a3 83 fe ff cmp esi, -1 - 000a6 0f 84 ea 00 00 - 00 je $LN71@two_way_lo + 000a6 0f 84 f9 00 00 + 00 je $LN73@two_way_lo 000ac 8a 41 03 mov al, BYTE PTR [ecx+3] 000af 3a 42 03 cmp al, BYTE PTR [edx+3] - 000b2 0f 84 de 00 00 - 00 je $LN71@two_way_lo + 000b2 0f 84 ed 00 00 + 00 je $LN73@two_way_lo $LN23@two_way_lo: ; 367 : } @@ -156,187 +155,198 @@ $LN23@two_way_lo: ; 374 : size_t shift; ; 375 : period = MAX (suffix, needle_len - suffix) + 1; - 000b8 8b 55 fc mov edx, DWORD PTR _suffix$1$[ebp] + 000b8 8b 4d f4 mov ecx, DWORD PTR _suffix$1$[ebp] 000bb 8b c3 mov eax, ebx - 000bd 2b c2 sub eax, edx - 000bf 8b ca mov ecx, edx - 000c1 3b d0 cmp edx, eax - 000c3 0f 42 c8 cmovb ecx, eax + 000bd 2b c1 sub eax, ecx + 000bf 3b c8 cmp ecx, eax + 000c1 72 02 jb SHORT $LN35@two_way_lo + 000c3 8b c1 mov eax, ecx +$LN35@two_way_lo: + 000c5 40 inc eax ; 376 : j = 0; 000c6 33 f6 xor esi, esi - 000c8 8d 41 01 lea eax, DWORD PTR [ecx+1] - 000cb 89 45 f4 mov DWORD PTR _period$2$[ebp], eax + 000c8 89 45 f8 mov DWORD PTR _period$2$[ebp], eax ; 377 : while (AVAILABLE (haystack, haystack_len, j, needle_len)) - 000ce 8b c3 mov eax, ebx - 000d0 2b 45 0c sub eax, DWORD PTR _haystack_len$[ebp] - 000d3 50 push eax - 000d4 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] - 000d7 03 45 0c add eax, DWORD PTR _haystack_len$[ebp] - 000da 56 push esi - 000db 50 push eax - 000dc e8 00 00 00 00 call _memchr - 000e1 83 c4 0c add esp, 12 ; 0000000cH - 000e4 85 c0 test eax, eax - 000e6 0f 85 a1 00 00 - 00 jne $LN70@two_way_lo - 000ec 8d 64 24 00 npad 4 + 000cb 8b c3 mov eax, ebx + 000cd 2b 45 0c sub eax, DWORD PTR _haystack_len$[ebp] + 000d0 50 push eax + 000d1 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 000d4 03 45 0c add eax, DWORD PTR _haystack_len$[ebp] + 000d7 56 push esi + 000d8 50 push eax + 000d9 e8 00 00 00 00 call _memchr + 000de 83 c4 0c add esp, 12 ; 0000000cH + 000e1 85 c0 test eax, eax + 000e3 0f 85 b3 00 00 + 00 jne $LN72@two_way_lo + 000e9 8d a4 24 00 00 + 00 00 npad 7 $LL10@two_way_lo: 000f0 8d 04 1e lea eax, DWORD PTR [esi+ebx] - 000f3 89 45 f8 mov DWORD PTR _haystack_len$4$[ebp], eax + 000f3 89 45 fc mov DWORD PTR _haystack_len$4$[ebp], eax 000f6 85 c0 test eax, eax - 000f8 0f 84 8f 00 00 - 00 je $LN70@two_way_lo + 000f8 0f 84 9e 00 00 + 00 je $LN72@two_way_lo ; 378 : { ; 379 : /* Check the last byte first; if it does not match, then ; 380 : shift to the next possible match location. */ ; 381 : shift = shift_table[CANON_ELEMENT (haystack[j + needle_len - 1])]; - 000fe 8b 4d 08 mov ecx, DWORD PTR _haystack$[ebp] - 00101 8d 04 0e lea eax, DWORD PTR [esi+ecx] - 00104 0f b6 44 18 ff movzx eax, BYTE PTR [eax+ebx-1] - 00109 8b 84 85 ec fb + 000fe 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 00101 03 c6 add eax, esi + 00103 0f b6 44 18 ff movzx eax, BYTE PTR [eax+ebx-1] + 00108 8b 84 85 ec fb ff ff mov eax, DWORD PTR _shift_table$[ebp+eax*4] ; 382 : if (0 < shift) - 00110 85 c0 test eax, eax - 00112 75 56 jne SHORT $LN79@two_way_lo + 0010f 85 c0 test eax, eax + 00111 74 04 je SHORT $LN8@two_way_lo ; 383 : { ; 384 : j += shift; + + 00113 03 f0 add esi, eax + ; 385 : continue; + + 00115 eb 64 jmp SHORT $LN1@two_way_lo +$LN8@two_way_lo: + ; 386 : } ; 387 : /* Scan for matches in right half. The last byte has ; 388 : already been matched, by virtue of the shift table. */ ; 389 : i = suffix; - 00114 8b 45 fc mov eax, DWORD PTR _suffix$1$[ebp] + 00117 8b 45 f4 mov eax, DWORD PTR _suffix$1$[ebp] ; 390 : while (i < needle_len - 1 && (CANON_ELEMENT (needle[i]) ; 391 : == CANON_ELEMENT (haystack[i + j]))) - 00117 8d 53 ff lea edx, DWORD PTR [ebx-1] - 0011a 3b d0 cmp edx, eax - 0011c 76 1b jbe SHORT $LN81@two_way_lo - 0011e 03 ce add ecx, esi - 00120 89 4d 10 mov DWORD PTR tv719[ebp], ecx - 00123 8b d9 mov ebx, ecx + 0011a 8d 53 ff lea edx, DWORD PTR [ebx-1] + 0011d 8b c8 mov ecx, eax + 0011f 3b c2 cmp eax, edx + 00121 73 23 jae SHORT $LN6@two_way_lo + 00123 8b 7d 08 mov edi, DWORD PTR _haystack$[ebp] + 00126 8b 5d 10 mov ebx, DWORD PTR _needle$[ebp] + 00129 03 fe add edi, esi + 0012b eb 03 8d 49 00 npad 5 $LL7@two_way_lo: - 00125 8a 0c 38 mov cl, BYTE PTR [eax+edi] - 00128 3a 0c 03 cmp cl, BYTE PTR [ebx+eax] - 0012b 75 05 jne SHORT $LN75@two_way_lo + 00130 8a 04 19 mov al, BYTE PTR [ecx+ebx] + 00133 3a 04 0f cmp al, BYTE PTR [edi+ecx] + 00136 75 05 jne SHORT $LN77@two_way_lo ; 392 : ++i; - 0012d 40 inc eax - 0012e 3b c2 cmp eax, edx - 00130 72 f3 jb SHORT $LL7@two_way_lo -$LN75@two_way_lo: - 00132 8b 5d 14 mov ebx, DWORD PTR _needle_len$[ebp] + 00138 41 inc ecx + 00139 3b ca cmp ecx, edx + 0013b 72 f3 jb SHORT $LL7@two_way_lo +$LN77@two_way_lo: + 0013d 8b 5d 14 mov ebx, DWORD PTR _needle_len$[ebp] + 00140 8b 7d 10 mov edi, DWORD PTR _needle$[ebp] + 00143 8b 45 f4 mov eax, DWORD PTR _suffix$1$[ebp] +$LN6@two_way_lo: ; 393 : if (needle_len - 1 <= i) - 00135 3b d0 cmp edx, eax - 00137 77 2d ja SHORT $LN5@two_way_lo -$LN81@two_way_lo: + 00146 3b d1 cmp edx, ecx + 00148 77 2c ja SHORT $LN5@two_way_lo ; 394 : { ; 395 : /* Scan for matches in left half. */ ; 396 : i = suffix - 1; - 00139 8b 4d fc mov ecx, DWORD PTR _suffix$1$[ebp] - 0013c 49 dec ecx + 0014a 8d 48 ff lea ecx, DWORD PTR [eax-1] ; 397 : while (i != SIZE_MAX && (CANON_ELEMENT (needle[i]) ; 398 : == CANON_ELEMENT (haystack[i + j]))) - 0013d 83 f9 ff cmp ecx, -1 - 00140 74 13 je SHORT $LN45@two_way_lo - 00142 8b 55 08 mov edx, DWORD PTR _haystack$[ebp] - 00145 03 d6 add edx, esi + 0014d 83 f9 ff cmp ecx, -1 + 00150 74 13 je SHORT $LN47@two_way_lo + 00152 8b 55 08 mov edx, DWORD PTR _haystack$[ebp] + 00155 03 d6 add edx, esi $LL4@two_way_lo: - 00147 8a 04 39 mov al, BYTE PTR [ecx+edi] - 0014a 3a 04 0a cmp al, BYTE PTR [edx+ecx] - 0014d 75 12 jne SHORT $LN3@two_way_lo + 00157 8a 04 39 mov al, BYTE PTR [ecx+edi] + 0015a 3a 04 0a cmp al, BYTE PTR [edx+ecx] + 0015d 75 12 jne SHORT $LN3@two_way_lo ; 399 : --i; - 0014f 49 dec ecx - 00150 83 f9 ff cmp ecx, -1 - 00153 75 f2 jne SHORT $LL4@two_way_lo -$LN45@two_way_lo: + 0015f 49 dec ecx + 00160 83 f9 ff cmp ecx, -1 + 00163 75 f2 jne SHORT $LL4@two_way_lo +$LN47@two_way_lo: ; 400 : if (i == SIZE_MAX) ; 401 : return (RETURN_TYPE) (haystack + j); - 00155 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] - 00158 5f pop edi - 00159 03 c6 add eax, esi - 0015b 5e pop esi - 0015c 5b pop ebx + 00165 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 00168 5f pop edi + 00169 03 c6 add eax, esi + 0016b 5e pop esi + 0016c 5b pop ebx ; 409 : } - 0015d 8b e5 mov esp, ebp - 0015f 5d pop ebp - 00160 c3 ret 0 + 0016d 8b e5 mov esp, ebp + 0016f 5d pop ebp + 00170 c3 ret 0 $LN3@two_way_lo: ; 402 : j += period; - 00161 03 75 f4 add esi, DWORD PTR _period$2$[ebp] + 00171 03 75 f8 add esi, DWORD PTR _period$2$[ebp] ; 403 : } ; 404 : else - 00164 eb 06 jmp SHORT $LN1@two_way_lo + 00174 eb 05 jmp SHORT $LN1@two_way_lo $LN5@two_way_lo: ; 405 : j += i - suffix + 1; - 00166 2b 45 fc sub eax, DWORD PTR _suffix$1$[ebp] - 00169 46 inc esi -$LN79@two_way_lo: - 0016a 03 f0 add esi, eax + 00176 2b c8 sub ecx, eax + 00178 46 inc esi + 00179 03 f1 add esi, ecx $LN1@two_way_lo: ; 377 : while (AVAILABLE (haystack, haystack_len, j, needle_len)) - 0016c 8b c6 mov eax, esi - 0016e 2b 45 f8 sub eax, DWORD PTR _haystack_len$4$[ebp] - 00171 03 c3 add eax, ebx - 00173 50 push eax - 00174 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] - 00177 03 45 f8 add eax, DWORD PTR _haystack_len$4$[ebp] - 0017a 6a 00 push 0 - 0017c 50 push eax - 0017d e8 00 00 00 00 call _memchr - 00182 83 c4 0c add esp, 12 ; 0000000cH - 00185 85 c0 test eax, eax - 00187 0f 84 63 ff ff + 0017b 8b c6 mov eax, esi + 0017d 2b 45 fc sub eax, DWORD PTR _haystack_len$4$[ebp] + 00180 03 c3 add eax, ebx + 00182 50 push eax + 00183 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 00186 03 45 fc add eax, DWORD PTR _haystack_len$4$[ebp] + 00189 6a 00 push 0 + 0018b 50 push eax + 0018c e8 00 00 00 00 call _memchr + 00191 83 c4 0c add esp, 12 ; 0000000cH + 00194 85 c0 test eax, eax + 00196 0f 84 54 ff ff ff je $LL10@two_way_lo -$LN70@two_way_lo: - 0018d 5f pop edi - 0018e 5e pop esi +$LN72@two_way_lo: + 0019c 5f pop edi + 0019d 5e pop esi ; 406 : } ; 407 : } ; 408 : return NULL; - 0018f 33 c0 xor eax, eax - 00191 5b pop ebx + 0019e 33 c0 xor eax, eax + 001a0 5b pop ebx ; 409 : } - 00192 8b e5 mov esp, ebp - 00194 5d pop ebp - 00195 c3 ret 0 -$LN71@two_way_lo: + 001a1 8b e5 mov esp, ebp + 001a3 5d pop ebp + 001a4 c3 ret 0 +$LN73@two_way_lo: ; 318 : { ; 319 : /* Entire needle is periodic; a mismatch can only advance by the @@ -347,50 +357,50 @@ $LN71@two_way_lo: ; 324 : j = 0; ; 325 : while (AVAILABLE (haystack, haystack_len, j, needle_len)) - 00196 8b c3 mov eax, ebx - 00198 33 ff xor edi, edi - 0019a 2b 45 0c sub eax, DWORD PTR _haystack_len$[ebp] - 0019d 33 f6 xor esi, esi - 0019f 50 push eax - 001a0 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] - 001a3 03 45 0c add eax, DWORD PTR _haystack_len$[ebp] - 001a6 57 push edi - 001a7 50 push eax - 001a8 89 7d f8 mov DWORD PTR _j$1$[ebp], edi - 001ab e8 00 00 00 00 call _memchr - 001b0 83 c4 0c add esp, 12 ; 0000000cH - 001b3 85 c0 test eax, eax - 001b5 75 d6 jne SHORT $LN70@two_way_lo + 001a5 8b c3 mov eax, ebx + 001a7 33 ff xor edi, edi + 001a9 2b 45 0c sub eax, DWORD PTR _haystack_len$[ebp] + 001ac 33 f6 xor esi, esi + 001ae 50 push eax + 001af 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 001b2 03 45 0c add eax, DWORD PTR _haystack_len$[ebp] + 001b5 57 push edi + 001b6 50 push eax + 001b7 89 7d fc mov DWORD PTR _j$1$[ebp], edi + 001ba e8 00 00 00 00 call _memchr + 001bf 83 c4 0c add esp, 12 ; 0000000cH + 001c2 85 c0 test eax, eax + 001c4 75 d6 jne SHORT $LN72@two_way_lo $LL22@two_way_lo: - 001b7 8d 04 1f lea eax, DWORD PTR [edi+ebx] - 001ba 89 45 ec mov DWORD PTR _haystack_len$2$[ebp], eax - 001bd 85 c0 test eax, eax - 001bf 74 cc je SHORT $LN70@two_way_lo + 001c6 8d 04 1f lea eax, DWORD PTR [edi+ebx] + 001c9 89 45 ec mov DWORD PTR _haystack_len$2$[ebp], eax + 001cc 85 c0 test eax, eax + 001ce 74 cc je SHORT $LN72@two_way_lo ; 326 : { ; 327 : /* Check the last byte first; if it does not match, then ; 328 : shift to the next possible match location. */ ; 329 : shift = shift_table[CANON_ELEMENT (haystack[j + needle_len - 1])]; - 001c1 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] - 001c4 03 c7 add eax, edi - 001c6 0f b6 44 18 ff movzx eax, BYTE PTR [eax+ebx-1] - 001cb 8b 84 85 ec fb + 001d0 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 001d3 03 c7 add eax, edi + 001d5 0f b6 44 18 ff movzx eax, BYTE PTR [eax+ebx-1] + 001da 8b 84 85 ec fb ff ff mov eax, DWORD PTR _shift_table$[ebp+eax*4] ; 330 : if (0 < shift) - 001d2 85 c0 test eax, eax - 001d4 74 18 je SHORT $LN20@two_way_lo + 001e1 85 c0 test eax, eax + 001e3 74 18 je SHORT $LN20@two_way_lo ; 331 : { ; 332 : if (memory && shift < period) - 001d6 85 f6 test esi, esi - 001d8 74 0b je SHORT $LN19@two_way_lo - 001da 8b 4d f4 mov ecx, DWORD PTR _period$[ebp] - 001dd 3b c1 cmp eax, ecx - 001df 73 04 jae SHORT $LN19@two_way_lo + 001e5 85 f6 test esi, esi + 001e7 74 0b je SHORT $LN19@two_way_lo + 001e9 8b 4d f8 mov ecx, DWORD PTR _period$[ebp] + 001ec 3b c1 cmp eax, ecx + 001ee 73 04 jae SHORT $LN19@two_way_lo ; 333 : { ; 334 : /* Since needle is periodic, but the last period has @@ -398,22 +408,22 @@ $LL22@two_way_lo: ; 336 : after the mismatch. */ ; 337 : shift = needle_len - period; - 001e1 8b c3 mov eax, ebx - 001e3 2b c1 sub eax, ecx + 001f0 8b c3 mov eax, ebx + 001f2 2b c1 sub eax, ecx $LN19@two_way_lo: ; 338 : } ; 339 : memory = 0; - 001e5 33 f6 xor esi, esi + 001f4 33 f6 xor esi, esi ; 340 : j += shift; - 001e7 03 f8 add edi, eax + 001f6 03 f8 add edi, eax ; 341 : continue; - 001e9 e9 83 00 00 00 jmp $LN82@two_way_lo + 001f8 e9 84 00 00 00 jmp $LN81@two_way_lo $LN20@two_way_lo: ; 342 : } @@ -421,160 +431,162 @@ $LN20@two_way_lo: ; 344 : already been matched, by virtue of the shift table. */ ; 345 : i = MAX (suffix, memory); - 001ee 8b 45 fc mov eax, DWORD PTR _suffix$1$[ebp] + 001fd 8b 45 f4 mov eax, DWORD PTR _suffix$1$[ebp] + 00200 8b ce mov ecx, esi + 00202 3b c6 cmp eax, esi + 00204 72 02 jb SHORT $LN33@two_way_lo + 00206 8b c8 mov ecx, eax +$LN33@two_way_lo: ; 346 : while (i < needle_len - 1 && (CANON_ELEMENT (needle[i]) ; 347 : == CANON_ELEMENT (haystack[i + j]))) - 001f1 8d 53 ff lea edx, DWORD PTR [ebx-1] - 001f4 3b c6 cmp eax, esi - 001f6 8b c8 mov ecx, eax - 001f8 0f 42 ce cmovb ecx, esi - 001fb 3b d1 cmp edx, ecx - 001fd 76 2b jbe SHORT $LN84@two_way_lo - 001ff 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] - 00202 8b 5d 10 mov ebx, DWORD PTR _needle$[ebp] - 00205 03 c7 add eax, edi - 00207 89 45 f0 mov DWORD PTR tv721[ebp], eax - 0020a 8b f8 mov edi, eax - 0020c 8d 64 24 00 npad 4 + 00208 8d 53 ff lea edx, DWORD PTR [ebx-1] + 0020b 3b d1 cmp edx, ecx + 0020d 76 2b jbe SHORT $LN83@two_way_lo + 0020f 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 00212 03 c7 add eax, edi + 00214 8b 7d 10 mov edi, DWORD PTR _needle$[ebp] + 00217 89 45 f0 mov DWORD PTR tv737[ebp], eax + 0021a 8b d8 mov ebx, eax + 0021c 8d 64 24 00 npad 4 $LL18@two_way_lo: - 00210 8a 04 19 mov al, BYTE PTR [ecx+ebx] - 00213 3a 04 0f cmp al, BYTE PTR [edi+ecx] - 00216 75 05 jne SHORT $LN76@two_way_lo + 00220 8a 04 39 mov al, BYTE PTR [ecx+edi] + 00223 3a 04 0b cmp al, BYTE PTR [ebx+ecx] + 00226 75 05 jne SHORT $LN78@two_way_lo ; 348 : ++i; - 00218 41 inc ecx - 00219 3b ca cmp ecx, edx - 0021b 72 f3 jb SHORT $LL18@two_way_lo -$LN76@two_way_lo: - 0021d 8b 7d f8 mov edi, DWORD PTR _j$1$[ebp] - 00220 8b 5d 14 mov ebx, DWORD PTR _needle_len$[ebp] - 00223 8b 45 fc mov eax, DWORD PTR _suffix$1$[ebp] + 00228 41 inc ecx + 00229 3b ca cmp ecx, edx + 0022b 72 f3 jb SHORT $LL18@two_way_lo +$LN78@two_way_lo: + 0022d 8b 7d fc mov edi, DWORD PTR _j$1$[ebp] + 00230 8b 5d 14 mov ebx, DWORD PTR _needle_len$[ebp] + 00233 8b 45 f4 mov eax, DWORD PTR _suffix$1$[ebp] ; 349 : if (needle_len - 1 <= i) - 00226 3b d1 cmp edx, ecx - 00228 77 40 ja SHORT $LN16@two_way_lo -$LN84@two_way_lo: + 00236 3b d1 cmp edx, ecx + 00238 77 40 ja SHORT $LN16@two_way_lo +$LN83@two_way_lo: ; 350 : { ; 351 : /* Scan for matches in left half. */ ; 352 : i = suffix - 1; - 0022a 8d 50 ff lea edx, DWORD PTR [eax-1] + 0023a 8d 50 ff lea edx, DWORD PTR [eax-1] ; 353 : while (memory < i + 1 && (CANON_ELEMENT (needle[i]) ; 354 : == CANON_ELEMENT (haystack[i + j]))) - 0022d 8d 4a 01 lea ecx, DWORD PTR [edx+1] - 00230 3b f1 cmp esi, ecx - 00232 73 22 jae SHORT $LN14@two_way_lo - 00234 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] - 00237 8b 5d 10 mov ebx, DWORD PTR _needle$[ebp] - 0023a 03 c7 add eax, edi - 0023c 89 45 f0 mov DWORD PTR tv720[ebp], eax - 0023f 8b f8 mov edi, eax + 0023d 8d 4a 01 lea ecx, DWORD PTR [edx+1] + 00240 3b f1 cmp esi, ecx + 00242 73 22 jae SHORT $LN14@two_way_lo + 00244 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 00247 8b 5d 10 mov ebx, DWORD PTR _needle$[ebp] + 0024a 03 c7 add eax, edi + 0024c 89 45 f0 mov DWORD PTR tv736[ebp], eax + 0024f 8b f8 mov edi, eax $LL15@two_way_lo: - 00241 8a 44 0b ff mov al, BYTE PTR [ebx+ecx-1] - 00245 3a 04 17 cmp al, BYTE PTR [edi+edx] - 00248 75 06 jne SHORT $LN77@two_way_lo + 00251 8a 44 0b ff mov al, BYTE PTR [ebx+ecx-1] + 00255 3a 04 17 cmp al, BYTE PTR [edi+edx] + 00258 75 06 jne SHORT $LN79@two_way_lo ; 355 : --i; - 0024a 49 dec ecx - 0024b 4a dec edx - 0024c 3b f1 cmp esi, ecx - 0024e 72 f1 jb SHORT $LL15@two_way_lo -$LN77@two_way_lo: - 00250 8b 7d f8 mov edi, DWORD PTR _j$1$[ebp] - 00253 8b 5d 14 mov ebx, DWORD PTR _needle_len$[ebp] + 0025a 49 dec ecx + 0025b 4a dec edx + 0025c 3b f1 cmp esi, ecx + 0025e 72 f1 jb SHORT $LL15@two_way_lo +$LN79@two_way_lo: + 00260 8b 7d fc mov edi, DWORD PTR _j$1$[ebp] + 00263 8b 5d 14 mov ebx, DWORD PTR _needle_len$[ebp] $LN14@two_way_lo: ; 356 : if (i + 1 < memory + 1) - 00256 8d 4e 01 lea ecx, DWORD PTR [esi+1] - 00259 8d 42 01 lea eax, DWORD PTR [edx+1] - 0025c 3b c1 cmp eax, ecx - 0025e 72 3e jb SHORT $LN44@two_way_lo + 00266 8d 4e 01 lea ecx, DWORD PTR [esi+1] + 00269 8d 42 01 lea eax, DWORD PTR [edx+1] + 0026c 3b c1 cmp eax, ecx + 0026e 72 3e jb SHORT $LN46@two_way_lo ; 358 : /* No match, so remember how many repetitions of period ; 359 : on the right half were scanned. */ ; 360 : j += period; - 00260 03 7d f4 add edi, DWORD PTR _period$[ebp] + 00270 03 7d f8 add edi, DWORD PTR _period$[ebp] ; 361 : memory = needle_len - period; - 00263 8b f3 mov esi, ebx - 00265 2b 75 f4 sub esi, DWORD PTR _period$[ebp] + 00273 8b f3 mov esi, ebx + 00275 2b 75 f8 sub esi, DWORD PTR _period$[ebp] ; 362 : } ; 363 : else - 00268 eb 07 jmp SHORT $LN82@two_way_lo + 00278 eb 07 jmp SHORT $LN81@two_way_lo $LN16@two_way_lo: ; 364 : { ; 365 : j += i - suffix + 1; - 0026a 2b c8 sub ecx, eax - 0026c 47 inc edi - 0026d 03 f9 add edi, ecx + 0027a 2b c8 sub ecx, eax + 0027c 47 inc edi + 0027d 03 f9 add edi, ecx ; 366 : memory = 0; - 0026f 33 f6 xor esi, esi -$LN82@two_way_lo: + 0027f 33 f6 xor esi, esi +$LN81@two_way_lo: ; 364 : { ; 365 : j += i - suffix + 1; - 00271 8b c7 mov eax, edi - 00273 89 7d f8 mov DWORD PTR _j$1$[ebp], edi - 00276 2b 45 ec sub eax, DWORD PTR _haystack_len$2$[ebp] - 00279 03 c3 add eax, ebx - 0027b 50 push eax - 0027c 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] - 0027f 03 45 ec add eax, DWORD PTR _haystack_len$2$[ebp] - 00282 6a 00 push 0 - 00284 50 push eax - 00285 e8 00 00 00 00 call _memchr - 0028a 83 c4 0c add esp, 12 ; 0000000cH - 0028d 85 c0 test eax, eax - 0028f 0f 84 22 ff ff + 00281 8b c7 mov eax, edi + 00283 89 7d fc mov DWORD PTR _j$1$[ebp], edi + 00286 2b 45 ec sub eax, DWORD PTR _haystack_len$2$[ebp] + 00289 03 c3 add eax, ebx + 0028b 50 push eax + 0028c 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 0028f 03 45 ec add eax, DWORD PTR _haystack_len$2$[ebp] + 00292 6a 00 push 0 + 00294 50 push eax + 00295 e8 00 00 00 00 call _memchr + 0029a 83 c4 0c add esp, 12 ; 0000000cH + 0029d 85 c0 test eax, eax + 0029f 0f 84 21 ff ff ff je $LL22@two_way_lo ; 406 : } ; 407 : } ; 408 : return NULL; - 00295 5f pop edi - 00296 5e pop esi - 00297 33 c0 xor eax, eax - 00299 5b pop ebx + 002a5 5f pop edi + 002a6 5e pop esi + 002a7 33 c0 xor eax, eax + 002a9 5b pop ebx ; 409 : } - 0029a 8b e5 mov esp, ebp - 0029c 5d pop ebp - 0029d c3 ret 0 -$LN44@two_way_lo: + 002aa 8b e5 mov esp, ebp + 002ac 5d pop ebp + 002ad c3 ret 0 +$LN46@two_way_lo: ; 357 : return (RETURN_TYPE) (haystack + j); - 0029e 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] - 002a1 03 c7 add eax, edi - 002a3 5f pop edi - 002a4 5e pop esi - 002a5 5b pop ebx + 002ae 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 002b1 03 c7 add eax, edi + 002b3 5f pop edi + 002b4 5e pop esi + 002b5 5b pop ebx ; 409 : } - 002a6 8b e5 mov esp, ebp - 002a8 5d pop ebp - 002a9 c3 ret 0 + 002b6 8b e5 mov esp, ebp + 002b8 5d pop ebp + 002b9 c3 ret 0 _two_way_long_needle ENDP _TEXT ENDS ; Function compile flags: /Ogtp @@ -582,7 +594,7 @@ _TEXT ENDS ; COMDAT _two_way_short_needle _TEXT SEGMENT _haystack_len$2$ = -20 ; size = 4 -tv549 = -16 ; size = 4 +tv565 = -16 ; size = 4 _haystack_len$4$ = -12 ; size = 4 _period$ = -12 ; size = 4 _j$1$ = -8 ; size = 4 @@ -633,43 +645,43 @@ _two_way_short_needle PROC ; COMDAT 00025 03 d3 add edx, ebx 00027 8b cb mov ecx, ebx 00029 83 ef 04 sub edi, 4 - 0002c 72 13 jb SHORT $LN55@two_way_sh + 0002c 72 13 jb SHORT $LN57@two_way_sh 0002e 8b ff npad 2 -$LL56@two_way_sh: +$LL58@two_way_sh: 00030 8b 01 mov eax, DWORD PTR [ecx] 00032 3b 02 cmp eax, DWORD PTR [edx] - 00034 75 14 jne SHORT $LN54@two_way_sh + 00034 75 14 jne SHORT $LN56@two_way_sh 00036 83 c1 04 add ecx, 4 00039 83 c2 04 add edx, 4 0003c 83 ef 04 sub edi, 4 - 0003f 73 ef jae SHORT $LL56@two_way_sh -$LN55@two_way_sh: + 0003f 73 ef jae SHORT $LL58@two_way_sh +$LN57@two_way_sh: 00041 83 ff fc cmp edi, -4 ; fffffffcH - 00044 0f 84 f6 00 00 - 00 je $LN53@two_way_sh -$LN54@two_way_sh: + 00044 0f 84 f9 00 00 + 00 je $LN55@two_way_sh +$LN56@two_way_sh: 0004a 8a 01 mov al, BYTE PTR [ecx] 0004c 3a 02 cmp al, BYTE PTR [edx] 0004e 75 37 jne SHORT $LN20@two_way_sh 00050 83 ff fd cmp edi, -3 ; fffffffdH - 00053 0f 84 e7 00 00 - 00 je $LN53@two_way_sh + 00053 0f 84 ea 00 00 + 00 je $LN55@two_way_sh 00059 8a 41 01 mov al, BYTE PTR [ecx+1] 0005c 3a 42 01 cmp al, BYTE PTR [edx+1] 0005f 75 26 jne SHORT $LN20@two_way_sh 00061 83 ff fe cmp edi, -2 ; fffffffeH - 00064 0f 84 d6 00 00 - 00 je $LN53@two_way_sh + 00064 0f 84 d9 00 00 + 00 je $LN55@two_way_sh 0006a 8a 41 02 mov al, BYTE PTR [ecx+2] 0006d 3a 42 02 cmp al, BYTE PTR [edx+2] 00070 75 15 jne SHORT $LN20@two_way_sh 00072 83 ff ff cmp edi, -1 - 00075 0f 84 c5 00 00 - 00 je $LN53@two_way_sh + 00075 0f 84 c8 00 00 + 00 je $LN55@two_way_sh 0007b 8a 41 03 mov al, BYTE PTR [ecx+3] 0007e 3a 42 03 cmp al, BYTE PTR [edx+3] - 00081 0f 84 b9 00 00 - 00 je $LN53@two_way_sh + 00081 0f 84 bc 00 00 + 00 je $LN55@two_way_sh $LN20@two_way_sh: ; 245 : } @@ -681,158 +693,161 @@ $LN20@two_way_sh: ; 251 : required, and any mismatch results in a maximal shift. */ ; 252 : period = MAX (suffix, needle_len - suffix) + 1; - 00087 8b 55 fc mov edx, DWORD PTR _suffix$1$[ebp] + 00087 8b 4d fc mov ecx, DWORD PTR _suffix$1$[ebp] 0008a 8b c6 mov eax, esi - 0008c 2b c2 sub eax, edx - 0008e 8b ca mov ecx, edx - 00090 3b d0 cmp edx, eax - 00092 0f 42 c8 cmovb ecx, eax + 0008c 2b c1 sub eax, ecx + 0008e 3b c8 cmp ecx, eax + 00090 72 02 jb SHORT $LN26@two_way_sh + 00092 8b c1 mov eax, ecx +$LN26@two_way_sh: + 00094 40 inc eax ; 253 : j = 0; 00095 33 ff xor edi, edi - 00097 8d 41 01 lea eax, DWORD PTR [ecx+1] - 0009a 89 45 10 mov DWORD PTR _period$2$[ebp], eax + 00097 89 45 10 mov DWORD PTR _period$2$[ebp], eax ; 254 : while (AVAILABLE (haystack, haystack_len, j, needle_len)) - 0009d 8b c6 mov eax, esi - 0009f 2b 45 0c sub eax, DWORD PTR _haystack_len$[ebp] - 000a2 50 push eax - 000a3 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] - 000a6 03 45 0c add eax, DWORD PTR _haystack_len$[ebp] - 000a9 57 push edi - 000aa 50 push eax - 000ab e8 00 00 00 00 call _memchr - 000b0 83 c4 0c add esp, 12 ; 0000000cH - 000b3 85 c0 test eax, eax - 000b5 0f 85 7c 00 00 + 0009a 8b c6 mov eax, esi + 0009c 2b 45 0c sub eax, DWORD PTR _haystack_len$[ebp] + 0009f 50 push eax + 000a0 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 000a3 03 45 0c add eax, DWORD PTR _haystack_len$[ebp] + 000a6 57 push edi + 000a7 50 push eax + 000a8 e8 00 00 00 00 call _memchr + 000ad 83 c4 0c add esp, 12 ; 0000000cH + 000b0 85 c0 test eax, eax + 000b2 0f 85 82 00 00 00 jne $LN8@two_way_sh - 000bb eb 03 8d 49 00 npad 5 $LL9@two_way_sh: - 000c0 8d 04 37 lea eax, DWORD PTR [edi+esi] - 000c3 89 45 f4 mov DWORD PTR _haystack_len$4$[ebp], eax - 000c6 85 c0 test eax, eax - 000c8 74 6d je SHORT $LN8@two_way_sh + 000b8 8d 04 37 lea eax, DWORD PTR [edi+esi] + 000bb 89 45 f4 mov DWORD PTR _haystack_len$4$[ebp], eax + 000be 85 c0 test eax, eax + 000c0 74 78 je SHORT $LN8@two_way_sh ; 255 : { ; 256 : /* Scan for matches in right half. */ ; 257 : i = suffix; - 000ca 8b 45 fc mov eax, DWORD PTR _suffix$1$[ebp] + 000c2 8b 45 fc mov eax, DWORD PTR _suffix$1$[ebp] ; 258 : while (i < needle_len && (CANON_ELEMENT (needle[i]) ; 259 : == CANON_ELEMENT (haystack[i + j]))) - 000cd 3b c6 cmp eax, esi - 000cf 73 12 jae SHORT $LN49@two_way_sh - 000d1 8b 55 08 mov edx, DWORD PTR _haystack$[ebp] - 000d4 03 d7 add edx, edi + 000c5 3b c6 cmp eax, esi + 000c7 73 14 jae SHORT $LN51@two_way_sh + 000c9 8b 55 08 mov edx, DWORD PTR _haystack$[ebp] + 000cc 03 d7 add edx, edi + 000ce 8b ff npad 2 $LL7@two_way_sh: - 000d6 8a 0c 18 mov cl, BYTE PTR [eax+ebx] - 000d9 3a 0c 02 cmp cl, BYTE PTR [edx+eax] - 000dc 75 2d jne SHORT $LN6@two_way_sh + 000d0 8a 0c 18 mov cl, BYTE PTR [eax+ebx] + 000d3 3a 0c 02 cmp cl, BYTE PTR [edx+eax] + 000d6 75 32 jne SHORT $LN6@two_way_sh ; 260 : ++i; - 000de 40 inc eax - 000df 3b c6 cmp eax, esi - 000e1 72 f3 jb SHORT $LL7@two_way_sh -$LN49@two_way_sh: + 000d8 40 inc eax + 000d9 3b c6 cmp eax, esi + 000db 72 f3 jb SHORT $LL7@two_way_sh +$LN51@two_way_sh: ; 262 : { ; 263 : /* Scan for matches in left half. */ ; 264 : i = suffix - 1; - 000e3 8b 4d fc mov ecx, DWORD PTR _suffix$1$[ebp] - 000e6 49 dec ecx + 000dd 8b 4d fc mov ecx, DWORD PTR _suffix$1$[ebp] + 000e0 49 dec ecx ; 265 : while (i != SIZE_MAX && (CANON_ELEMENT (needle[i]) ; 266 : == CANON_ELEMENT (haystack[i + j]))) - 000e7 83 f9 ff cmp ecx, -1 - 000ea 74 13 je SHORT $LN32@two_way_sh - 000ec 8b 55 08 mov edx, DWORD PTR _haystack$[ebp] - 000ef 03 d7 add edx, edi + 000e1 83 f9 ff cmp ecx, -1 + 000e4 74 18 je SHORT $LN34@two_way_sh + 000e6 8b 55 08 mov edx, DWORD PTR _haystack$[ebp] + 000e9 03 d7 add edx, edi + 000eb eb 03 8d 49 00 npad 5 $LL4@two_way_sh: - 000f1 8a 04 19 mov al, BYTE PTR [ecx+ebx] - 000f4 3a 04 0a cmp al, BYTE PTR [edx+ecx] - 000f7 75 1e jne SHORT $LN3@two_way_sh + 000f0 8a 04 19 mov al, BYTE PTR [ecx+ebx] + 000f3 3a 04 0a cmp al, BYTE PTR [edx+ecx] + 000f6 75 1e jne SHORT $LN3@two_way_sh ; 267 : --i; - 000f9 49 dec ecx - 000fa 83 f9 ff cmp ecx, -1 - 000fd 75 f2 jne SHORT $LL4@two_way_sh -$LN32@two_way_sh: + 000f8 49 dec ecx + 000f9 83 f9 ff cmp ecx, -1 + 000fc 75 f2 jne SHORT $LL4@two_way_sh +$LN34@two_way_sh: ; 268 : if (i == SIZE_MAX) ; 269 : return (RETURN_TYPE) (haystack + j); - 000ff 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] - 00102 03 c7 add eax, edi - 00104 5f pop edi - 00105 5e pop esi - 00106 5b pop ebx + 000fe 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 00101 03 c7 add eax, edi + 00103 5f pop edi + 00104 5e pop esi + 00105 5b pop ebx ; 277 : } - 00107 8b e5 mov esp, ebp - 00109 5d pop ebp - 0010a c3 ret 0 + 00106 8b e5 mov esp, ebp + 00108 5d pop ebp + 00109 c3 ret 0 $LN6@two_way_sh: ; 261 : if (needle_len <= i) - 0010b 3b f0 cmp esi, eax - 0010d 76 d4 jbe SHORT $LN49@two_way_sh + 0010a 3b f0 cmp esi, eax + 0010c 76 cf jbe SHORT $LN51@two_way_sh ; 271 : } ; 272 : else ; 273 : j += i - suffix + 1; - 0010f 2b 45 fc sub eax, DWORD PTR _suffix$1$[ebp] - 00112 47 inc edi - 00113 03 f8 add edi, eax - 00115 eb 03 jmp SHORT $LN1@two_way_sh + 0010e 2b 45 fc sub eax, DWORD PTR _suffix$1$[ebp] + 00111 47 inc edi + 00112 03 f8 add edi, eax + 00114 eb 03 jmp SHORT $LN1@two_way_sh $LN3@two_way_sh: ; 270 : j += period; - 00117 03 7d 10 add edi, DWORD PTR _period$2$[ebp] + 00116 03 7d 10 add edi, DWORD PTR _period$2$[ebp] $LN1@two_way_sh: ; 254 : while (AVAILABLE (haystack, haystack_len, j, needle_len)) - 0011a 8b c7 mov eax, edi - 0011c 2b 45 f4 sub eax, DWORD PTR _haystack_len$4$[ebp] - 0011f 03 c6 add eax, esi - 00121 50 push eax - 00122 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] - 00125 03 45 f4 add eax, DWORD PTR _haystack_len$4$[ebp] - 00128 6a 00 push 0 - 0012a 50 push eax - 0012b e8 00 00 00 00 call _memchr - 00130 83 c4 0c add esp, 12 ; 0000000cH - 00133 85 c0 test eax, eax - 00135 74 89 je SHORT $LL9@two_way_sh + 00119 8b c7 mov eax, edi + 0011b 2b 45 f4 sub eax, DWORD PTR _haystack_len$4$[ebp] + 0011e 03 c6 add eax, esi + 00120 50 push eax + 00121 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 00124 03 45 f4 add eax, DWORD PTR _haystack_len$4$[ebp] + 00127 6a 00 push 0 + 00129 50 push eax + 0012a e8 00 00 00 00 call _memchr + 0012f 83 c4 0c add esp, 12 ; 0000000cH + 00132 85 c0 test eax, eax + 00134 0f 84 7e ff ff + ff je $LL9@two_way_sh $LN8@two_way_sh: - 00137 5f pop edi - 00138 5e pop esi + 0013a 5f pop edi + 0013b 5e pop esi ; 274 : } ; 275 : } ; 276 : return NULL; - 00139 33 c0 xor eax, eax - 0013b 5b pop ebx + 0013c 33 c0 xor eax, eax + 0013e 5b pop ebx ; 277 : } - 0013c 8b e5 mov esp, ebp - 0013e 5d pop ebp - 0013f c3 ret 0 -$LN53@two_way_sh: + 0013f 8b e5 mov esp, ebp + 00141 5d pop ebp + 00142 c3 ret 0 +$LN55@two_way_sh: ; 214 : { ; 215 : /* Entire needle is periodic; a mismatch can only advance by the @@ -842,80 +857,80 @@ $LN53@two_way_sh: ; 219 : j = 0; ; 220 : while (AVAILABLE (haystack, haystack_len, j, needle_len)) - 00140 8b c6 mov eax, esi - 00142 33 ff xor edi, edi - 00144 2b 45 0c sub eax, DWORD PTR _haystack_len$[ebp] - 00147 50 push eax - 00148 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] - 0014b 03 45 0c add eax, DWORD PTR _haystack_len$[ebp] - 0014e 57 push edi - 0014f 50 push eax - 00150 89 7d f8 mov DWORD PTR _j$1$[ebp], edi - 00153 e8 00 00 00 00 call _memchr - 00158 83 c4 0c add esp, 12 ; 0000000cH - 0015b 85 c0 test eax, eax - 0015d 75 d8 jne SHORT $LN8@two_way_sh - 0015f 90 npad 1 + 00143 8b c6 mov eax, esi + 00145 33 db xor ebx, ebx + 00147 2b 45 0c sub eax, DWORD PTR _haystack_len$[ebp] + 0014a 33 ff xor edi, edi + 0014c 50 push eax + 0014d 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 00150 03 45 0c add eax, DWORD PTR _haystack_len$[ebp] + 00153 53 push ebx + 00154 50 push eax + 00155 89 5d f8 mov DWORD PTR _j$1$[ebp], ebx + 00158 e8 00 00 00 00 call _memchr + 0015d 83 c4 0c add esp, 12 ; 0000000cH + 00160 85 c0 test eax, eax + 00162 75 d6 jne SHORT $LN8@two_way_sh $LL19@two_way_sh: - 00160 8b 55 f8 mov edx, DWORD PTR _j$1$[ebp] - 00163 8d 04 32 lea eax, DWORD PTR [edx+esi] - 00166 89 45 ec mov DWORD PTR _haystack_len$2$[ebp], eax - 00169 85 c0 test eax, eax - 0016b 74 ca je SHORT $LN8@two_way_sh + 00164 8d 04 33 lea eax, DWORD PTR [ebx+esi] + 00167 89 45 ec mov DWORD PTR _haystack_len$2$[ebp], eax + 0016a 85 c0 test eax, eax + 0016c 74 cc je SHORT $LN8@two_way_sh ; 221 : { ; 222 : /* Scan for matches in right half. */ ; 223 : i = MAX (suffix, memory); - 0016d 8b 45 fc mov eax, DWORD PTR _suffix$1$[ebp] - 00170 3b c7 cmp eax, edi - 00172 8b c8 mov ecx, eax - 00174 0f 42 cf cmovb ecx, edi + 0016e 8b 4d fc mov ecx, DWORD PTR _suffix$1$[ebp] + 00171 3b cf cmp ecx, edi + 00173 73 02 jae SHORT $LN23@two_way_sh + 00175 8b cf mov ecx, edi +$LN23@two_way_sh: ; 224 : while (i < needle_len && (CANON_ELEMENT (needle[i]) ; 225 : == CANON_ELEMENT (haystack[i + j]))) 00177 3b ce cmp ecx, esi - 00179 73 20 jae SHORT $LN50@two_way_sh - 0017b eb 03 8d 49 00 npad 5 + 00179 73 15 jae SHORT $LN52@two_way_sh + 0017b 8b 55 08 mov edx, DWORD PTR _haystack$[ebp] + 0017e 03 d3 add edx, ebx $LL17@two_way_sh: - 00180 8a 04 19 mov al, BYTE PTR [ecx+ebx] - 00183 8b 5d 08 mov ebx, DWORD PTR _haystack$[ebp] - 00186 8b 75 14 mov esi, DWORD PTR _needle_len$[ebp] - 00189 03 da add ebx, edx - 0018b 3a 04 0b cmp al, BYTE PTR [ebx+ecx] - 0018e 8b 5d 10 mov ebx, DWORD PTR _needle$[ebp] - 00191 75 71 jne SHORT $LN16@two_way_sh + 00180 8b 45 10 mov eax, DWORD PTR _needle$[ebp] + 00183 8a 04 01 mov al, BYTE PTR [ecx+eax] + 00186 3a 04 0a cmp al, BYTE PTR [edx+ecx] + 00189 75 79 jne SHORT $LN16@two_way_sh ; 226 : ++i; - 00193 41 inc ecx - 00194 3b ce cmp ecx, esi - 00196 72 e8 jb SHORT $LL17@two_way_sh -$LN58@two_way_sh: - 00198 8b 45 fc mov eax, DWORD PTR _suffix$1$[ebp] -$LN50@two_way_sh: + 0018b 41 inc ecx + 0018c 3b ce cmp ecx, esi + 0018e 72 f0 jb SHORT $LL17@two_way_sh +$LN52@two_way_sh: ; 228 : { ; 229 : /* Scan for matches in left half. */ ; 230 : i = suffix - 1; - 0019b 8d 50 ff lea edx, DWORD PTR [eax-1] + 00190 8b 55 fc mov edx, DWORD PTR _suffix$1$[ebp] + 00193 4a dec edx ; 231 : while (memory < i + 1 && (CANON_ELEMENT (needle[i]) ; 232 : == CANON_ELEMENT (haystack[i + j]))) - 0019e 8d 4a 01 lea ecx, DWORD PTR [edx+1] - 001a1 3b f9 cmp edi, ecx - 001a3 73 1d jae SHORT $LN13@two_way_sh - 001a5 8b 45 f8 mov eax, DWORD PTR _j$1$[ebp] - 001a8 03 45 08 add eax, DWORD PTR _haystack$[ebp] - 001ab 89 45 f0 mov DWORD PTR tv549[ebp], eax - 001ae 8b f0 mov esi, eax + 00194 8d 4a 01 lea ecx, DWORD PTR [edx+1] + 00197 3b f9 cmp edi, ecx + 00199 73 2a jae SHORT $LN13@two_way_sh + 0019b 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 0019e 8b 75 10 mov esi, DWORD PTR _needle$[ebp] + 001a1 03 c3 add eax, ebx + 001a3 89 45 f0 mov DWORD PTR tv565[ebp], eax + 001a6 8b d8 mov ebx, eax + 001a8 eb 06 8d 9b 00 + 00 00 00 npad 8 $LL14@two_way_sh: - 001b0 8a 44 0b ff mov al, BYTE PTR [ebx+ecx-1] - 001b4 3a 04 16 cmp al, BYTE PTR [esi+edx] - 001b7 75 06 jne SHORT $LN57@two_way_sh + 001b0 8a 44 0e ff mov al, BYTE PTR [esi+ecx-1] + 001b4 3a 04 13 cmp al, BYTE PTR [ebx+edx] + 001b7 75 06 jne SHORT $LN59@two_way_sh ; 233 : --i; @@ -923,36 +938,36 @@ $LL14@two_way_sh: 001ba 4a dec edx 001bb 3b f9 cmp edi, ecx 001bd 72 f1 jb SHORT $LL14@two_way_sh -$LN57@two_way_sh: +$LN59@two_way_sh: 001bf 8b 75 14 mov esi, DWORD PTR _needle_len$[ebp] + 001c2 8b 5d f8 mov ebx, DWORD PTR _j$1$[ebp] $LN13@two_way_sh: ; 234 : if (i + 1 < memory + 1) - 001c2 8d 4a 01 lea ecx, DWORD PTR [edx+1] - 001c5 8d 47 01 lea eax, DWORD PTR [edi+1] - 001c8 3b c8 cmp ecx, eax - 001ca 72 46 jb SHORT $LN31@two_way_sh + 001c5 8d 4a 01 lea ecx, DWORD PTR [edx+1] + 001c8 8d 47 01 lea eax, DWORD PTR [edi+1] + 001cb 3b c8 cmp ecx, eax + 001cd 72 43 jb SHORT $LN33@two_way_sh ; 236 : /* No match, so remember how many repetitions of period ; 237 : on the right half were scanned. */ ; 238 : j += period; - 001cc 8b 55 f8 mov edx, DWORD PTR _j$1$[ebp] + 001cf 03 5d f4 add ebx, DWORD PTR _period$[ebp] ; 239 : memory = needle_len - period; - 001cf 8b fe mov edi, esi - 001d1 03 55 f4 add edx, DWORD PTR _period$[ebp] + 001d2 8b fe mov edi, esi 001d4 2b 7d f4 sub edi, DWORD PTR _period$[ebp] -$LN59@two_way_sh: +$LN60@two_way_sh: ; 236 : /* No match, so remember how many repetitions of period ; 237 : on the right half were scanned. */ ; 238 : j += period; - 001d7 8b c2 mov eax, edx - 001d9 89 55 f8 mov DWORD PTR _j$1$[ebp], edx + 001d7 8b c3 mov eax, ebx + 001d9 89 5d f8 mov DWORD PTR _j$1$[ebp], ebx 001dc 2b 45 ec sub eax, DWORD PTR _haystack_len$2$[ebp] 001df 03 c6 add eax, esi 001e1 50 push eax @@ -963,7 +978,7 @@ $LN59@two_way_sh: 001eb e8 00 00 00 00 call _memchr 001f0 83 c4 0c add esp, 12 ; 0000000cH 001f3 85 c0 test eax, eax - 001f5 0f 84 65 ff ff + 001f5 0f 84 69 ff ff ff je $LL19@two_way_sh ; 274 : } @@ -985,7 +1000,7 @@ $LN16@two_way_sh: ; 227 : if (needle_len <= i) 00204 3b f1 cmp esi, ecx - 00206 76 90 jbe SHORT $LN58@two_way_sh + 00206 76 88 jbe SHORT $LN52@two_way_sh ; 240 : } ; 241 : else @@ -993,28 +1008,28 @@ $LN16@two_way_sh: ; 243 : j += i - suffix + 1; 00208 2b 4d fc sub ecx, DWORD PTR _suffix$1$[ebp] - 0020b 42 inc edx - 0020c 03 d1 add edx, ecx + 0020b 43 inc ebx + 0020c 03 d9 add ebx, ecx ; 244 : memory = 0; 0020e 33 ff xor edi, edi - 00210 eb c5 jmp SHORT $LN59@two_way_sh -$LN31@two_way_sh: + 00210 eb c5 jmp SHORT $LN60@two_way_sh +$LN33@two_way_sh: ; 235 : return (RETURN_TYPE) (haystack + j); - 00212 8b 45 f8 mov eax, DWORD PTR _j$1$[ebp] - 00215 03 45 08 add eax, DWORD PTR _haystack$[ebp] - 00218 5f pop edi - 00219 5e pop esi - 0021a 5b pop ebx + 00212 8b 45 08 mov eax, DWORD PTR _haystack$[ebp] + 00215 5f pop edi + 00216 5e pop esi + 00217 03 c3 add eax, ebx + 00219 5b pop ebx ; 277 : } - 0021b 8b e5 mov esp, ebp - 0021d 5d pop ebp - 0021e c3 ret 0 + 0021a 8b e5 mov esp, ebp + 0021c 5d pop ebp + 0021d c3 ret 0 _two_way_short_needle ENDP _TEXT ENDS ; Function compile flags: /Ogtp diff --git a/clib/mscv/CLib/strtod.cod b/clib/mscv/CLib/strtod.cod index 97aab11fe..98ec8bc5c 100644 --- a/clib/mscv/CLib/strtod.cod +++ b/clib/mscv/CLib/strtod.cod @@ -30,8 +30,12 @@ CONST ENDS ; File c:\users\philip\documents\github\mollenos\clib\src\string\strtod.c ; COMDAT _strtod _TEXT SEGMENT -tv433 = -8 ; size = 8 -_r$ = -8 ; size = 8 +tv421 = -12 ; size = 8 +tv414 = -12 ; size = 8 +tv389 = -12 ; size = 8 +_sign$ = -4 ; size = 4 +tv422 = 8 ; size = 4 +tv415 = 8 ; size = 4 _s$ = 8 ; size = 4 _sret$ = 12 ; size = 4 _strtod PROC ; COMDAT @@ -40,7 +44,7 @@ _strtod PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp - 00003 83 ec 08 sub esp, 8 + 00003 83 ec 0c sub esp, 12 ; 0000000cH ; 9 : long double r; /* result */ ; 10 : int e; /* exponent */ @@ -51,262 +55,267 @@ _strtod PROC ; COMDAT ; 15 : int flags=0; ; 16 : ; 17 : r = 0.0; + + 00006 d9 ee fldz + ; 18 : sign = 1; ; 19 : e = 0; + + 00008 33 c9 xor ecx, ecx + ; 20 : esign = 1; ; 21 : ; 22 : if (s == NULL) - 00006 8b 55 08 mov edx, DWORD PTR _s$[ebp] - 00009 0f 57 c9 xorps xmm1, xmm1 - 0000c 53 push ebx - 0000d 56 push esi - 0000e 33 f6 xor esi, esi - 00010 f2 0f 11 4d f8 movsd QWORD PTR _r$[ebp], xmm1 - 00015 bb 01 00 00 00 mov ebx, 1 - 0001a 33 c9 xor ecx, ecx - 0001c 57 push edi - 0001d 8b fb mov edi, ebx - 0001f 85 d2 test edx, edx - 00021 0f 84 a4 00 00 - 00 je $LN20@strtod -$LL32@strtod: + 0000a 8b 55 08 mov edx, DWORD PTR _s$[ebp] + 0000d d9 c0 fld ST(0) + 0000f 56 push esi + 00010 33 f6 xor esi, esi + 00012 c7 45 fc 01 00 + 00 00 mov DWORD PTR _sign$[ebp], 1 + 00019 57 push edi + 0001a 8d 7e 01 lea edi, DWORD PTR [esi+1] + 0001d 85 d2 test edx, edx + 0001f 75 08 jne SHORT $LN32@strtod + 00021 5f pop edi + 00022 dd d8 fstp ST(0) + 00024 5e pop esi + +; 101 : } + + 00025 8b e5 mov esp, ebp + 00027 5d pop ebp + 00028 c3 ret 0 +$LN32@strtod: ; 23 : return (double)r; ; 24 : ; 25 : ; 26 : while ((*s == ' ') || (*s == '\t')) - 00027 8a 02 mov al, BYTE PTR [edx] - 00029 3c 20 cmp al, 32 ; 00000020H - 0002b 74 04 je SHORT $LN30@strtod - 0002d 3c 09 cmp al, 9 - 0002f 75 03 jne SHORT $LN31@strtod + 00029 8a 02 mov al, BYTE PTR [edx] + 0002b 3c 20 cmp al, 32 ; 00000020H + 0002d 74 04 je SHORT $LN30@strtod + 0002f 3c 09 cmp al, 9 + 00031 75 03 jne SHORT $LN31@strtod $LN30@strtod: ; 27 : s++; - 00031 42 inc edx - 00032 eb f3 jmp SHORT $LL32@strtod + 00033 42 inc edx + 00034 eb f3 jmp SHORT $LN32@strtod $LN31@strtod: ; 28 : ; 29 : if (*s == '+') - 00034 8a 02 mov al, BYTE PTR [edx] - 00036 3c 2b cmp al, 43 ; 0000002bH - 00038 74 07 je SHORT $LN135@strtod + 00036 8a 02 mov al, BYTE PTR [edx] + 00038 3c 2b cmp al, 43 ; 0000002bH + 0003a 74 0b je SHORT $LN209@strtod ; 30 : s++; ; 31 : else if (*s == '-') - 0003a 3c 2d cmp al, 45 ; 0000002dH - 0003c 75 04 jne SHORT $LN38@strtod + 0003c 3c 2d cmp al, 45 ; 0000002dH + 0003e 75 08 jne SHORT $LN38@strtod ; 32 : { ; 33 : sign = -1; - 0003e 83 cb ff or ebx, -1 -$LN135@strtod: + 00040 c7 45 fc ff ff + ff ff mov DWORD PTR _sign$[ebp], -1 +$LN209@strtod: ; 34 : s++; - 00041 42 inc edx + 00047 42 inc edx $LN38@strtod: ; 35 : } ; 36 : ; 37 : while ((*s >= '0') && (*s <= '9')) - 00042 8a 02 mov al, BYTE PTR [edx] - 00044 f2 0f 10 1d 00 - 00 00 00 movsd xmm3, QWORD PTR __real@4024000000000000 - 0004c 3c 30 cmp al, 48 ; 00000030H - 0004e 7c 28 jl SHORT $LN125@strtod -$LL26@strtod: - 00050 3c 39 cmp al, 57 ; 00000039H - 00052 7f 24 jg SHORT $LN125@strtod + 00048 8a 02 mov al, BYTE PTR [edx] + 0004a dd 05 00 00 00 + 00 fld QWORD PTR __real@4024000000000000 + 00050 3c 30 cmp al, 48 ; 00000030H + 00052 7c 25 jl SHORT $LN121@strtod +$LN26@strtod: + 00054 3c 39 cmp al, 57 ; 00000039H + 00056 7f 21 jg SHORT $LN121@strtod ; 38 : { ; 39 : flags |= 1; ; 40 : r *= 10.0; ; 41 : r += *s - '0'; - 00054 0f be c0 movsx eax, al + 00058 0f be c0 movsx eax, al ; 42 : s++; - 00057 42 inc edx - 00058 83 e8 30 sub eax, 48 ; 00000030H - 0005b f2 0f 59 cb mulsd xmm1, xmm3 + 0005b 42 inc edx + 0005c 83 e8 30 sub eax, 48 ; 00000030H 0005f 0b f7 or esi, edi - 00061 66 0f 6e c0 movd xmm0, eax - 00065 8a 02 mov al, BYTE PTR [edx] - 00067 f3 0f e6 c0 cvtdq2pd xmm0, xmm0 - 0006b f2 0f 58 c8 addsd xmm1, xmm0 - 0006f f2 0f 11 4d f8 movsd QWORD PTR _r$[ebp], xmm1 - 00074 3c 30 cmp al, 48 ; 00000030H - 00076 7d d8 jge SHORT $LL26@strtod -$LN125@strtod: + 00061 89 45 08 mov DWORD PTR tv422[ebp], eax + 00064 db 45 08 fild DWORD PTR tv422[ebp] + 00067 dd 5d f4 fstp QWORD PTR tv421[ebp] + 0006a dd 45 f4 fld QWORD PTR tv421[ebp] + 0006d d9 ca fxch ST(2) + 0006f 8a 02 mov al, BYTE PTR [edx] + 00071 d8 c9 fmul ST(0), ST(1) + 00073 de c2 faddp ST(2), ST(0) + 00075 3c 30 cmp al, 48 ; 00000030H + 00077 7d db jge SHORT $LN26@strtod +$LN121@strtod: ; 43 : } ; 44 : ; 45 : if (*s == '.') - 00078 80 3a 2e cmp BYTE PTR [edx], 46 ; 0000002eH - 0007b f2 0f 10 15 00 - 00 00 00 movsd xmm2, QWORD PTR __real@3fb999999999999a - 00083 75 39 jne SHORT $LN126@strtod + 00079 80 3a 2e cmp BYTE PTR [edx], 46 ; 0000002eH + 0007c dd 05 00 00 00 + 00 fld QWORD PTR __real@3fb999999999999a + 00082 75 32 jne SHORT $LN122@strtod ; 46 : { ; 47 : d = 0.1L; ; 48 : s++; ; 49 : while ((*s >= '0') && (*s <= '9')) - 00085 8a 42 01 mov al, BYTE PTR [edx+1] - 00088 42 inc edx - 00089 66 0f 28 e2 movapd xmm4, xmm2 - 0008d 3c 30 cmp al, 48 ; 00000030H - 0008f 7c 2d jl SHORT $LN126@strtod -$LL23@strtod: - 00091 3c 39 cmp al, 57 ; 00000039H - 00093 7f 29 jg SHORT $LN126@strtod + 00084 8a 42 01 mov al, BYTE PTR [edx+1] + 00087 42 inc edx + 00088 d9 c0 fld ST(0) + 0008a 3c 30 cmp al, 48 ; 00000030H + 0008c 7c 26 jl SHORT $LN154@strtod +$LN23@strtod: + 0008e 3c 39 cmp al, 57 ; 00000039H + 00090 7f 22 jg SHORT $LN154@strtod ; 50 : { ; 51 : flags |= 2; ; 52 : r += d * (*s - '0'); - 00095 0f be c0 movsx eax, al + 00092 0f be c0 movsx eax, al ; 53 : s++; - 00098 42 inc edx - 00099 83 e8 30 sub eax, 48 ; 00000030H - 0009c 83 ce 02 or esi, 2 - 0009f 66 0f 6e c0 movd xmm0, eax - 000a3 8a 02 mov al, BYTE PTR [edx] - 000a5 f3 0f e6 c0 cvtdq2pd xmm0, xmm0 - 000a9 f2 0f 59 c4 mulsd xmm0, xmm4 + 00095 42 inc edx + 00096 83 e8 30 sub eax, 48 ; 00000030H + 00099 83 ce 02 or esi, 2 + 0009c 89 45 08 mov DWORD PTR tv415[ebp], eax + 0009f db 45 08 fild DWORD PTR tv415[ebp] + 000a2 dd 5d f4 fstp QWORD PTR tv414[ebp] + 000a5 dd 45 f4 fld QWORD PTR tv414[ebp] + 000a8 8a 02 mov al, BYTE PTR [edx] + 000aa d8 c9 fmul ST(0), ST(1) + 000ac de c4 faddp ST(4), ST(0) ; 54 : d *= 0.1L; - 000ad f2 0f 59 e2 mulsd xmm4, xmm2 - 000b1 f2 0f 58 c8 addsd xmm1, xmm0 - 000b5 f2 0f 11 4d f8 movsd QWORD PTR _r$[ebp], xmm1 - 000ba 3c 30 cmp al, 48 ; 00000030H - 000bc 7d d3 jge SHORT $LL23@strtod -$LN126@strtod: + 000ae d8 c9 fmul ST(0), ST(1) + 000b0 3c 30 cmp al, 48 ; 00000030H + 000b2 7d da jge SHORT $LN23@strtod +$LN154@strtod: + 000b4 dd d8 fstp ST(0) +$LN122@strtod: ; 55 : } ; 56 : } ; 57 : ; 58 : if (flags == 0) - 000be 85 f6 test esi, esi - 000c0 75 12 jne SHORT $LN21@strtod + 000b6 85 f6 test esi, esi + 000b8 75 0b jne SHORT $LN156@strtod ; 59 : { ; 60 : if (sret) - - 000c2 8b 45 0c mov eax, DWORD PTR _sret$[ebp] - 000c5 85 c0 test eax, eax - 000c7 74 02 je SHORT $LN20@strtod - ; 61 : *sret = (char *)s; - - 000c9 89 10 mov DWORD PTR [eax], edx -$LN20@strtod: - ; 62 : return 0; - 000cb d9 ee fldz - 000cd 5f pop edi - 000ce 5e pop esi - 000cf 5b pop ebx - -; 101 : } - - 000d0 8b e5 mov esp, ebp - 000d2 5d pop ebp - 000d3 c3 ret 0 -$LN21@strtod: + 000ba dd da fstp ST(2) + 000bc dd d9 fstp ST(1) + 000be dd d8 fstp ST(0) + 000c0 e9 da 00 00 00 jmp $LN13@strtod +$LN156@strtod: ; 63 : } ; 64 : ; 65 : if ((*s == 'e') || (*s == 'E')) - 000d4 8a 02 mov al, BYTE PTR [edx] - 000d6 3c 65 cmp al, 101 ; 00000065H - 000d8 74 08 je SHORT $LN18@strtod - 000da 3c 45 cmp al, 69 ; 00000045H - 000dc 0f 85 97 00 00 - 00 jne $LN9@strtod + 000c5 8a 02 mov al, BYTE PTR [edx] + 000c7 dd db fstp ST(3) + 000c9 3c 65 cmp al, 101 ; 00000065H + 000cb 74 04 je SHORT $LN18@strtod + 000cd 3c 45 cmp al, 69 ; 00000045H + 000cf 75 79 jne SHORT $LN190@strtod $LN18@strtod: ; 66 : { ; 67 : s++; ; 68 : if (*s == '+') - 000e2 8a 42 01 mov al, BYTE PTR [edx+1] - 000e5 42 inc edx - 000e6 3c 2b cmp al, 43 ; 0000002bH - 000e8 75 03 jne SHORT $LN17@strtod + 000d1 8a 42 01 mov al, BYTE PTR [edx+1] + 000d4 42 inc edx + 000d5 3c 2b cmp al, 43 ; 0000002bH + 000d7 75 03 jne SHORT $LN17@strtod ; 69 : s++; - 000ea 42 inc edx - 000eb eb 08 jmp SHORT $LN15@strtod + 000d9 42 inc edx + 000da eb 08 jmp SHORT $LN15@strtod $LN17@strtod: ; 70 : else if (*s == '-') - 000ed 3c 2d cmp al, 45 ; 0000002dH - 000ef 75 04 jne SHORT $LN15@strtod + 000dc 3c 2d cmp al, 45 ; 0000002dH + 000de 75 04 jne SHORT $LN15@strtod ; 71 : { ; 72 : s++; - 000f1 42 inc edx + 000e0 42 inc edx ; 73 : esign = -1; - 000f2 83 cf ff or edi, -1 + 000e1 83 cf ff or edi, -1 $LN15@strtod: ; 74 : } ; 75 : if ((*s < '0') || (*s > '9')) - 000f5 8a 02 mov al, BYTE PTR [edx] - 000f7 3c 30 cmp al, 48 ; 00000030H - 000f9 0f 8c ec 00 00 - 00 jl $LN13@strtod - 000ff 3c 39 cmp al, 57 ; 00000039H - 00101 0f 8f e4 00 00 - 00 jg $LN13@strtod -$LL11@strtod: + 000e4 8a 02 mov al, BYTE PTR [edx] + 000e6 3c 30 cmp al, 48 ; 00000030H + 000e8 0f 8c ad 00 00 + 00 jl $LN184@strtod + 000ee 3c 39 cmp al, 57 ; 00000039H + 000f0 0f 8f a5 00 00 + 00 jg $LN184@strtod +$LN11@strtod: +; 79 : +; 80 : return (double)r; ; 81 : } ; 82 : ; 83 : while ((*s >= '0') && (*s <= '9')) - 00107 3c 39 cmp al, 57 ; 00000039H - 00109 7f 13 jg SHORT $LN10@strtod + 000f6 3c 39 cmp al, 57 ; 00000039H + 000f8 7f 13 jg SHORT $LN10@strtod ; 84 : { ; 85 : e *= 10; ; 86 : e += *s - '0'; - 0010b 0f be c0 movsx eax, al - 0010e 8d 0c 89 lea ecx, DWORD PTR [ecx+ecx*4] + 000fa 0f be c0 movsx eax, al + 000fd 8d 0c 89 lea ecx, DWORD PTR [ecx+ecx*4] ; 87 : s++; - 00111 42 inc edx - 00112 8d 49 e8 lea ecx, DWORD PTR [ecx-24] - 00115 8d 0c 48 lea ecx, DWORD PTR [eax+ecx*2] - 00118 8a 02 mov al, BYTE PTR [edx] - 0011a 3c 30 cmp al, 48 ; 00000030H - 0011c 7d e9 jge SHORT $LL11@strtod + 00100 42 inc edx + 00101 8d 49 e8 lea ecx, DWORD PTR [ecx-24] + 00104 8d 0c 48 lea ecx, DWORD PTR [eax+ecx*2] + 00107 8a 02 mov al, BYTE PTR [edx] + 00109 3c 30 cmp al, 48 ; 00000030H + 0010b 7d e9 jge SHORT $LN11@strtod $LN10@strtod: ; 88 : } @@ -314,155 +323,145 @@ $LN10@strtod: ; 90 : ; 91 : if (esign < 0) - 0011e 85 ff test edi, edi - 00120 79 57 jns SHORT $LN9@strtod + 0010d 85 ff test edi, edi + 0010f 79 39 jns SHORT $LN190@strtod ; 92 : for (i = 1; i <= e; i++) - 00122 be 01 00 00 00 mov esi, 1 - 00127 83 f9 08 cmp ecx, 8 - 0012a 7c 37 jl SHORT $LC71@strtod - 0012c 8b c1 mov eax, ecx - 0012e c1 e8 03 shr eax, 3 - 00131 8d 34 c5 01 00 + 00111 dd d8 fstp ST(0) + 00113 be 01 00 00 00 mov esi, 1 + 00118 83 f9 08 cmp ecx, 8 + 0011b 7c 1f jl SHORT $LC67@strtod + 0011d 8b c1 mov eax, ecx + 0011f c1 e8 03 shr eax, 3 + 00122 8d 34 c5 01 00 00 00 lea esi, DWORD PTR [eax*8+1] - 00138 eb 06 8d 9b 00 - 00 00 00 npad 8 -$LL131@strtod: +$LN127@strtod: ; 93 : r *= 0.1L; - 00140 f2 0f 59 ca mulsd xmm1, xmm2 - 00144 f2 0f 59 ca mulsd xmm1, xmm2 - 00148 f2 0f 59 ca mulsd xmm1, xmm2 - 0014c f2 0f 59 ca mulsd xmm1, xmm2 - 00150 f2 0f 59 ca mulsd xmm1, xmm2 - 00154 f2 0f 59 ca mulsd xmm1, xmm2 - 00158 f2 0f 59 ca mulsd xmm1, xmm2 - 0015c f2 0f 59 ca mulsd xmm1, xmm2 - 00160 48 dec eax - 00161 75 dd jne SHORT $LL131@strtod -$LC71@strtod: + 00129 d8 c9 fmul ST(0), ST(1) + 0012b d8 c9 fmul ST(0), ST(1) + 0012d d8 c9 fmul ST(0), ST(1) + 0012f d8 c9 fmul ST(0), ST(1) + 00131 d8 c9 fmul ST(0), ST(1) + 00133 d8 c9 fmul ST(0), ST(1) + 00135 d8 c9 fmul ST(0), ST(1) + 00137 d8 c9 fmul ST(0), ST(1) + 00139 48 dec eax + 0013a 75 ed jne SHORT $LN127@strtod +$LC67@strtod: ; 92 : for (i = 1; i <= e; i++) - 00163 3b f1 cmp esi, ecx - 00165 7f 60 jg SHORT $LN73@strtod - 00167 2b ce sub ecx, esi - 00169 41 inc ecx - 0016a 8d 9b 00 00 00 - 00 npad 6 -$LC132@strtod: + 0013c 3b f1 cmp esi, ecx + 0013e 7f 41 jg SHORT $LN197@strtod + 00140 2b ce sub ecx, esi + 00142 41 inc ecx +$LC128@strtod: ; 93 : r *= 0.1L; - 00170 f2 0f 59 ca mulsd xmm1, xmm2 - 00174 49 dec ecx - 00175 75 f9 jne SHORT $LC132@strtod + 00143 d8 c9 fmul ST(0), ST(1) + 00145 49 dec ecx + 00146 75 fb jne SHORT $LC128@strtod ; 94 : else - 00177 eb 4e jmp SHORT $LN73@strtod -$LN9@strtod: + 00148 eb 37 jmp SHORT $LN197@strtod +$LN190@strtod: + 0014a dd da fstp ST(2) ; 95 : for (i = 1; i <= e; i++) - 00179 be 01 00 00 00 mov esi, 1 - 0017e 83 f9 08 cmp ecx, 8 - 00181 7c 30 jl SHORT $LC74@strtod - 00183 8b c1 mov eax, ecx - 00185 c1 e8 03 shr eax, 3 - 00188 8d 34 c5 01 00 + 0014c be 01 00 00 00 mov esi, 1 + 00151 83 f9 08 cmp ecx, 8 + 00154 7c 1f jl SHORT $LC70@strtod + 00156 8b c1 mov eax, ecx + 00158 c1 e8 03 shr eax, 3 + 0015b 8d 34 c5 01 00 00 00 lea esi, DWORD PTR [eax*8+1] - 0018f 90 npad 1 -$LL133@strtod: +$LN129@strtod: ; 96 : r *= 10.0; - 00190 f2 0f 59 cb mulsd xmm1, xmm3 - 00194 f2 0f 59 cb mulsd xmm1, xmm3 - 00198 f2 0f 59 cb mulsd xmm1, xmm3 - 0019c f2 0f 59 cb mulsd xmm1, xmm3 - 001a0 f2 0f 59 cb mulsd xmm1, xmm3 - 001a4 f2 0f 59 cb mulsd xmm1, xmm3 - 001a8 f2 0f 59 cb mulsd xmm1, xmm3 - 001ac f2 0f 59 cb mulsd xmm1, xmm3 - 001b0 48 dec eax - 001b1 75 dd jne SHORT $LL133@strtod -$LC74@strtod: + 00162 d8 c9 fmul ST(0), ST(1) + 00164 d8 c9 fmul ST(0), ST(1) + 00166 d8 c9 fmul ST(0), ST(1) + 00168 d8 c9 fmul ST(0), ST(1) + 0016a d8 c9 fmul ST(0), ST(1) + 0016c d8 c9 fmul ST(0), ST(1) + 0016e d8 c9 fmul ST(0), ST(1) + 00170 d8 c9 fmul ST(0), ST(1) + 00172 48 dec eax + 00173 75 ed jne SHORT $LN129@strtod +$LC70@strtod: ; 95 : for (i = 1; i <= e; i++) - 001b3 3b f1 cmp esi, ecx - 001b5 7f 10 jg SHORT $LN73@strtod - 001b7 2b ce sub ecx, esi - 001b9 41 inc ecx - 001ba 8d 9b 00 00 00 - 00 npad 6 -$LC134@strtod: + 00175 3b f1 cmp esi, ecx + 00177 7f 08 jg SHORT $LN197@strtod + 00179 2b ce sub ecx, esi + 0017b 41 inc ecx +$LC130@strtod: ; 96 : r *= 10.0; - 001c0 f2 0f 59 cb mulsd xmm1, xmm3 - 001c4 49 dec ecx - 001c5 75 f9 jne SHORT $LC134@strtod -$LN73@strtod: + 0017c d8 c9 fmul ST(0), ST(1) + 0017e 49 dec ecx + 0017f 75 fb jne SHORT $LC130@strtod +$LN197@strtod: ; 97 : ; 98 : if (sret) - 001c7 8b 45 0c mov eax, DWORD PTR _sret$[ebp] - 001ca 85 c0 test eax, eax - 001cc 74 02 je SHORT $LN1@strtod + 00181 8b 45 0c mov eax, DWORD PTR _sret$[ebp] + 00184 dd d9 fstp ST(1) + 00186 85 c0 test eax, eax + 00188 74 02 je SHORT $LN1@strtod ; 99 : *sret = (char *)s; - 001ce 89 10 mov DWORD PTR [eax], edx + 0018a 89 10 mov DWORD PTR [eax], edx $LN1@strtod: - 001d0 66 0f 6e c3 movd xmm0, ebx ; 100 : return (double)(r * sign); - 001d4 f3 0f e6 c0 cvtdq2pd xmm0, xmm0 - 001d8 5f pop edi - 001d9 5e pop esi - 001da 5b pop ebx - 001db f2 0f 59 c1 mulsd xmm0, xmm1 - 001df f2 0f 11 45 f8 movsd QWORD PTR tv433[ebp], xmm0 - 001e4 dd 45 f8 fld QWORD PTR tv433[ebp] + 0018c db 45 fc fild DWORD PTR _sign$[ebp] + 0018f 5f pop edi + 00190 5e pop esi + 00191 dd 5d f4 fstp QWORD PTR tv389[ebp] + 00194 dc 4d f4 fmul QWORD PTR tv389[ebp] ; 101 : } - 001e7 8b e5 mov esp, ebp - 001e9 5d pop ebp - 001ea c3 ret 0 + 00197 8b e5 mov esp, ebp + 00199 5d pop ebp + 0019a c3 ret 0 +$LN184@strtod: + 0019b dd da fstp ST(2) + 0019d dd d9 fstp ST(1) $LN13@strtod: ; 76 : { ; 77 : if (sret) - 001eb 8b 45 0c mov eax, DWORD PTR _sret$[ebp] - 001ee 85 c0 test eax, eax - 001f0 74 02 je SHORT $LN12@strtod + 0019f 8b 45 0c mov eax, DWORD PTR _sret$[ebp] + 001a2 85 c0 test eax, eax + 001a4 74 02 je SHORT $LN34@strtod ; 78 : *sret = (char *)s; - 001f2 89 10 mov DWORD PTR [eax], edx -$LN12@strtod: - -; 79 : -; 80 : return (double)r; - - 001f4 dd 45 f8 fld QWORD PTR _r$[ebp] - 001f7 5f pop edi - 001f8 5e pop esi - 001f9 5b pop ebx + 001a6 89 10 mov DWORD PTR [eax], edx +$LN34@strtod: + 001a8 5f pop edi + 001a9 5e pop esi ; 101 : } - 001fa 8b e5 mov esp, ebp - 001fc 5d pop ebp - 001fd c3 ret 0 + 001aa 8b e5 mov esp, ebp + 001ac 5d pop ebp + 001ad c3 ret 0 _strtod ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/strtoi64.cod b/clib/mscv/CLib/strtoi64.cod index a4789b4ae..9f71bce97 100644 --- a/clib/mscv/CLib/strtoi64.cod +++ b/clib/mscv/CLib/strtoi64.cod @@ -51,14 +51,13 @@ _TEXT ENDS ; File c:\users\philip\documents\github\mollenos\clib\src\string\strtoi64.c ; COMDAT _strtoi64 _TEXT SEGMENT -_ret$ = -16 ; size = 8 -tv162 = -12 ; size = 4 -tv133 = -12 ; size = 4 -tv163 = -8 ; size = 4 -tv132 = -8 ; size = 4 +tv164 = -12 ; size = 4 +tv135 = -12 ; size = 4 +_ret$2$ = -8 ; size = 4 _negative$1$ = -1 ; size = 1 -tv173 = 8 ; size = 4 -_ret$2$ = 8 ; size = 4 +tv174 = 8 ; size = 4 +tv163 = 8 ; size = 4 +tv133 = 8 ; size = 4 _nptr$ = 8 ; size = 4 _endptr$ = 12 ; size = 4 _base$ = 16 ; size = 4 @@ -68,7 +67,7 @@ _strtoi64 PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp - 00003 83 ec 10 sub esp, 16 ; 00000010H + 00003 83 ec 0c sub esp, 12 ; 0000000cH 00006 53 push ebx 00007 56 push esi @@ -80,104 +79,102 @@ _strtoi64 PROC ; COMDAT 00008 8b 75 08 mov esi, DWORD PTR _nptr$[ebp] 0000b 32 c0 xor al, al 0000d 88 45 ff mov BYTE PTR _negative$1$[ebp], al - 00010 0f 57 c0 xorps xmm0, xmm0 - 00013 57 push edi - 00014 66 0f 13 45 f0 movlpd QWORD PTR _ret$[ebp], xmm0 - 00019 0f b6 06 movzx eax, BYTE PTR [esi] - 0001c f6 80 00 00 00 + 00010 33 db xor ebx, ebx + 00012 57 push edi + 00013 33 ff xor edi, edi + 00015 89 5d f8 mov DWORD PTR _ret$2$[ebp], ebx + 00018 0f b6 06 movzx eax, BYTE PTR [esi] + 0001b f6 80 00 00 00 00 20 test BYTE PTR __ctype[eax], 32 ; 00000020H - 00023 74 19 je SHORT $LN24@strtoi64 - 00025 eb 09 8d a4 24 - 00 00 00 00 8b - ff npad 11 + 00022 74 0e je SHORT $LN24@strtoi64 $LL25@strtoi64: - 00030 0f b6 46 01 movzx eax, BYTE PTR [esi+1] - 00034 46 inc esi - 00035 f6 80 00 00 00 + 00024 0f b6 46 01 movzx eax, BYTE PTR [esi+1] + 00028 46 inc esi + 00029 f6 80 00 00 00 00 20 test BYTE PTR __ctype[eax], 32 ; 00000020H - 0003c 75 f2 jne SHORT $LL25@strtoi64 + 00030 75 f2 jne SHORT $LL25@strtoi64 $LN24@strtoi64: ; 13 : ; 14 : if(*nptr == '-') { - 0003e 8a 06 mov al, BYTE PTR [esi] - 00040 3c 2d cmp al, 45 ; 0000002dH - 00042 75 07 jne SHORT $LN23@strtoi64 + 00032 8a 06 mov al, BYTE PTR [esi] + 00034 3c 2d cmp al, 45 ; 0000002dH + 00036 75 07 jne SHORT $LN23@strtoi64 ; 15 : negative = true; - 00044 b0 01 mov al, 1 - 00046 88 45 ff mov BYTE PTR _negative$1$[ebp], al + 00038 b0 01 mov al, 1 + 0003a 88 45 ff mov BYTE PTR _negative$1$[ebp], al ; 16 : nptr++; - 00049 eb 04 jmp SHORT $LN52@strtoi64 + 0003d eb 04 jmp SHORT $LN52@strtoi64 $LN23@strtoi64: ; 17 : } else if(*nptr == '+') - 0004b 3c 2b cmp al, 43 ; 0000002bH - 0004d 75 01 jne SHORT $LN21@strtoi64 + 0003f 3c 2b cmp al, 43 ; 0000002bH + 00041 75 01 jne SHORT $LN21@strtoi64 $LN52@strtoi64: ; 18 : nptr++; - 0004f 46 inc esi + 00043 46 inc esi $LN21@strtoi64: ; 20 : if((base==0 || base==16) && *nptr=='0' && tolower(*(nptr+1))=='x') { - 00050 8b 55 10 mov edx, DWORD PTR _base$[ebp] - 00053 85 d2 test edx, edx - 00055 74 05 je SHORT $LN19@strtoi64 - 00057 83 fa 10 cmp edx, 16 ; 00000010H - 0005a 75 23 jne SHORT $LN20@strtoi64 + 00044 8b 55 10 mov edx, DWORD PTR _base$[ebp] + 00047 85 d2 test edx, edx + 00049 74 05 je SHORT $LN19@strtoi64 + 0004b 83 fa 10 cmp edx, 16 ; 00000010H + 0004e 75 23 jne SHORT $LN20@strtoi64 $LN19@strtoi64: - 0005c 80 3e 30 cmp BYTE PTR [esi], 48 ; 00000030H - 0005f 75 1e jne SHORT $LN20@strtoi64 + 00050 80 3e 30 cmp BYTE PTR [esi], 48 ; 00000030H + 00053 75 1e jne SHORT $LN20@strtoi64 ; File c:\users\philip\documents\github\mollenos\clib\include\ctype.h ; 62 : return isupper(c) ? c - ('A' - 'a') : c; - 00061 0f b6 46 01 movzx eax, BYTE PTR [esi+1] - 00065 f6 80 00 00 00 + 00055 0f b6 46 01 movzx eax, BYTE PTR [esi+1] + 00059 f6 80 00 00 00 00 01 test BYTE PTR __ctype[eax], 1 - 0006c 74 03 je SHORT $LN30@strtoi64 - 0006e 83 c0 20 add eax, 32 ; 00000020H + 00060 74 03 je SHORT $LN30@strtoi64 + 00062 83 c0 20 add eax, 32 ; 00000020H $LN30@strtoi64: ; File c:\users\philip\documents\github\mollenos\clib\src\string\strtoi64.c ; 20 : if((base==0 || base==16) && *nptr=='0' && tolower(*(nptr+1))=='x') { - 00071 3c 78 cmp al, 120 ; 00000078H - 00073 75 0a jne SHORT $LN20@strtoi64 + 00065 3c 78 cmp al, 120 ; 00000078H + 00067 75 0a jne SHORT $LN20@strtoi64 ; 21 : base = 16; - 00075 ba 10 00 00 00 mov edx, 16 ; 00000010H + 00069 ba 10 00 00 00 mov edx, 16 ; 00000010H ; 22 : nptr += 2; - 0007a 83 c6 02 add esi, 2 + 0006e 83 c6 02 add esi, 2 ; 23 : } ; 24 : ; 25 : if(base == 0) { - 0007d eb 11 jmp SHORT $LN53@strtoi64 + 00071 eb 11 jmp SHORT $LN53@strtoi64 $LN20@strtoi64: - 0007f 85 d2 test edx, edx - 00081 75 10 jne SHORT $LN17@strtoi64 + 00073 85 d2 test edx, edx + 00075 75 10 jne SHORT $LN17@strtoi64 ; 26 : if(*nptr=='0') - 00083 80 3e 30 cmp BYTE PTR [esi], 48 ; 00000030H - 00086 0f 95 c2 setne dl - 00089 8d 14 55 08 00 + 00077 80 3e 30 cmp BYTE PTR [esi], 48 ; 00000030H + 0007a 0f 95 c2 setne dl + 0007d 8d 14 55 08 00 00 00 lea edx, DWORD PTR [edx*2+8] $LN53@strtoi64: - 00090 89 55 10 mov DWORD PTR _base$[ebp], edx + 00084 89 55 10 mov DWORD PTR _base$[ebp], edx $LN17@strtoi64: ; 27 : base = 8; @@ -187,199 +184,194 @@ $LN17@strtoi64: ; 31 : ; 32 : while(*nptr) { - 00093 8a 06 mov al, BYTE PTR [esi] - 00095 8b 5d f4 mov ebx, DWORD PTR _ret$[ebp+4] - 00098 8b 7d f0 mov edi, DWORD PTR _ret$[ebp] - 0009b 84 c0 test al, al - 0009d 0f 84 3d 01 00 - 00 je $LN38@strtoi64 - 000a3 89 5d 08 mov DWORD PTR _ret$2$[ebp], ebx - 000a6 eb 08 8d a4 24 - 00 00 00 00 90 npad 10 + 00087 8a 06 mov al, BYTE PTR [esi] + 00089 84 c0 test al, al + 0008b 0f 84 30 01 00 + 00 je $LN51@strtoi64 $LL15@strtoi64: ; File c:\users\philip\documents\github\mollenos\clib\include\ctype.h ; 62 : return isupper(c) ? c - ('A' - 'a') : c; - 000b0 0f b6 c8 movzx ecx, al - 000b3 f6 81 00 00 00 + 00091 0f b6 c8 movzx ecx, al + 00094 f6 81 00 00 00 00 01 test BYTE PTR __ctype[ecx], 1 - 000ba 74 02 je SHORT $LN34@strtoi64 - 000bc 04 20 add al, 32 ; 00000020H + 0009b 74 02 je SHORT $LN34@strtoi64 + 0009d 04 20 add al, 32 ; 00000020H $LN34@strtoi64: ; File c:\users\philip\documents\github\mollenos\clib\src\string\strtoi64.c ; 36 : if(isdigit((unsigned char)cur)) { - 000be 0f b6 c8 movzx ecx, al - 000c1 f6 81 00 00 00 + 0009f 0f b6 c8 movzx ecx, al + 000a2 f6 81 00 00 00 00 04 test BYTE PTR __ctype[ecx], 4 - 000c8 74 13 je SHORT $LN13@strtoi64 + 000a9 74 13 je SHORT $LN13@strtoi64 ; 37 : if(cur >= '0'+base) - 000ca 0f be c8 movsx ecx, al - 000cd 8d 42 30 lea eax, DWORD PTR [edx+48] - 000d0 3b c8 cmp ecx, eax - 000d2 0f 8d 08 01 00 - 00 jge $LN38@strtoi64 + 000ab 0f be c8 movsx ecx, al + 000ae 8d 42 30 lea eax, DWORD PTR [edx+48] + 000b1 3b c8 cmp ecx, eax + 000b3 0f 8d 08 01 00 + 00 jge $LN51@strtoi64 ; 38 : break; ; 39 : v = cur-'0'; - 000d8 8d 59 d0 lea ebx, DWORD PTR [ecx-48] + 000b9 8d 59 d0 lea ebx, DWORD PTR [ecx-48] ; 40 : } else { - 000db eb 19 jmp SHORT $LN11@strtoi64 + 000bc eb 19 jmp SHORT $LN11@strtoi64 $LN13@strtoi64: ; 41 : if(cur<'a' || cur>='a'+base-10) - 000dd 3c 61 cmp al, 97 ; 00000061H - 000df 0f 8c fb 00 00 - 00 jl $LN38@strtoi64 - 000e5 0f be c8 movsx ecx, al - 000e8 8d 42 57 lea eax, DWORD PTR [edx+87] - 000eb 3b c8 cmp ecx, eax - 000ed 0f 8d ed 00 00 - 00 jge $LN38@strtoi64 + 000be 3c 61 cmp al, 97 ; 00000061H + 000c0 0f 8c fb 00 00 + 00 jl $LN51@strtoi64 + 000c6 0f be c8 movsx ecx, al + 000c9 8d 42 57 lea eax, DWORD PTR [edx+87] + 000cc 3b c8 cmp ecx, eax + 000ce 0f 8d ed 00 00 + 00 jge $LN51@strtoi64 ; 42 : break; ; 43 : v = cur-'a'+10; - 000f3 8d 59 a9 lea ebx, DWORD PTR [ecx-87] + 000d4 8d 59 a9 lea ebx, DWORD PTR [ecx-87] $LN11@strtoi64: ; 44 : } ; 45 : ; 46 : if(negative) - 000f6 8a 45 ff mov al, BYTE PTR _negative$1$[ebp] - 000f9 84 c0 test al, al - 000fb 74 02 je SHORT $LN8@strtoi64 + 000d7 8a 45 ff mov al, BYTE PTR _negative$1$[ebp] + 000da 84 c0 test al, al + 000dc 74 02 je SHORT $LN8@strtoi64 ; 47 : v = -v; - 000fd f7 db neg ebx + 000de f7 db neg ebx $LN8@strtoi64: ; 48 : ; 49 : nptr++; - 000ff 46 inc esi + 000e0 46 inc esi ; 50 : ; 51 : if(!negative && (ret > _I64_MAX / base || ret * base > _I64_MAX-v)) { - 00100 84 c0 test al, al - 00102 8b c2 mov eax, edx - 00104 99 cdq - 00105 8b c8 mov ecx, eax - 00107 8b c2 mov eax, edx - 00109 50 push eax - 0010a 51 push ecx - 0010b 75 59 jne SHORT $LN45@strtoi64 - 0010d 68 ff ff ff 7f push 2147483647 ; 7fffffffH - 00112 6a ff push -1 - 00114 89 4d f4 mov DWORD PTR tv133[ebp], ecx - 00117 89 45 f8 mov DWORD PTR tv132[ebp], eax - 0011a e8 00 00 00 00 call __alldiv - 0011f 8b 4d 08 mov ecx, DWORD PTR _ret$2$[ebp] - 00122 3b ca cmp ecx, edx - 00124 7f 36 jg SHORT $LN47@strtoi64 - 00126 7c 04 jl SHORT $LN46@strtoi64 - 00128 3b f8 cmp edi, eax - 0012a 77 30 ja SHORT $LN47@strtoi64 + 000e1 84 c0 test al, al + 000e3 8b c2 mov eax, edx + 000e5 99 cdq + 000e6 8b c8 mov ecx, eax + 000e8 8b c2 mov eax, edx + 000ea 50 push eax + 000eb 51 push ecx + 000ec 75 59 jne SHORT $LN45@strtoi64 + 000ee 68 ff ff ff 7f push 2147483647 ; 7fffffffH + 000f3 6a ff push -1 + 000f5 89 4d f4 mov DWORD PTR tv135[ebp], ecx + 000f8 89 45 08 mov DWORD PTR tv133[ebp], eax + 000fb e8 00 00 00 00 call __alldiv + 00100 8b 4d f8 mov ecx, DWORD PTR _ret$2$[ebp] + 00103 3b ca cmp ecx, edx + 00105 7f 36 jg SHORT $LN47@strtoi64 + 00107 7c 04 jl SHORT $LN46@strtoi64 + 00109 3b f8 cmp edi, eax + 0010b 77 30 ja SHORT $LN47@strtoi64 $LN46@strtoi64: - 0012c 51 push ecx - 0012d 57 push edi - 0012e ff 75 f8 push DWORD PTR tv132[ebp] - 00131 ff 75 f4 push DWORD PTR tv133[ebp] - 00134 e8 00 00 00 00 call __allmul - 00139 8b c8 mov ecx, eax - 0013b 89 55 08 mov DWORD PTR tv173[ebp], edx - 0013e 8b c3 mov eax, ebx - 00140 99 cdq - 00141 8b da mov ebx, edx - 00143 8b f8 mov edi, eax - 00145 83 ca ff or edx, -1 - 00148 b8 ff ff ff 7f mov eax, 2147483647 ; 7fffffffH - 0014d 2b d7 sub edx, edi - 0014f 1b c3 sbb eax, ebx - 00151 39 45 08 cmp DWORD PTR tv173[ebp], eax - 00154 7c 5e jl SHORT $LN49@strtoi64 - 00156 7f 04 jg SHORT $LN47@strtoi64 - 00158 3b ca cmp ecx, edx - 0015a 76 58 jbe SHORT $LN49@strtoi64 + 0010d 51 push ecx + 0010e 57 push edi + 0010f ff 75 08 push DWORD PTR tv133[ebp] + 00112 ff 75 f4 push DWORD PTR tv135[ebp] + 00115 e8 00 00 00 00 call __allmul + 0011a 8b c8 mov ecx, eax + 0011c 89 55 08 mov DWORD PTR tv174[ebp], edx + 0011f 8b c3 mov eax, ebx + 00121 99 cdq + 00122 8b da mov ebx, edx + 00124 8b f8 mov edi, eax + 00126 83 ca ff or edx, -1 + 00129 b8 ff ff ff 7f mov eax, 2147483647 ; 7fffffffH + 0012e 2b d7 sub edx, edi + 00130 1b c3 sbb eax, ebx + 00132 39 45 08 cmp DWORD PTR tv174[ebp], eax + 00135 7c 5e jl SHORT $LN49@strtoi64 + 00137 7f 04 jg SHORT $LN47@strtoi64 + 00139 3b ca cmp ecx, edx + 0013b 76 58 jbe SHORT $LN49@strtoi64 $LN47@strtoi64: ; 52 : ret = _I64_MAX; - 0015c 83 cf ff or edi, -1 - 0015f bb ff ff ff 7f mov ebx, 2147483647 ; 7fffffffH + 0013d 83 cf ff or edi, -1 + 00140 bb ff ff ff 7f mov ebx, 2147483647 ; 7fffffffH ; 53 : *__errno() = ERANGE; - 00164 eb 5f jmp SHORT $LN54@strtoi64 + 00145 eb 5f jmp SHORT $LN54@strtoi64 $LN45@strtoi64: ; 54 : } else if(negative && (ret < _I64_MIN / base || ret * base < _I64_MIN-v)) { - 00166 68 00 00 00 80 push -2147483648 ; 80000000H - 0016b 6a 00 push 0 - 0016d 89 4d f8 mov DWORD PTR tv163[ebp], ecx - 00170 89 45 f4 mov DWORD PTR tv162[ebp], eax - 00173 e8 00 00 00 00 call __alldiv - 00178 8b 4d 08 mov ecx, DWORD PTR _ret$2$[ebp] - 0017b 3b ca cmp ecx, edx - 0017d 7c 3f jl SHORT $LN3@strtoi64 - 0017f 7f 04 jg SHORT $LN48@strtoi64 - 00181 3b f8 cmp edi, eax - 00183 72 39 jb SHORT $LN3@strtoi64 + 00147 68 00 00 00 80 push -2147483648 ; 80000000H + 0014c 6a 00 push 0 + 0014e 89 4d f4 mov DWORD PTR tv164[ebp], ecx + 00151 89 45 08 mov DWORD PTR tv163[ebp], eax + 00154 e8 00 00 00 00 call __alldiv + 00159 8b 4d f8 mov ecx, DWORD PTR _ret$2$[ebp] + 0015c 3b ca cmp ecx, edx + 0015e 7c 3f jl SHORT $LN3@strtoi64 + 00160 7f 04 jg SHORT $LN48@strtoi64 + 00162 3b f8 cmp edi, eax + 00164 72 39 jb SHORT $LN3@strtoi64 $LN48@strtoi64: - 00185 51 push ecx - 00186 57 push edi - 00187 ff 75 f4 push DWORD PTR tv162[ebp] - 0018a ff 75 f8 push DWORD PTR tv163[ebp] - 0018d e8 00 00 00 00 call __allmul - 00192 8b c8 mov ecx, eax - 00194 89 55 08 mov DWORD PTR tv173[ebp], edx - 00197 8b c3 mov eax, ebx - 00199 99 cdq - 0019a 8b da mov ebx, edx - 0019c 8b f8 mov edi, eax - 0019e 33 d2 xor edx, edx - 001a0 b8 00 00 00 80 mov eax, -2147483648 ; 80000000H - 001a5 2b d7 sub edx, edi - 001a7 1b c3 sbb eax, ebx - 001a9 39 45 08 cmp DWORD PTR tv173[ebp], eax - 001ac 7c 10 jl SHORT $LN3@strtoi64 - 001ae 7f 04 jg SHORT $LN49@strtoi64 - 001b0 3b ca cmp ecx, edx - 001b2 72 0a jb SHORT $LN3@strtoi64 + 00166 51 push ecx + 00167 57 push edi + 00168 ff 75 08 push DWORD PTR tv163[ebp] + 0016b ff 75 f4 push DWORD PTR tv164[ebp] + 0016e e8 00 00 00 00 call __allmul + 00173 8b c8 mov ecx, eax + 00175 89 55 08 mov DWORD PTR tv174[ebp], edx + 00178 8b c3 mov eax, ebx + 0017a 99 cdq + 0017b 8b da mov ebx, edx + 0017d 8b f8 mov edi, eax + 0017f 33 d2 xor edx, edx + 00181 b8 00 00 00 80 mov eax, -2147483648 ; 80000000H + 00186 2b d7 sub edx, edi + 00188 1b c3 sbb eax, ebx + 0018a 39 45 08 cmp DWORD PTR tv174[ebp], eax + 0018d 7c 10 jl SHORT $LN3@strtoi64 + 0018f 7f 04 jg SHORT $LN49@strtoi64 + 00191 3b ca cmp ecx, edx + 00193 72 0a jb SHORT $LN3@strtoi64 $LN49@strtoi64: ; 57 : } else ; 58 : ret = ret*base + v; - 001b4 03 f9 add edi, ecx - 001b6 13 5d 08 adc ebx, DWORD PTR tv173[ebp] - 001b9 89 5d 08 mov DWORD PTR _ret$2$[ebp], ebx - 001bc eb 15 jmp SHORT $LN2@strtoi64 + 00195 03 f9 add edi, ecx + 00197 13 5d 08 adc ebx, DWORD PTR tv174[ebp] + 0019a 89 5d f8 mov DWORD PTR _ret$2$[ebp], ebx + 0019d eb 15 jmp SHORT $LN2@strtoi64 $LN3@strtoi64: ; 55 : ret = _I64_MIN; - 001be 33 ff xor edi, edi - 001c0 bb 00 00 00 80 mov ebx, -2147483648 ; 80000000H + 0019f 33 ff xor edi, edi + 001a1 bb 00 00 00 80 mov ebx, -2147483648 ; 80000000H $LN54@strtoi64: - 001c5 89 5d 08 mov DWORD PTR _ret$2$[ebp], ebx + 001a6 89 5d f8 mov DWORD PTR _ret$2$[ebp], ebx ; 56 : *__errno() = ERANGE; - 001c8 e8 00 00 00 00 call ___errno - 001cd c7 00 22 00 00 + 001a9 e8 00 00 00 00 call ___errno + 001ae c7 00 22 00 00 00 mov DWORD PTR [eax], 34 ; 00000022H $LN2@strtoi64: @@ -390,44 +382,44 @@ $LN2@strtoi64: ; 31 : ; 32 : while(*nptr) { - 001d3 8a 06 mov al, BYTE PTR [esi] - 001d5 8b 55 10 mov edx, DWORD PTR _base$[ebp] - 001d8 84 c0 test al, al - 001da 0f 85 d0 fe ff + 001b4 8a 06 mov al, BYTE PTR [esi] + 001b6 8b 55 10 mov edx, DWORD PTR _base$[ebp] + 001b9 84 c0 test al, al + 001bb 0f 85 d0 fe ff ff jne $LL15@strtoi64 -$LN38@strtoi64: +$LN51@strtoi64: ; 59 : } ; 60 : ; 61 : if(endptr) - 001e0 8b 45 0c mov eax, DWORD PTR _endptr$[ebp] + 001c1 8b 45 0c mov eax, DWORD PTR _endptr$[ebp] ; 63 : ; 64 : return ret; - 001e3 8b d3 mov edx, ebx - 001e5 85 c0 test eax, eax - 001e7 74 02 je SHORT $LN50@strtoi64 + 001c4 8b d3 mov edx, ebx + 001c6 85 c0 test eax, eax + 001c8 74 02 je SHORT $LN50@strtoi64 ; 62 : *endptr = (char*)nptr; - 001e9 89 30 mov DWORD PTR [eax], esi + 001ca 89 30 mov DWORD PTR [eax], esi $LN50@strtoi64: ; 63 : ; 64 : return ret; - 001eb 8b c7 mov eax, edi - 001ed 5f pop edi - 001ee 5e pop esi - 001ef 5b pop ebx + 001cc 8b c7 mov eax, edi + 001ce 5f pop edi + 001cf 5e pop esi + 001d0 5b pop ebx ; 65 : } - 001f0 8b e5 mov esp, ebp - 001f2 5d pop ebp - 001f3 c3 ret 0 + 001d1 8b e5 mov esp, ebp + 001d3 5d pop ebp + 001d4 c3 ret 0 _strtoi64 ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/strtol.cod b/clib/mscv/CLib/strtol.cod index 6f2e5a36d..ff4096afa 100644 --- a/clib/mscv/CLib/strtol.cod +++ b/clib/mscv/CLib/strtol.cod @@ -16,14 +16,13 @@ EXTRN __ctype:BYTE ; File c:\users\philip\documents\github\mollenos\clib\src\string\strtol.c ; COMDAT _strtol _TEXT SEGMENT -_cutoff$1$ = -16 ; size = 4 -_cutlim$1$ = -12 ; size = 4 -_cutoff$2$ = -8 ; size = 4 -_neg$1$ = -4 ; size = 4 +_cutoff$1$ = -20 ; size = 4 +_cutlim$1$ = -16 ; size = 4 +_cutoff$2$ = -12 ; size = 4 +_neg$1$ = -8 ; size = 4 +_any$1$ = -4 ; size = 4 _nptr$ = 8 ; size = 4 _endptr$ = 12 ; size = 4 -tv267 = 16 ; size = 4 -_any$1$ = 16 ; size = 4 _base$ = 16 ; size = 4 _strtol PROC ; COMDAT @@ -31,21 +30,19 @@ _strtol PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp - 00003 83 ec 10 sub esp, 16 ; 00000010H - 00006 56 push esi + 00003 83 ec 14 sub esp, 20 ; 00000014H + 00006 53 push ebx ; 9 : const char *s = nptr; - - 00007 8b 75 08 mov esi, DWORD PTR _nptr$[ebp] - ; 10 : unsigned long acc; ; 11 : int c; ; 12 : unsigned long cutoff; ; 13 : int neg = 0, any, cutlim; - 0000a 33 d2 xor edx, edx - 0000c 57 push edi - 0000d 89 55 fc mov DWORD PTR _neg$1$[ebp], edx + 00007 33 d2 xor edx, edx + 00009 57 push edi + 0000a 8b 7d 08 mov edi, DWORD PTR _nptr$[ebp] + 0000d 89 55 f8 mov DWORD PTR _neg$1$[ebp], edx $LL25@strtol: ; 14 : @@ -57,8 +54,8 @@ $LL25@strtol: ; 20 : do { ; 21 : c = *s++; - 00010 0f be 0e movsx ecx, BYTE PTR [esi] - 00013 46 inc esi + 00010 0f be 0f movsx ecx, BYTE PTR [edi] + 00013 47 inc edi ; 22 : } while (isspace(c)); @@ -76,7 +73,7 @@ $LL25@strtol: ; 25 : neg = 1; 00025 ba 01 00 00 00 mov edx, 1 - 0002a 89 55 fc mov DWORD PTR _neg$1$[ebp], edx + 0002a 89 55 f8 mov DWORD PTR _neg$1$[ebp], edx ; 26 : c = *s++; @@ -92,54 +89,55 @@ $LN38@strtol: ; 29 : c = *s++; - 00034 0f be 0e movsx ecx, BYTE PTR [esi] - 00037 46 inc esi + 00034 0f be 0f movsx ecx, BYTE PTR [edi] + 00037 47 inc edi $LN20@strtol: ; 30 : if ((base == 0 || base == 16) && ; 31 : c == '0' && (*s == 'x' || *s == 'X')) - 00038 53 push ebx - 00039 8b 5d 10 mov ebx, DWORD PTR _base$[ebp] - 0003c 85 db test ebx, ebx - 0003e 74 05 je SHORT $LN18@strtol - 00040 83 fb 10 cmp ebx, 16 ; 00000010H - 00043 75 1d jne SHORT $LN19@strtol + 00038 8b 5d 10 mov ebx, DWORD PTR _base$[ebp] + 0003b 85 db test ebx, ebx + 0003d 74 05 je SHORT $LN18@strtol + 0003f 83 fb 10 cmp ebx, 16 ; 00000010H + 00042 75 1d jne SHORT $LN19@strtol $LN18@strtol: - 00045 83 f9 30 cmp ecx, 48 ; 00000030H - 00048 75 18 jne SHORT $LN19@strtol - 0004a 8a 06 mov al, BYTE PTR [esi] - 0004c 3c 78 cmp al, 120 ; 00000078H - 0004e 74 04 je SHORT $LN17@strtol - 00050 3c 58 cmp al, 88 ; 00000058H - 00052 75 0e jne SHORT $LN19@strtol + 00044 83 f9 30 cmp ecx, 48 ; 00000030H + 00047 75 18 jne SHORT $LN19@strtol + 00049 8a 07 mov al, BYTE PTR [edi] + 0004b 3c 78 cmp al, 120 ; 00000078H + 0004d 74 04 je SHORT $LN17@strtol + 0004f 3c 58 cmp al, 88 ; 00000058H + 00051 75 0e jne SHORT $LN19@strtol $LN17@strtol: ; 32 : { ; 33 : c = s[1]; - 00054 0f be 4e 01 movsx ecx, BYTE PTR [esi+1] + 00053 0f be 4f 01 movsx ecx, BYTE PTR [edi+1] ; 34 : s += 2; ; 35 : base = 16; - 00058 bb 10 00 00 00 mov ebx, 16 ; 00000010H - 0005d 83 c6 02 add esi, 2 + 00057 bb 10 00 00 00 mov ebx, 16 ; 00000010H + 0005c 83 c7 02 add edi, 2 ; 36 : } ; 37 : if (base == 0) - 00060 eb 11 jmp SHORT $LN16@strtol + 0005f eb 11 jmp SHORT $LN39@strtol $LN19@strtol: - 00062 85 db test ebx, ebx - 00064 75 0d jne SHORT $LN16@strtol + 00061 85 db test ebx, ebx + 00063 75 10 jne SHORT $LN16@strtol ; 38 : base = c == '0' ? 8 : 10; - 00066 83 f9 30 cmp ecx, 48 ; 00000030H - 00069 0f 95 c3 setne bl - 0006c 8d 1c 5d 08 00 + 00065 83 f9 30 cmp ecx, 48 ; 00000030H + 00068 0f 95 c3 setne bl + 0006b 8d 1c 5d 08 00 00 00 lea ebx, DWORD PTR [ebx*2+8] +$LN39@strtol: + 00072 89 5d 10 mov DWORD PTR _base$[ebp], ebx $LN16@strtol: ; 39 : @@ -162,24 +160,26 @@ $LN16@strtol: ; 56 : */ ; 57 : cutoff = neg ? ((unsigned long)LONG_MAX+1) : LONG_MAX; - 00073 33 c0 xor eax, eax + 00075 33 c0 xor eax, eax + 00077 85 d2 test edx, edx + 00079 56 push esi + 0007a 0f 95 c0 setne al ; 58 : cutlim = cutoff % (unsigned long)base; + + 0007d 33 d2 xor edx, edx + 0007f 05 ff ff ff 7f add eax, 2147483647 ; 7fffffffH + 00084 89 45 ec mov DWORD PTR _cutoff$1$[ebp], eax + 00087 f7 f3 div ebx + ; 59 : cutoff /= (unsigned long)base; ; 60 : for (acc = 0, any = 0;; c = *s++) - 00075 c7 45 10 37 00 - 00 00 mov DWORD PTR tv267[ebp], 55 ; 00000037H - 0007c 85 d2 test edx, edx - 0007e 0f 95 c0 setne al - 00081 33 d2 xor edx, edx - 00083 05 ff ff ff 7f add eax, 2147483647 ; 7fffffffH - 00088 33 ff xor edi, edi - 0008a 89 45 f0 mov DWORD PTR _cutoff$1$[ebp], eax - 0008d f7 f3 div ebx - 0008f 89 55 f4 mov DWORD PTR _cutlim$1$[ebp], edx - 00092 33 d2 xor edx, edx - 00094 89 45 f8 mov DWORD PTR _cutoff$2$[ebp], eax + 00089 33 db xor ebx, ebx + 0008b 89 45 f4 mov DWORD PTR _cutoff$2$[ebp], eax + 0008e 8b 45 10 mov eax, DWORD PTR _base$[ebp] + 00091 89 55 f0 mov DWORD PTR _cutlim$1$[ebp], edx + 00094 89 5d fc mov DWORD PTR _any$1$[ebp], ebx 00097 eb 07 8d a4 24 00 00 00 00 npad 9 $LL15@strtol: @@ -187,49 +187,53 @@ $LL15@strtol: ; 61 : { ; 62 : if (isdigit(c)) - 000a0 0f b6 c1 movzx eax, cl - 000a3 8a 80 00 00 00 - 00 mov al, BYTE PTR __ctype[eax] - 000a9 a8 04 test al, 4 - 000ab 74 05 je SHORT $LN12@strtol + 000a0 0f b6 f1 movzx esi, cl + 000a3 8a 96 00 00 00 + 00 mov dl, BYTE PTR __ctype[esi] + 000a9 f6 c2 04 test dl, 4 + 000ac 74 05 je SHORT $LN12@strtol ; 63 : c -= '0'; - 000ad 83 e9 30 sub ecx, 48 ; 00000030H - 000b0 eb 11 jmp SHORT $LN9@strtol + 000ae 83 e9 30 sub ecx, 48 ; 00000030H + 000b1 eb 1a jmp SHORT $LN9@strtol $LN12@strtol: ; 64 : else if (isalpha(c)) - 000b2 a8 03 test al, 3 - 000b4 74 3c je SHORT $LN32@strtol + 000b3 f6 c2 03 test dl, 3 + 000b6 74 4c je SHORT $LN32@strtol ; 65 : c -= isupper(c) ? 'A' - 10 : 'a' - 10; - 000b6 a8 01 test al, 1 - 000b8 b8 57 00 00 00 mov eax, 87 ; 00000057H - 000bd 0f 45 45 10 cmovne eax, DWORD PTR tv267[ebp] - 000c1 2b c8 sub ecx, eax + 000b8 80 e2 01 and dl, 1 + 000bb 0f b6 c2 movzx eax, dl + 000be f7 d8 neg eax + 000c0 1b c0 sbb eax, eax + 000c2 83 e0 e0 and eax, -32 ; ffffffe0H + 000c5 83 c0 57 add eax, 87 ; 00000057H + 000c8 2b c8 sub ecx, eax + 000ca 8b 45 10 mov eax, DWORD PTR _base$[ebp] $LN9@strtol: ; 66 : else ; 67 : break; ; 68 : if (c >= base) - 000c3 3b cb cmp ecx, ebx - 000c5 7d 2b jge SHORT $LN32@strtol + 000cd 3b c8 cmp ecx, eax + 000cf 7d 33 jge SHORT $LN32@strtol ; 69 : break; ; 70 : if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim)) - 000c7 85 d2 test edx, edx - 000c9 78 1e js SHORT $LN6@strtol - 000cb 8b 45 f8 mov eax, DWORD PTR _cutoff$2$[ebp] - 000ce 3b f8 cmp edi, eax - 000d0 77 17 ja SHORT $LN6@strtol - 000d2 75 05 jne SHORT $LN7@strtol - 000d4 3b 4d f4 cmp ecx, DWORD PTR _cutlim$1$[ebp] - 000d7 7f 10 jg SHORT $LN6@strtol + 000d1 83 7d fc 00 cmp DWORD PTR _any$1$[ebp], 0 + 000d5 7c 20 jl SHORT $LN6@strtol + 000d7 8b 55 f4 mov edx, DWORD PTR _cutoff$2$[ebp] + 000da 3b da cmp ebx, edx + 000dc 77 19 ja SHORT $LN6@strtol + 000de 75 05 jne SHORT $LN7@strtol + 000e0 3b 4d f0 cmp ecx, DWORD PTR _cutlim$1$[ebp] + 000e3 7f 12 jg SHORT $LN6@strtol $LN7@strtol: ; 72 : else @@ -237,91 +241,92 @@ $LN7@strtol: ; 74 : any = 1; ; 75 : acc *= base; - 000d9 0f af fb imul edi, ebx - 000dc ba 01 00 00 00 mov edx, 1 + 000e5 0f af d8 imul ebx, eax + 000e8 c7 45 fc 01 00 + 00 00 mov DWORD PTR _any$1$[ebp], 1 ; 76 : acc += c; - 000e1 03 f9 add edi, ecx - 000e3 0f be 0e movsx ecx, BYTE PTR [esi] - 000e6 46 inc esi - 000e7 eb b7 jmp SHORT $LL15@strtol + 000ef 03 d9 add ebx, ecx + 000f1 0f be 0f movsx ecx, BYTE PTR [edi] + 000f4 47 inc edi + 000f5 eb a9 jmp SHORT $LL15@strtol $LN6@strtol: -; 58 : cutlim = cutoff % (unsigned long)base; ; 59 : cutoff /= (unsigned long)base; ; 60 : for (acc = 0, any = 0;; c = *s++) - 000e9 0f be 0e movsx ecx, BYTE PTR [esi] + 000f7 0f be 0f movsx ecx, BYTE PTR [edi] + 000fa 47 inc edi ; 71 : any = -1; - 000ec 83 ca ff or edx, -1 - 000ef 46 inc esi - 000f0 eb ae jmp SHORT $LL15@strtol + 000fb c7 45 fc ff ff + ff ff mov DWORD PTR _any$1$[ebp], -1 + 00102 eb 9c jmp SHORT $LL15@strtol $LN32@strtol: - 000f2 89 55 10 mov DWORD PTR _any$1$[ebp], edx - 000f5 5b pop ebx ; 77 : } ; 78 : } ; 79 : if (any < 0) - 000f6 85 d2 test edx, edx - 000f8 79 13 jns SHORT $LN4@strtol + 00104 8b 45 fc mov eax, DWORD PTR _any$1$[ebp] + 00107 5e pop esi + 00108 85 c0 test eax, eax + 0010a 79 13 jns SHORT $LN4@strtol ; 80 : { ; 81 : acc = neg ? LONG_MIN : LONG_MAX; - 000fa 8b 7d f0 mov edi, DWORD PTR _cutoff$1$[ebp] + 0010c 8b 5d ec mov ebx, DWORD PTR _cutoff$1$[ebp] ; 82 : errno = ERANGE; - 000fd e8 00 00 00 00 call ___errno - 00102 8b 55 10 mov edx, DWORD PTR _any$1$[ebp] - 00105 c7 00 22 00 00 + 0010f e8 00 00 00 00 call ___errno + 00114 c7 00 22 00 00 00 mov DWORD PTR [eax], 34 ; 00000022H - 0010b eb 08 jmp SHORT $LN2@strtol + 0011a 8b 45 fc mov eax, DWORD PTR _any$1$[ebp] + 0011d eb 08 jmp SHORT $LN2@strtol $LN4@strtol: ; 83 : } ; 84 : else if (neg) - 0010d 83 7d fc 00 cmp DWORD PTR _neg$1$[ebp], 0 - 00111 74 02 je SHORT $LN2@strtol + 0011f 83 7d f8 00 cmp DWORD PTR _neg$1$[ebp], 0 + 00123 74 02 je SHORT $LN2@strtol ; 85 : acc = 0-acc; - 00113 f7 df neg edi + 00125 f7 db neg ebx $LN2@strtol: ; 86 : if (endptr != 0) - 00115 8b 45 0c mov eax, DWORD PTR _endptr$[ebp] - 00118 85 c0 test eax, eax - 0011a 74 0c je SHORT $LN37@strtol + 00127 8b 4d 0c mov ecx, DWORD PTR _endptr$[ebp] + 0012a 85 c9 test ecx, ecx + 0012c 74 0c je SHORT $LN37@strtol ; 87 : *endptr = any ? (char *)((size_t)(s - 1)) : (char *)((size_t)nptr); - 0011c 8d 4e ff lea ecx, DWORD PTR [esi-1] - 0011f 85 d2 test edx, edx - 00121 75 03 jne SHORT $LN29@strtol - 00123 8b 4d 08 mov ecx, DWORD PTR _nptr$[ebp] + 0012e 85 c0 test eax, eax + 00130 8d 47 ff lea eax, DWORD PTR [edi-1] + 00133 75 03 jne SHORT $LN29@strtol + 00135 8b 45 08 mov eax, DWORD PTR _nptr$[ebp] $LN29@strtol: - 00126 89 08 mov DWORD PTR [eax], ecx + 00138 89 01 mov DWORD PTR [ecx], eax $LN37@strtol: + 0013a 5f pop edi ; 88 : return acc; - 00128 8b c7 mov eax, edi - 0012a 5f pop edi - 0012b 5e pop esi + 0013b 8b c3 mov eax, ebx + 0013d 5b pop ebx ; 89 : } - 0012c 8b e5 mov esp, ebp - 0012e 5d pop ebp - 0012f c3 ret 0 + 0013e 8b e5 mov esp, ebp + 00140 5d pop ebp + 00141 c3 ret 0 _strtol ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/strtold.cod b/clib/mscv/CLib/strtold.cod index 399f5bc50..89d0fb25c 100644 --- a/clib/mscv/CLib/strtold.cod +++ b/clib/mscv/CLib/strtold.cod @@ -46,8 +46,12 @@ CONST ENDS ; File c:\users\philip\documents\github\mollenos\clib\src\string\strtold.c ; COMDAT __strtold _TEXT SEGMENT -tv344 = -8 ; size = 8 -_sign$1$ = -4 ; size = 4 +tv356 = -12 ; size = 8 +tv350 = -12 ; size = 8 +tv335 = -12 ; size = 8 +_sign$ = -4 ; size = 4 +tv357 = 8 ; size = 4 +tv351 = 8 ; size = 4 _s$ = 8 ; size = 4 _sret$ = 12 ; size = 4 __strtold PROC ; COMDAT @@ -56,7 +60,7 @@ __strtold PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp - 00003 83 ec 08 sub esp, 8 + 00003 83 ec 0c sub esp, 12 ; 0000000cH ; 16 : double r; /* result */ ; 17 : int e, ne; /* exponent */ @@ -73,278 +77,284 @@ __strtold PROC ; COMDAT ; 28 : while(*s && isspace(*s)) 00006 8b 55 08 mov edx, DWORD PTR _s$[ebp] - 00009 0f 57 db xorps xmm3, xmm3 - 0000c 53 push ebx - 0000d 56 push esi - 0000e 33 f6 xor esi, esi - 00010 c7 45 fc 01 00 - 00 00 mov DWORD PTR _sign$1$[ebp], 1 - 00017 8a 02 mov al, BYTE PTR [edx] - 00019 33 db xor ebx, ebx - 0001b 33 c9 xor ecx, ecx - 0001d 66 0f 28 cb movapd xmm1, xmm3 - 00021 57 push edi - 00022 8d 7e 01 lea edi, DWORD PTR [esi+1] - 00025 84 c0 test al, al - 00027 74 1b je SHORT $LN54@strtold - 00029 8d a4 24 00 00 - 00 00 npad 7 -$LL30@strtold: - 00030 0f b6 c0 movzx eax, al - 00033 f6 80 00 00 00 + 00009 33 c9 xor ecx, ecx + 0000b d9 ee fldz + 0000d 53 push ebx + 0000e 56 push esi + 0000f 8a 02 mov al, BYTE PTR [edx] + 00011 33 db xor ebx, ebx + 00013 57 push edi + 00014 33 ff xor edi, edi + 00016 c7 45 fc 01 00 + 00 00 mov DWORD PTR _sign$[ebp], 1 + 0001d d9 c0 fld ST(0) + 0001f 8d 77 01 lea esi, DWORD PTR [edi+1] + 00022 84 c0 test al, al + 00024 74 14 je SHORT $LN54@strtold +$LN30@strtold: + 00026 0f b6 c0 movzx eax, al + 00029 f6 80 00 00 00 00 20 test BYTE PTR __ctype[eax], 32 ; 00000020H - 0003a 74 08 je SHORT $LN54@strtold - 0003c 8a 42 01 mov al, BYTE PTR [edx+1] + 00030 74 08 je SHORT $LN54@strtold + 00032 8a 42 01 mov al, BYTE PTR [edx+1] ; 29 : s++; - 0003f 42 inc edx - 00040 84 c0 test al, al - 00042 75 ec jne SHORT $LL30@strtold + 00035 42 inc edx + 00036 84 c0 test al, al + 00038 75 ec jne SHORT $LN30@strtold $LN54@strtold: ; 30 : ; 31 : if (*s == '+') - 00044 8a 02 mov al, BYTE PTR [edx] - 00046 3c 2b cmp al, 43 ; 0000002bH - 00048 74 0b je SHORT $LN58@strtold + 0003a 8a 02 mov al, BYTE PTR [edx] + 0003c 3c 2b cmp al, 43 ; 0000002bH + 0003e 74 0b je SHORT $LN126@strtold ; 32 : s++; ; 33 : else if (*s == '-') - 0004a 3c 2d cmp al, 45 ; 0000002dH - 0004c 75 08 jne SHORT $LN34@strtold + 00040 3c 2d cmp al, 45 ; 0000002dH + 00042 75 08 jne SHORT $LN34@strtold ; 34 : { ; 35 : sign = -1; - 0004e c7 45 fc ff ff - ff ff mov DWORD PTR _sign$1$[ebp], -1 -$LN58@strtold: + 00044 c7 45 fc ff ff + ff ff mov DWORD PTR _sign$[ebp], -1 +$LN126@strtold: ; 36 : s++; - 00055 42 inc edx + 0004b 42 inc edx $LN34@strtold: ; 37 : } ; 38 : ; 39 : while ((*s >= '0') && (*s <= '9')) - 00056 8a 02 mov al, BYTE PTR [edx] - 00058 f2 0f 10 15 00 - 00 00 00 movsd xmm2, QWORD PTR __real@4024000000000000 - 00060 3c 30 cmp al, 48 ; 00000030H - 00062 7c 23 jl SHORT $LN55@strtold -$LL25@strtold: - 00064 3c 39 cmp al, 57 ; 00000039H - 00066 7f 1f jg SHORT $LN55@strtold + 0004c 8a 02 mov al, BYTE PTR [edx] + 0004e dd 05 00 00 00 + 00 fld QWORD PTR __real@4024000000000000 + 00054 3c 30 cmp al, 48 ; 00000030H + 00056 7c 25 jl SHORT $LN55@strtold +$LN25@strtold: + 00058 3c 39 cmp al, 57 ; 00000039H + 0005a 7f 21 jg SHORT $LN55@strtold ; 40 : { ; 41 : flags |= 1; ; 42 : r *= 10.0L; ; 43 : r += *s - '0'; - 00068 0f be c0 movsx eax, al + 0005c 0f be c0 movsx eax, al ; 44 : s++; - 0006b 42 inc edx - 0006c 83 e8 30 sub eax, 48 ; 00000030H - 0006f f2 0f 59 ca mulsd xmm1, xmm2 - 00073 0b f7 or esi, edi - 00075 66 0f 6e c0 movd xmm0, eax - 00079 8a 02 mov al, BYTE PTR [edx] - 0007b f3 0f e6 c0 cvtdq2pd xmm0, xmm0 - 0007f f2 0f 58 c8 addsd xmm1, xmm0 - 00083 3c 30 cmp al, 48 ; 00000030H - 00085 7d dd jge SHORT $LL25@strtold + 0005f 42 inc edx + 00060 83 e8 30 sub eax, 48 ; 00000030H + 00063 0b fe or edi, esi + 00065 89 45 08 mov DWORD PTR tv357[ebp], eax + 00068 db 45 08 fild DWORD PTR tv357[ebp] + 0006b dd 5d f4 fstp QWORD PTR tv356[ebp] + 0006e dd 45 f4 fld QWORD PTR tv356[ebp] + 00071 d9 ca fxch ST(2) + 00073 8a 02 mov al, BYTE PTR [edx] + 00075 d8 c9 fmul ST(0), ST(1) + 00077 de c2 faddp ST(2), ST(0) + 00079 3c 30 cmp al, 48 ; 00000030H + 0007b 7d db jge SHORT $LN25@strtold $LN55@strtold: ; 45 : } ; 46 : ; 47 : if (*s == '.') - 00087 80 3a 2e cmp BYTE PTR [edx], 46 ; 0000002eH - 0008a 75 2d jne SHORT $LN56@strtold + 0007d 80 3a 2e cmp BYTE PTR [edx], 46 ; 0000002eH + 00080 75 2f jne SHORT $LN78@strtold ; 48 : { ; 49 : s++; ; 50 : while ((*s >= '0') && (*s <= '9')) - 0008c 8a 42 01 mov al, BYTE PTR [edx+1] - 0008f 42 inc edx - 00090 3c 30 cmp al, 48 ; 00000030H - 00092 7c 25 jl SHORT $LN56@strtold -$LL22@strtold: - 00094 3c 39 cmp al, 57 ; 00000039H - 00096 7f 21 jg SHORT $LN56@strtold + 00082 8a 42 01 mov al, BYTE PTR [edx+1] + 00085 42 inc edx + 00086 3c 30 cmp al, 48 ; 00000030H + 00088 7c 27 jl SHORT $LN78@strtold +$LN22@strtold: + 0008a 3c 39 cmp al, 57 ; 00000039H + 0008c 7f 23 jg SHORT $LN78@strtold ; 51 : { ; 52 : flags |= 2; ; 53 : r *= 10.0L; ; 54 : r += *s - '0'; - 00098 0f be c0 movsx eax, al + 0008e 0f be c0 movsx eax, al ; 55 : s++; - 0009b 42 inc edx - 0009c 83 e8 30 sub eax, 48 ; 00000030H - 0009f f2 0f 59 ca mulsd xmm1, xmm2 - 000a3 83 ce 02 or esi, 2 + 00091 42 inc edx + 00092 83 e8 30 sub eax, 48 ; 00000030H + 00095 83 cf 02 or edi, 2 + 00098 89 45 08 mov DWORD PTR tv351[ebp], eax ; 56 : ne++; - 000a6 43 inc ebx - 000a7 66 0f 6e c0 movd xmm0, eax - 000ab 8a 02 mov al, BYTE PTR [edx] - 000ad f3 0f e6 c0 cvtdq2pd xmm0, xmm0 - 000b1 f2 0f 58 c8 addsd xmm1, xmm0 - 000b5 3c 30 cmp al, 48 ; 00000030H - 000b7 7d db jge SHORT $LL22@strtold -$LN56@strtold: + 0009b 43 inc ebx + 0009c db 45 08 fild DWORD PTR tv351[ebp] + 0009f dd 5d f4 fstp QWORD PTR tv350[ebp] + 000a2 dd 45 f4 fld QWORD PTR tv350[ebp] + 000a5 d9 ca fxch ST(2) + 000a7 8a 02 mov al, BYTE PTR [edx] + 000a9 d8 c9 fmul ST(0), ST(1) + 000ab de c2 faddp ST(2), ST(0) + 000ad 3c 30 cmp al, 48 ; 00000030H + 000af 7d d9 jge SHORT $LN22@strtold +$LN78@strtold: + 000b1 dd d8 fstp ST(0) ; 57 : } ; 58 : } ; 59 : if (flags == 0) - 000b9 85 f6 test esi, esi - 000bb 75 12 jne SHORT $LN20@strtold + 000b3 85 ff test edi, edi + 000b5 75 16 jne SHORT $LN20@strtold ; 60 : { ; 61 : if (sret) - 000bd 8b 45 0c mov eax, DWORD PTR _sret$[ebp] - 000c0 85 c0 test eax, eax - 000c2 74 02 je SHORT $LN19@strtold + 000b7 8b 45 0c mov eax, DWORD PTR _sret$[ebp] + 000ba dd d8 fstp ST(0) + 000bc 85 c0 test eax, eax + 000be 0f 84 ad 00 00 + 00 je $LN31@strtold ; 62 : *sret = (char *)s; - 000c4 89 10 mov DWORD PTR [eax], edx -$LN19@strtold: - -; 63 : return 0.0L; - - 000c6 d9 ee fldz - 000c8 5f pop edi - 000c9 5e pop esi - 000ca 5b pop ebx + 000c4 5f pop edi + 000c5 5e pop esi + 000c6 89 10 mov DWORD PTR [eax], edx + 000c8 5b pop ebx ; 122 : } - 000cb 8b e5 mov esp, ebp - 000cd 5d pop ebp - 000ce c3 ret 0 + 000c9 8b e5 mov esp, ebp + 000cb 5d pop ebp + 000cc c3 ret 0 $LN20@strtold: +; 63 : return 0.0L; ; 64 : } ; 65 : ; 66 : if ((*s == 'e') || (*s == 'E')) - 000cf 8a 02 mov al, BYTE PTR [edx] - 000d1 3c 65 cmp al, 101 ; 00000065H - 000d3 74 04 je SHORT $LN17@strtold - 000d5 3c 45 cmp al, 69 ; 00000045H - 000d7 75 38 jne SHORT $LN11@strtold + 000cd 8a 02 mov al, BYTE PTR [edx] + 000cf 3c 65 cmp al, 101 ; 00000065H + 000d1 74 04 je SHORT $LN17@strtold + 000d3 3c 45 cmp al, 69 ; 00000045H + 000d5 75 38 jne SHORT $LN11@strtold $LN17@strtold: ; 67 : { ; 68 : s++; ; 69 : if (*s == '+') - 000d9 8a 42 01 mov al, BYTE PTR [edx+1] - 000dc 42 inc edx - 000dd 3c 2b cmp al, 43 ; 0000002bH - 000df 75 03 jne SHORT $LN16@strtold + 000d7 8a 42 01 mov al, BYTE PTR [edx+1] + 000da 42 inc edx + 000db 3c 2b cmp al, 43 ; 0000002bH + 000dd 75 03 jne SHORT $LN16@strtold ; 70 : s++; - 000e1 42 inc edx - 000e2 eb 08 jmp SHORT $LN36@strtold + 000df 42 inc edx + 000e0 eb 08 jmp SHORT $LN36@strtold $LN16@strtold: ; 71 : else if (*s == '-') - 000e4 3c 2d cmp al, 45 ; 0000002dH - 000e6 75 04 jne SHORT $LN36@strtold + 000e2 3c 2d cmp al, 45 ; 0000002dH + 000e4 75 04 jne SHORT $LN36@strtold ; 72 : { ; 73 : s++; - 000e8 42 inc edx + 000e6 42 inc edx ; 74 : esign = -1; - 000e9 83 cf ff or edi, -1 + 000e7 83 ce ff or esi, -1 $LN36@strtold: ; 75 : } ; 76 : while ((*s >= '0') && (*s <= '9')) - 000ec 8a 02 mov al, BYTE PTR [edx] - 000ee 3c 30 cmp al, 48 ; 00000030H - 000f0 7c 17 jl SHORT $LN57@strtold -$LL13@strtold: - 000f2 3c 39 cmp al, 57 ; 00000039H - 000f4 7f 13 jg SHORT $LN57@strtold + 000ea 8a 02 mov al, BYTE PTR [edx] + 000ec 3c 30 cmp al, 48 ; 00000030H + 000ee 7c 17 jl SHORT $LN57@strtold +$LN13@strtold: + 000f0 3c 39 cmp al, 57 ; 00000039H + 000f2 7f 13 jg SHORT $LN57@strtold ; 77 : { ; 78 : e *= 10; ; 79 : e += *s - '0'; - 000f6 0f be c0 movsx eax, al - 000f9 8d 0c 89 lea ecx, DWORD PTR [ecx+ecx*4] + 000f4 0f be c0 movsx eax, al + 000f7 8d 0c 89 lea ecx, DWORD PTR [ecx+ecx*4] ; 80 : s++; - 000fc 42 inc edx - 000fd 8d 49 e8 lea ecx, DWORD PTR [ecx-24] - 00100 8d 0c 48 lea ecx, DWORD PTR [eax+ecx*2] - 00103 8a 02 mov al, BYTE PTR [edx] - 00105 3c 30 cmp al, 48 ; 00000030H - 00107 7d e9 jge SHORT $LL13@strtold + 000fa 42 inc edx + 000fb 8d 49 e8 lea ecx, DWORD PTR [ecx-24] + 000fe 8d 0c 48 lea ecx, DWORD PTR [eax+ecx*2] + 00101 8a 02 mov al, BYTE PTR [edx] + 00103 3c 30 cmp al, 48 ; 00000030H + 00105 7d e9 jge SHORT $LN13@strtold $LN57@strtold: ; 81 : } ; 82 : } ; 83 : if (esign < 0) - 00109 85 ff test edi, edi - 0010b 79 04 jns SHORT $LN11@strtold + 00107 85 f6 test esi, esi + 00109 79 04 jns SHORT $LN11@strtold ; 84 : { ; 85 : esign = -esign; - 0010d f7 df neg edi + 0010b f7 de neg esi ; 86 : e = -e; - 0010f f7 d9 neg ecx + 0010d f7 d9 neg ecx $LN11@strtold: ; 87 : } ; 88 : e = e - ne; - 00111 2b cb sub ecx, ebx + 0010f 2b cb sub ecx, ebx ; 89 : if (e < -4096) - 00113 81 f9 00 f0 ff + 00111 81 f9 00 f0 ff ff cmp ecx, -4096 ; fffff000H - 00119 7d 0a jge SHORT $LN10@strtold + 00117 7d 0a jge SHORT $LN90@strtold ; 90 : { ; 91 : /* possibly subnormal number, 10^e would overflow */ ; 92 : r *= 1.0e-2048L; - 0011b f2 0f 59 cb mulsd xmm1, xmm3 + 00119 de c9 fmulp ST(1), ST(0) ; 93 : e += 2048; - 0011f 81 c1 00 08 00 + 0011b 81 c1 00 08 00 00 add ecx, 2048 ; 00000800H + 00121 eb 02 jmp SHORT $LN10@strtold +$LN90@strtold: + 00123 dd d9 fstp ST(1) $LN10@strtold: ; 94 : } @@ -360,7 +370,7 @@ $LN10@strtold: ; 98 : esign = -esign; - 0012b f7 df neg edi + 0012b f7 de neg esi $LN9@strtold: ; 99 : } @@ -379,87 +389,84 @@ $LN9@strtold: 0013a eb 04 jmp SHORT $LN53@strtold $LN8@strtold: 0013c 85 c9 test ecx, ecx - 0013e 74 2e je SHORT $LN2@strtold + 0013e 74 1f je SHORT $LN2@strtold $LN53@strtold: ; 103 : { ; 104 : double d = 1.0L; - 00140 f2 0f 10 15 00 - 00 00 00 movsd xmm2, QWORD PTR __real@3ff0000000000000 - 00148 b8 00 00 00 00 mov eax, OFFSET _powten - 0014d 8d 49 00 npad 3 -$LL6@strtold: + 00140 d9 e8 fld1 + 00142 b8 00 00 00 00 mov eax, OFFSET _powten +$LN6@strtold: ; 105 : l2powm1 = 0; ; 106 : while (e) ; 107 : { ; 108 : if (e & 1) - 00150 f6 c1 01 test cl, 1 - 00153 74 04 je SHORT $LN4@strtold + 00147 f6 c1 01 test cl, 1 + 0014a 74 02 je SHORT $LN4@strtold ; 109 : d *= powten[l2powm1]; - 00155 f2 0f 59 10 mulsd xmm2, QWORD PTR [eax] + 0014c dc 08 fmul QWORD PTR [eax] $LN4@strtold: ; 110 : e >>= 1; ; 111 : l2powm1++; - 00159 83 c0 08 add eax, 8 - 0015c d1 f9 sar ecx, 1 - 0015e 75 f0 jne SHORT $LL6@strtold + 0014e 83 c0 08 add eax, 8 + 00151 d1 f9 sar ecx, 1 + 00153 75 f2 jne SHORT $LN6@strtold ; 112 : } ; 113 : if (esign > 0) - 00160 85 ff test edi, edi - 00162 7e 06 jle SHORT $LN3@strtold + 00155 85 f6 test esi, esi + 00157 7e 04 jle SHORT $LN3@strtold ; 114 : r *= d; - 00164 f2 0f 59 ca mulsd xmm1, xmm2 + 00159 de c9 fmulp ST(1), ST(0) ; 115 : else - 00168 eb 04 jmp SHORT $LN2@strtold + 0015b eb 02 jmp SHORT $LN2@strtold $LN3@strtold: ; 116 : r /= d; - 0016a f2 0f 5e ca divsd xmm1, xmm2 + 0015d de f9 fdivp ST(1), ST(0) $LN2@strtold: ; 117 : } ; 118 : if (sret) - 0016e 8b 45 0c mov eax, DWORD PTR _sret$[ebp] - 00171 85 c0 test eax, eax - 00173 74 02 je SHORT $LN1@strtold + 0015f 8b 45 0c mov eax, DWORD PTR _sret$[ebp] + 00162 85 c0 test eax, eax + 00164 74 02 je SHORT $LN1@strtold ; 119 : *sret = (char *)s; - 00175 89 10 mov DWORD PTR [eax], edx + 00166 89 10 mov DWORD PTR [eax], edx $LN1@strtold: - 00177 66 0f 6e 45 fc movd xmm0, DWORD PTR _sign$1$[ebp] ; 120 : ; 121 : return r * sign; - 0017c f3 0f e6 c0 cvtdq2pd xmm0, xmm0 - 00180 5f pop edi - 00181 5e pop esi - 00182 5b pop ebx - 00183 f2 0f 59 c1 mulsd xmm0, xmm1 - 00187 f2 0f 11 45 f8 movsd QWORD PTR tv344[ebp], xmm0 - 0018c dd 45 f8 fld QWORD PTR tv344[ebp] + 00168 db 45 fc fild DWORD PTR _sign$[ebp] + 0016b dd 5d f4 fstp QWORD PTR tv335[ebp] + 0016e dc 4d f4 fmul QWORD PTR tv335[ebp] +$LN31@strtold: + 00171 5f pop edi + 00172 5e pop esi + 00173 5b pop ebx ; 122 : } - 0018f 8b e5 mov esp, ebp - 00191 5d pop ebp - 00192 c3 ret 0 + 00174 8b e5 mov esp, ebp + 00176 5d pop ebp + 00177 c3 ret 0 __strtold ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/strtoul.cod b/clib/mscv/CLib/strtoul.cod index d1427625c..b2a81700a 100644 --- a/clib/mscv/CLib/strtoul.cod +++ b/clib/mscv/CLib/strtoul.cod @@ -16,13 +16,12 @@ EXTRN __ctype:BYTE ; File c:\users\philip\documents\github\mollenos\clib\src\string\strtoul.c ; COMDAT _strtoul _TEXT SEGMENT -_cutlim$1$ = -12 ; size = 4 -_cutoff$1$ = -8 ; size = 4 -_neg$1$ = -4 ; size = 4 +_cutlim$1$ = -16 ; size = 4 +_cutoff$1$ = -12 ; size = 4 +_neg$1$ = -8 ; size = 4 +_any$1$ = -4 ; size = 4 _nptr$ = 8 ; size = 4 _endptr$ = 12 ; size = 4 -tv269 = 16 ; size = 4 -_any$1$ = 16 ; size = 4 _base$ = 16 ; size = 4 _strtoul PROC ; COMDAT @@ -30,20 +29,20 @@ _strtoul PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp - 00003 83 ec 0c sub esp, 12 ; 0000000cH - 00006 56 push esi + 00003 83 ec 10 sub esp, 16 ; 00000010H + 00006 53 push ebx + 00007 57 push edi ; 17 : const char *s = nptr; - 00007 8b 75 08 mov esi, DWORD PTR _nptr$[ebp] - 0000a 57 push edi + 00008 8b 7d 08 mov edi, DWORD PTR _nptr$[ebp] ; 18 : unsigned long acc; ; 19 : int c; ; 20 : unsigned long cutoff; ; 21 : int neg = 0, any, cutlim; - 0000b c7 45 fc 00 00 + 0000b c7 45 f8 00 00 00 00 mov DWORD PTR _neg$1$[ebp], 0 $LL25@strtoul: @@ -54,8 +53,8 @@ $LL25@strtoul: ; 26 : do { ; 27 : c = *s++; - 00012 0f be 0e movsx ecx, BYTE PTR [esi] - 00015 46 inc esi + 00012 0f be 0f movsx ecx, BYTE PTR [edi] + 00015 47 inc edi ; 28 : } while (isspace(c)); @@ -72,7 +71,7 @@ $LL25@strtoul: ; 30 : { ; 31 : neg = 1; - 00027 c7 45 fc 01 00 + 00027 c7 45 f8 01 00 00 00 mov DWORD PTR _neg$1$[ebp], 1 ; 32 : c = *s++; @@ -89,210 +88,217 @@ $LN38@strtoul: ; 35 : c = *s++; - 00035 0f be 0e movsx ecx, BYTE PTR [esi] - 00038 46 inc esi + 00035 0f be 0f movsx ecx, BYTE PTR [edi] + 00038 47 inc edi $LN20@strtoul: ; 36 : if ((base == 0 || base == 16) && ; 37 : c == '0' && (*s == 'x' || *s == 'X')) - 00039 53 push ebx - 0003a 8b 5d 10 mov ebx, DWORD PTR _base$[ebp] - 0003d 85 db test ebx, ebx - 0003f 74 05 je SHORT $LN18@strtoul - 00041 83 fb 10 cmp ebx, 16 ; 00000010H - 00044 75 1d jne SHORT $LN19@strtoul + 00039 8b 5d 10 mov ebx, DWORD PTR _base$[ebp] + 0003c 85 db test ebx, ebx + 0003e 74 05 je SHORT $LN18@strtoul + 00040 83 fb 10 cmp ebx, 16 ; 00000010H + 00043 75 1d jne SHORT $LN19@strtoul $LN18@strtoul: - 00046 83 f9 30 cmp ecx, 48 ; 00000030H - 00049 75 18 jne SHORT $LN19@strtoul - 0004b 8a 06 mov al, BYTE PTR [esi] - 0004d 3c 78 cmp al, 120 ; 00000078H - 0004f 74 04 je SHORT $LN17@strtoul - 00051 3c 58 cmp al, 88 ; 00000058H - 00053 75 0e jne SHORT $LN19@strtoul + 00045 83 f9 30 cmp ecx, 48 ; 00000030H + 00048 75 18 jne SHORT $LN19@strtoul + 0004a 8a 07 mov al, BYTE PTR [edi] + 0004c 3c 78 cmp al, 120 ; 00000078H + 0004e 74 04 je SHORT $LN17@strtoul + 00050 3c 58 cmp al, 88 ; 00000058H + 00052 75 0e jne SHORT $LN19@strtoul $LN17@strtoul: ; 38 : { ; 39 : c = s[1]; - 00055 0f be 4e 01 movsx ecx, BYTE PTR [esi+1] + 00054 0f be 4f 01 movsx ecx, BYTE PTR [edi+1] ; 40 : s += 2; ; 41 : base = 16; - 00059 bb 10 00 00 00 mov ebx, 16 ; 00000010H - 0005e 83 c6 02 add esi, 2 + 00058 bb 10 00 00 00 mov ebx, 16 ; 00000010H + 0005d 83 c7 02 add edi, 2 ; 42 : } ; 43 : if (base == 0) - 00061 eb 11 jmp SHORT $LN16@strtoul + 00060 eb 11 jmp SHORT $LN39@strtoul $LN19@strtoul: - 00063 85 db test ebx, ebx - 00065 75 0d jne SHORT $LN16@strtoul + 00062 85 db test ebx, ebx + 00064 75 10 jne SHORT $LN16@strtoul ; 44 : base = c == '0' ? 8 : 10; - 00067 83 f9 30 cmp ecx, 48 ; 00000030H - 0006a 0f 95 c3 setne bl - 0006d 8d 1c 5d 08 00 + 00066 83 f9 30 cmp ecx, 48 ; 00000030H + 00069 0f 95 c3 setne bl + 0006c 8d 1c 5d 08 00 00 00 lea ebx, DWORD PTR [ebx*2+8] +$LN39@strtoul: + 00073 89 5d 10 mov DWORD PTR _base$[ebp], ebx $LN16@strtoul: ; 45 : cutoff = (unsigned long)ULONG_MAX / (unsigned long)base; - 00074 83 c8 ff or eax, -1 + 00076 83 c8 ff or eax, -1 + 00079 33 d2 xor edx, edx + 0007b f7 f3 div ebx ; 46 : cutlim = (unsigned long)ULONG_MAX % (unsigned long)base; ; 47 : for (acc = 0, any = 0;; c = *s++) - 00077 c7 45 10 37 00 - 00 00 mov DWORD PTR tv269[ebp], 55 ; 00000037H - 0007e 33 d2 xor edx, edx - 00080 33 ff xor edi, edi - 00082 f7 f3 div ebx - 00084 89 55 f4 mov DWORD PTR _cutlim$1$[ebp], edx - 00087 33 d2 xor edx, edx - 00089 89 45 f8 mov DWORD PTR _cutoff$1$[ebp], eax + 0007d 33 db xor ebx, ebx + 0007f 89 45 f4 mov DWORD PTR _cutoff$1$[ebp], eax + 00082 8b 45 10 mov eax, DWORD PTR _base$[ebp] + 00085 89 55 f0 mov DWORD PTR _cutlim$1$[ebp], edx + 00088 89 5d fc mov DWORD PTR _any$1$[ebp], ebx + 0008b 56 push esi 0008c 8d 64 24 00 npad 4 $LL15@strtoul: ; 48 : { ; 49 : if (isdigit(c)) - 00090 0f b6 c1 movzx eax, cl - 00093 8a 80 00 00 00 - 00 mov al, BYTE PTR __ctype[eax] - 00099 a8 04 test al, 4 - 0009b 74 05 je SHORT $LN12@strtoul + 00090 0f b6 f1 movzx esi, cl + 00093 8a 96 00 00 00 + 00 mov dl, BYTE PTR __ctype[esi] + 00099 f6 c2 04 test dl, 4 + 0009c 74 05 je SHORT $LN12@strtoul ; 50 : c -= '0'; - 0009d 83 e9 30 sub ecx, 48 ; 00000030H - 000a0 eb 11 jmp SHORT $LN9@strtoul + 0009e 83 e9 30 sub ecx, 48 ; 00000030H + 000a1 eb 1a jmp SHORT $LN9@strtoul $LN12@strtoul: ; 51 : else if (isalpha(c)) - 000a2 a8 03 test al, 3 - 000a4 74 3c je SHORT $LN32@strtoul + 000a3 f6 c2 03 test dl, 3 + 000a6 74 4c je SHORT $LN32@strtoul ; 52 : c -= isupper(c) ? 'A' - 10 : 'a' - 10; - 000a6 a8 01 test al, 1 - 000a8 b8 57 00 00 00 mov eax, 87 ; 00000057H - 000ad 0f 45 45 10 cmovne eax, DWORD PTR tv269[ebp] - 000b1 2b c8 sub ecx, eax + 000a8 80 e2 01 and dl, 1 + 000ab 0f b6 c2 movzx eax, dl + 000ae f7 d8 neg eax + 000b0 1b c0 sbb eax, eax + 000b2 83 e0 e0 and eax, -32 ; ffffffe0H + 000b5 83 c0 57 add eax, 87 ; 00000057H + 000b8 2b c8 sub ecx, eax + 000ba 8b 45 10 mov eax, DWORD PTR _base$[ebp] $LN9@strtoul: ; 53 : else ; 54 : break; ; 55 : if (c >= base) - 000b3 3b cb cmp ecx, ebx - 000b5 7d 2b jge SHORT $LN32@strtoul + 000bd 3b c8 cmp ecx, eax + 000bf 7d 33 jge SHORT $LN32@strtoul ; 56 : break; ; 57 : if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim)) - 000b7 85 d2 test edx, edx - 000b9 78 1e js SHORT $LN6@strtoul - 000bb 8b 45 f8 mov eax, DWORD PTR _cutoff$1$[ebp] - 000be 3b f8 cmp edi, eax - 000c0 77 17 ja SHORT $LN6@strtoul - 000c2 75 05 jne SHORT $LN7@strtoul - 000c4 3b 4d f4 cmp ecx, DWORD PTR _cutlim$1$[ebp] - 000c7 7f 10 jg SHORT $LN6@strtoul + 000c1 83 7d fc 00 cmp DWORD PTR _any$1$[ebp], 0 + 000c5 7c 20 jl SHORT $LN6@strtoul + 000c7 8b 55 f4 mov edx, DWORD PTR _cutoff$1$[ebp] + 000ca 3b da cmp ebx, edx + 000cc 77 19 ja SHORT $LN6@strtoul + 000ce 75 05 jne SHORT $LN7@strtoul + 000d0 3b 4d f0 cmp ecx, DWORD PTR _cutlim$1$[ebp] + 000d3 7f 12 jg SHORT $LN6@strtoul $LN7@strtoul: ; 59 : else { ; 60 : any = 1; ; 61 : acc *= base; - 000c9 0f af fb imul edi, ebx - 000cc ba 01 00 00 00 mov edx, 1 + 000d5 0f af d8 imul ebx, eax + 000d8 c7 45 fc 01 00 + 00 00 mov DWORD PTR _any$1$[ebp], 1 ; 62 : acc += c; - 000d1 03 f9 add edi, ecx - 000d3 0f be 0e movsx ecx, BYTE PTR [esi] - 000d6 46 inc esi - 000d7 eb b7 jmp SHORT $LL15@strtoul + 000df 03 d9 add ebx, ecx + 000e1 0f be 0f movsx ecx, BYTE PTR [edi] + 000e4 47 inc edi + 000e5 eb a9 jmp SHORT $LL15@strtoul $LN6@strtoul: ; 46 : cutlim = (unsigned long)ULONG_MAX % (unsigned long)base; ; 47 : for (acc = 0, any = 0;; c = *s++) - 000d9 0f be 0e movsx ecx, BYTE PTR [esi] + 000e7 0f be 0f movsx ecx, BYTE PTR [edi] + 000ea 47 inc edi ; 58 : any = -1; - 000dc 83 ca ff or edx, -1 - 000df 46 inc esi - 000e0 eb ae jmp SHORT $LL15@strtoul + 000eb c7 45 fc ff ff + ff ff mov DWORD PTR _any$1$[ebp], -1 + 000f2 eb 9c jmp SHORT $LL15@strtoul $LN32@strtoul: - 000e2 89 55 10 mov DWORD PTR _any$1$[ebp], edx - 000e5 5b pop ebx ; 63 : } ; 64 : } ; 65 : if (any < 0) - 000e6 85 d2 test edx, edx - 000e8 79 13 jns SHORT $LN4@strtoul + 000f4 8b 45 fc mov eax, DWORD PTR _any$1$[ebp] + 000f7 5e pop esi + 000f8 85 c0 test eax, eax + 000fa 79 13 jns SHORT $LN4@strtoul ; 66 : { ; 67 : acc = ULONG_MAX; - 000ea 83 cf ff or edi, -1 + 000fc 83 cb ff or ebx, -1 ; 68 : errno = ERANGE; - 000ed e8 00 00 00 00 call ___errno - 000f2 8b 55 10 mov edx, DWORD PTR _any$1$[ebp] - 000f5 c7 00 22 00 00 + 000ff e8 00 00 00 00 call ___errno + 00104 c7 00 22 00 00 00 mov DWORD PTR [eax], 34 ; 00000022H - 000fb eb 08 jmp SHORT $LN2@strtoul + 0010a 8b 45 fc mov eax, DWORD PTR _any$1$[ebp] + 0010d eb 08 jmp SHORT $LN2@strtoul $LN4@strtoul: ; 69 : } ; 70 : else if (neg) - 000fd 83 7d fc 00 cmp DWORD PTR _neg$1$[ebp], 0 - 00101 74 02 je SHORT $LN2@strtoul + 0010f 83 7d f8 00 cmp DWORD PTR _neg$1$[ebp], 0 + 00113 74 02 je SHORT $LN2@strtoul ; 71 : acc = 0-acc; - 00103 f7 df neg edi + 00115 f7 db neg ebx $LN2@strtoul: ; 72 : if (endptr != 0) - 00105 8b 45 0c mov eax, DWORD PTR _endptr$[ebp] - 00108 85 c0 test eax, eax - 0010a 74 0c je SHORT $LN37@strtoul + 00117 8b 4d 0c mov ecx, DWORD PTR _endptr$[ebp] + 0011a 85 c9 test ecx, ecx + 0011c 74 0c je SHORT $LN37@strtoul ; 73 : *endptr = any ? (char *)((size_t)(s - 1)) : (char *)((size_t)nptr); - 0010c 8d 4e ff lea ecx, DWORD PTR [esi-1] - 0010f 85 d2 test edx, edx - 00111 75 03 jne SHORT $LN29@strtoul - 00113 8b 4d 08 mov ecx, DWORD PTR _nptr$[ebp] + 0011e 85 c0 test eax, eax + 00120 8d 47 ff lea eax, DWORD PTR [edi-1] + 00123 75 03 jne SHORT $LN29@strtoul + 00125 8b 45 08 mov eax, DWORD PTR _nptr$[ebp] $LN29@strtoul: - 00116 89 08 mov DWORD PTR [eax], ecx + 00128 89 01 mov DWORD PTR [ecx], eax $LN37@strtoul: + 0012a 5f pop edi ; 74 : return acc; - 00118 8b c7 mov eax, edi - 0011a 5f pop edi - 0011b 5e pop esi + 0012b 8b c3 mov eax, ebx + 0012d 5b pop ebx ; 75 : } - 0011c 8b e5 mov esp, ebp - 0011e 5d pop ebp - 0011f c3 ret 0 + 0012e 8b e5 mov esp, ebp + 00130 5d pop ebp + 00131 c3 ret 0 _strtoul ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/strtoull.cod b/clib/mscv/CLib/strtoull.cod index 5c93910db..ee559bae9 100644 --- a/clib/mscv/CLib/strtoull.cod +++ b/clib/mscv/CLib/strtoull.cod @@ -18,13 +18,11 @@ EXTRN __ctype:BYTE ; File c:\users\philip\documents\github\mollenos\clib\src\string\strtoull.c ; COMDAT _strtoull _TEXT SEGMENT -tv326 = -44 ; size = 8 -_acc$ = -44 ; size = 8 -tv182 = -36 ; size = 4 -tv181 = -32 ; size = 4 +tv184 = -36 ; size = 4 +tv183 = -32 ; size = 4 _cutlim$1$ = -28 ; size = 4 -_cutoff$2$ = -24 ; size = 4 -tv173 = -20 ; size = 4 +tv326 = -24 ; size = 8 +_cutoff$2$ = -20 ; size = 4 _neg$1$ = -16 ; size = 4 _cutoff$1$ = -12 ; size = 4 _any$1$ = -8 ; size = 4 @@ -38,7 +36,7 @@ _strtoull PROC ; COMDAT 00000 55 push ebp 00001 8b ec mov ebp, esp - 00003 83 ec 2c sub esp, 44 ; 0000002cH + 00003 83 ec 24 sub esp, 36 ; 00000024H 00006 56 push esi ; 17 : const char *s = nptr; @@ -162,187 +160,186 @@ $LN16@strtoull: 0008a 51 push ecx 0008b 6a ff push -1 0008d 6a ff push -1 - 0008f 89 4d dc mov DWORD PTR tv182[ebp], ecx - 00092 89 45 e0 mov DWORD PTR tv181[ebp], eax + 0008f 89 4d dc mov DWORD PTR tv184[ebp], ecx + 00092 89 45 e0 mov DWORD PTR tv183[ebp], eax 00095 e8 00 00 00 00 call __aulldvrm - 0009a 89 5d d8 mov DWORD PTR tv326[ebp+4], ebx - 0009d 0f 57 c0 xorps xmm0, xmm0 - 000a0 8b 5d fc mov ebx, DWORD PTR _c$1$[ebp] - 000a3 89 55 e8 mov DWORD PTR _cutoff$2$[ebp], edx + 0009a 89 5d ec mov DWORD PTR tv326[ebp+4], ebx ; 46 : cutlim = (unsigned long long)ULLONG_MAX % (unsigned long long)base; ; 47 : for (acc = 0, any = 0;; c = *s++) - 000a6 33 d2 xor edx, edx - 000a8 66 0f 13 45 d4 movlpd QWORD PTR _acc$[ebp], xmm0 - 000ad 8b 7d d8 mov edi, DWORD PTR _acc$[ebp+4] - 000b0 89 4d e4 mov DWORD PTR _cutlim$1$[ebp], ecx - 000b3 8b 4d d4 mov ecx, DWORD PTR _acc$[ebp] - 000b6 89 45 f4 mov DWORD PTR _cutoff$1$[ebp], eax - 000b9 89 55 f8 mov DWORD PTR _any$1$[ebp], edx - 000bc c7 45 ec 37 00 - 00 00 mov DWORD PTR tv173[ebp], 55 ; 00000037H + 0009d 33 ff xor edi, edi + 0009f 8b 5d fc mov ebx, DWORD PTR _c$1$[ebp] + 000a2 89 4d e4 mov DWORD PTR _cutlim$1$[ebp], ecx + 000a5 33 c9 xor ecx, ecx + 000a7 89 55 ec mov DWORD PTR _cutoff$2$[ebp], edx + 000aa 33 d2 xor edx, edx + 000ac 89 45 f4 mov DWORD PTR _cutoff$1$[ebp], eax + 000af 89 55 f8 mov DWORD PTR _any$1$[ebp], edx $LL15@strtoull: ; 48 : { ; 49 : if (isdigit(c)) - 000c3 0f b6 c3 movzx eax, bl - 000c6 8a 80 00 00 00 + 000b2 0f b6 c3 movzx eax, bl + 000b5 8a 80 00 00 00 00 mov al, BYTE PTR __ctype[eax] - 000cc a8 04 test al, 4 - 000ce 74 05 je SHORT $LN12@strtoull + 000bb a8 04 test al, 4 + 000bd 74 05 je SHORT $LN12@strtoull ; 50 : c -= '0'; - 000d0 83 eb 30 sub ebx, 48 ; 00000030H - 000d3 eb 11 jmp SHORT $LN9@strtoull + 000bf 83 eb 30 sub ebx, 48 ; 00000030H + 000c2 eb 15 jmp SHORT $LN9@strtoull $LN12@strtoull: ; 51 : else if (isalpha(c)) - 000d5 a8 03 test al, 3 - 000d7 74 69 je SHORT $LN32@strtoull + 000c4 a8 03 test al, 3 + 000c6 74 70 je SHORT $LN32@strtoull ; 52 : c -= isupper(c) ? 'A' - 10 : 'a' - 10; - 000d9 a8 01 test al, 1 - 000db b8 57 00 00 00 mov eax, 87 ; 00000057H - 000e0 0f 45 45 ec cmovne eax, DWORD PTR tv173[ebp] - 000e4 2b d8 sub ebx, eax + 000c8 24 01 and al, 1 + 000ca 0f b6 c0 movzx eax, al + 000cd f7 d8 neg eax + 000cf 1b c0 sbb eax, eax + 000d1 83 e0 e0 and eax, -32 ; ffffffe0H + 000d4 83 c0 57 add eax, 87 ; 00000057H + 000d7 2b d8 sub ebx, eax $LN9@strtoull: ; 53 : else ; 54 : break; ; 55 : if (c >= base) - 000e6 3b 5d 10 cmp ebx, DWORD PTR _base$[ebp] - 000e9 7d 57 jge SHORT $LN32@strtoull + 000d9 3b 5d 10 cmp ebx, DWORD PTR _base$[ebp] + 000dc 7d 5a jge SHORT $LN32@strtoull ; 56 : break; ; 57 : if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim)) - 000eb 85 d2 test edx, edx - 000ed 78 47 js SHORT $LN6@strtoull - 000ef 8b 55 e8 mov edx, DWORD PTR _cutoff$2$[ebp] - 000f2 3b fa cmp edi, edx - 000f4 77 40 ja SHORT $LN6@strtoull - 000f6 8b 45 f4 mov eax, DWORD PTR _cutoff$1$[ebp] - 000f9 72 04 jb SHORT $LN37@strtoull - 000fb 3b c8 cmp ecx, eax - 000fd 77 37 ja SHORT $LN6@strtoull + 000de 85 d2 test edx, edx + 000e0 78 47 js SHORT $LN6@strtoull + 000e2 8b 55 ec mov edx, DWORD PTR _cutoff$2$[ebp] + 000e5 3b fa cmp edi, edx + 000e7 77 40 ja SHORT $LN6@strtoull + 000e9 8b 45 f4 mov eax, DWORD PTR _cutoff$1$[ebp] + 000ec 72 04 jb SHORT $LN37@strtoull + 000ee 3b c8 cmp ecx, eax + 000f0 77 37 ja SHORT $LN6@strtoull $LN37@strtoull: - 000ff 3b c8 cmp ecx, eax - 00101 75 09 jne SHORT $LN7@strtoull - 00103 3b fa cmp edi, edx - 00105 75 05 jne SHORT $LN7@strtoull - 00107 3b 5d e4 cmp ebx, DWORD PTR _cutlim$1$[ebp] - 0010a 7f 2a jg SHORT $LN6@strtoull + 000f2 3b c8 cmp ecx, eax + 000f4 75 09 jne SHORT $LN7@strtoull + 000f6 3b fa cmp edi, edx + 000f8 75 05 jne SHORT $LN7@strtoull + 000fa 3b 5d e4 cmp ebx, DWORD PTR _cutlim$1$[ebp] + 000fd 7f 2a jg SHORT $LN6@strtoull $LN7@strtoull: ; 59 : else { ; 60 : any = 1; ; 61 : acc *= base; - 0010c 57 push edi - 0010d 51 push ecx - 0010e ff 75 e0 push DWORD PTR tv181[ebp] - 00111 c7 45 f8 01 00 + 000ff 57 push edi + 00100 51 push ecx + 00101 ff 75 e0 push DWORD PTR tv183[ebp] + 00104 c7 45 f8 01 00 00 00 mov DWORD PTR _any$1$[ebp], 1 - 00118 ff 75 dc push DWORD PTR tv182[ebp] - 0011b e8 00 00 00 00 call __allmul - 00120 8b c8 mov ecx, eax - 00122 8b fa mov edi, edx + 0010b ff 75 dc push DWORD PTR tv184[ebp] + 0010e e8 00 00 00 00 call __allmul + 00113 8b c8 mov ecx, eax + 00115 8b fa mov edi, edx ; 62 : acc += c; - 00124 8b c3 mov eax, ebx - 00126 0f be 1e movsx ebx, BYTE PTR [esi] - 00129 99 cdq - 0012a 03 c8 add ecx, eax - 0012c 13 fa adc edi, edx - 0012e ba 01 00 00 00 mov edx, 1 - 00133 46 inc esi - 00134 eb 8d jmp SHORT $LL15@strtoull + 00117 8b c3 mov eax, ebx + 00119 0f be 1e movsx ebx, BYTE PTR [esi] + 0011c 99 cdq + 0011d 03 c8 add ecx, eax + 0011f 13 fa adc edi, edx + 00121 ba 01 00 00 00 mov edx, 1 + 00126 46 inc esi + 00127 eb 89 jmp SHORT $LL15@strtoull $LN6@strtoull: ; 46 : cutlim = (unsigned long long)ULLONG_MAX % (unsigned long long)base; ; 47 : for (acc = 0, any = 0;; c = *s++) - 00136 0f be 1e movsx ebx, BYTE PTR [esi] + 00129 0f be 1e movsx ebx, BYTE PTR [esi] ; 58 : any = -1; - 00139 83 ca ff or edx, -1 - 0013c 89 55 f8 mov DWORD PTR _any$1$[ebp], edx - 0013f 46 inc esi - 00140 eb 81 jmp SHORT $LL15@strtoull + 0012c 83 ca ff or edx, -1 + 0012f 89 55 f8 mov DWORD PTR _any$1$[ebp], edx + 00132 46 inc esi + 00133 e9 7a ff ff ff jmp $LL15@strtoull $LN32@strtoull: - 00142 5b pop ebx + 00138 5b pop ebx ; 63 : } ; 64 : } ; 65 : if (any < 0) - 00143 85 d2 test edx, edx - 00145 79 16 jns SHORT $LN4@strtoull + 00139 85 d2 test edx, edx + 0013b 79 16 jns SHORT $LN4@strtoull ; 66 : { ; 67 : acc = ULLONG_MAX; - 00147 83 cf ff or edi, -1 + 0013d 83 cf ff or edi, -1 ; 68 : errno = ERANGE; - 0014a e8 00 00 00 00 call ___errno - 0014f 8b 55 f8 mov edx, DWORD PTR _any$1$[ebp] - 00152 83 c9 ff or ecx, -1 - 00155 c7 00 22 00 00 + 00140 e8 00 00 00 00 call ___errno + 00145 8b 55 f8 mov edx, DWORD PTR _any$1$[ebp] + 00148 83 c9 ff or ecx, -1 + 0014b c7 00 22 00 00 00 mov DWORD PTR [eax], 34 ; 00000022H - 0015b eb 0d jmp SHORT $LN2@strtoull + 00151 eb 0d jmp SHORT $LN2@strtoull $LN4@strtoull: ; 69 : } ; 70 : else if (neg) - 0015d 83 7d f0 00 cmp DWORD PTR _neg$1$[ebp], 0 - 00161 74 07 je SHORT $LN2@strtoull + 00153 83 7d f0 00 cmp DWORD PTR _neg$1$[ebp], 0 + 00157 74 07 je SHORT $LN2@strtoull ; 71 : acc = 0-acc; - 00163 f7 d9 neg ecx - 00165 83 d7 00 adc edi, 0 - 00168 f7 df neg edi + 00159 f7 d9 neg ecx + 0015b 83 d7 00 adc edi, 0 + 0015e f7 df neg edi $LN2@strtoull: ; 72 : if (endptr != 0) - 0016a 8b 45 0c mov eax, DWORD PTR _endptr$[ebp] - 0016d 85 c0 test eax, eax - 0016f 74 0c je SHORT $LN38@strtoull + 00160 8b 45 0c mov eax, DWORD PTR _endptr$[ebp] + 00163 85 c0 test eax, eax + 00165 74 0c je SHORT $LN38@strtoull ; 73 : *endptr = any ? (char *)((size_t)(s - 1)) : (char *)((size_t)nptr); - 00171 85 d2 test edx, edx - 00173 8d 56 ff lea edx, DWORD PTR [esi-1] - 00176 75 03 jne SHORT $LN29@strtoull - 00178 8b 55 08 mov edx, DWORD PTR _nptr$[ebp] + 00167 85 d2 test edx, edx + 00169 8d 56 ff lea edx, DWORD PTR [esi-1] + 0016c 75 03 jne SHORT $LN29@strtoull + 0016e 8b 55 08 mov edx, DWORD PTR _nptr$[ebp] $LN29@strtoull: - 0017b 89 10 mov DWORD PTR [eax], edx + 00171 89 10 mov DWORD PTR [eax], edx $LN38@strtoull: ; 74 : return acc; - 0017d 8b d7 mov edx, edi - 0017f 8b c1 mov eax, ecx - 00181 5f pop edi - 00182 5e pop esi + 00173 8b d7 mov edx, edi + 00175 8b c1 mov eax, ecx + 00177 5f pop edi + 00178 5e pop esi ; 75 : } - 00183 8b e5 mov esp, ebp - 00185 5d pop ebp - 00186 c3 ret 0 + 00179 8b e5 mov esp, ebp + 0017b 5d pop ebp + 0017c c3 ret 0 _strtoull ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/tanh.cod b/clib/mscv/CLib/tanh.cod index 1935ae9d2..78ec69f74 100644 --- a/clib/mscv/CLib/tanh.cod +++ b/clib/mscv/CLib/tanh.cod @@ -14,7 +14,7 @@ PUBLIC __real@3ff0000000000000 PUBLIC __real@4049000000000000 PUBLIC __real@bff0000000000000 PUBLIC __real@c049000000000000 -EXTRN __libm_sse2_exp_precise:PROC +EXTRN __CIexp:PROC EXTRN __fltused:DWORD ; COMDAT __real@c049000000000000 CONST SEGMENT @@ -36,7 +36,6 @@ CONST ENDS ; File c:\users\philip\documents\github\mollenos\clib\src\math\tanh.c ; COMDAT _tanh _TEXT SEGMENT -tv131 = 8 ; size = 8 _x$ = 8 ; size = 8 _tanh PROC ; COMDAT @@ -47,68 +46,73 @@ _tanh PROC ; COMDAT ; 14 : if (x > 50) - 00003 f2 0f 10 4d 08 movsd xmm1, QWORD PTR _x$[ebp] - 00008 66 0f 2f 0d 00 - 00 00 00 comisd xmm1, QWORD PTR __real@4049000000000000 - 00010 76 04 jbe SHORT $LN4@tanh + 00003 dd 05 00 00 00 + 00 fld QWORD PTR __real@4049000000000000 + 00009 dd 45 08 fld QWORD PTR _x$[ebp] + 0000c d8 d1 fcom ST(1) + 0000e df e0 fnstsw ax + 00010 dd d9 fstp ST(1) + 00012 f6 c4 41 test ah, 65 ; 00000041H + 00015 75 06 jne SHORT $LN4@tanh + 00017 dd d8 fstp ST(0) ; 15 : return 1; - 00012 d9 e8 fld1 + 00019 d9 e8 fld1 ; 23 : } ; 24 : } - 00014 5d pop ebp - 00015 c3 ret 0 + 0001b 5d pop ebp + 0001c c3 ret 0 $LN4@tanh: ; 16 : else if (x < -50) - 00016 f2 0f 10 05 00 - 00 00 00 movsd xmm0, QWORD PTR __real@c049000000000000 - 0001e 66 0f 2f c1 comisd xmm0, xmm1 - 00022 76 08 jbe SHORT $LN2@tanh + 0001d dd 05 00 00 00 + 00 fld QWORD PTR __real@c049000000000000 + 00023 d8 d9 fcomp ST(1) + 00025 df e0 fnstsw ax + 00027 f6 c4 41 test ah, 65 ; 00000041H + 0002a 75 0a jne SHORT $LN2@tanh + 0002c dd d8 fstp ST(0) ; 17 : return -1; - 00024 dd 05 00 00 00 + 0002e dd 05 00 00 00 00 fld QWORD PTR __real@bff0000000000000 ; 23 : } ; 24 : } - 0002a 5d pop ebp - 0002b c3 ret 0 + 00034 5d pop ebp + 00035 c3 ret 0 $LN2@tanh: ; 18 : else ; 19 : { ; 20 : const double ebig = exp(x); - 0002c 0f 28 c1 movaps xmm0, xmm1 - 0002f e8 00 00 00 00 call __libm_sse2_exp_precise + 00036 e8 00 00 00 00 call __CIexp ; 21 : const double esmall = 1.0/ebig; - 00034 f2 0f 10 15 00 - 00 00 00 movsd xmm2, QWORD PTR __real@3ff0000000000000 + 0003b d9 e8 fld1 + 0003d d8 f1 fdiv ST(0), ST(1) ; 22 : return (ebig - esmall) / (ebig + esmall); - 0003c 66 0f 28 c8 movapd xmm1, xmm0 - 00040 f2 0f 5e d0 divsd xmm2, xmm0 - 00044 f2 0f 5c ca subsd xmm1, xmm2 - 00048 f2 0f 58 d0 addsd xmm2, xmm0 - 0004c f2 0f 5e ca divsd xmm1, xmm2 - 00050 f2 0f 11 4d 08 movsd QWORD PTR tv131[ebp], xmm1 - 00055 dd 45 08 fld QWORD PTR tv131[ebp] + 0003f d9 c1 fld ST(1) + 00041 d8 e1 fsub ST(0), ST(1) + 00043 d9 c9 fxch ST(1) + 00045 de c2 faddp ST(2), ST(0) + 00047 de f1 fdivrp ST(1), ST(0) ; 23 : } ; 24 : } - 00058 5d pop ebp - 00059 c3 ret 0 + 00049 5d pop ebp + 0004a c3 ret 0 _tanh ENDP _TEXT ENDS END diff --git a/clib/mscv/CLib/vfprintf.cod b/clib/mscv/CLib/vfprintf.cod index a1f0adcad..3fc15109c 100644 --- a/clib/mscv/CLib/vfprintf.cod +++ b/clib/mscv/CLib/vfprintf.cod @@ -10,9 +10,9 @@ INCLUDELIB MSVCRT INCLUDELIB OLDNAMES _DATA SEGMENT -$SG1992 DB 'r+', 00H +$SG1995 DB 'r+', 00H ORG $+1 -$SG1993 DB 'c:/system/mlog.txt', 00H +$SG1996 DB 'c:/system/mlog.txt', 00H _DATA ENDS PUBLIC _vfprintf EXTRN _fclose:PROC @@ -115,8 +115,8 @@ $LN3@vfprintf: ; 25 : //Ok, writing to sys-log ; 26 : FILE *temp = fopen("c:/system/mlog.txt", "r+"); - 00065 68 00 00 00 00 push OFFSET $SG1992 - 0006a 68 00 00 00 00 push OFFSET $SG1993 + 00065 68 00 00 00 00 push OFFSET $SG1995 + 0006a 68 00 00 00 00 push OFFSET $SG1996 0006f e8 00 00 00 00 call _fopen 00074 8b f8 mov edi, eax 00076 83 c4 08 add esp, 8 diff --git a/clib/src/stdio/fflush.c b/clib/src/stdio/fflush.c new file mode 100644 index 000000000..e6447e672 --- /dev/null +++ b/clib/src/stdio/fflush.c @@ -0,0 +1,51 @@ +/* MollenOS +* +* Copyright 2011 - 2016, Philip Meulengracht +* +* This program is free software : you can redistribute it and / or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation ? , either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program.If not, see . +* +* +* MollenOS C Library - File Flush +*/ + +/* Includes */ +#include +#include +#include +#include +#include + +/* The fflush + * Closes a file handle and frees + * resources associated */ +int fflush(FILE * stream) +{ + /* Variables */ + int RetVal = 0; + + /* Sanity input */ + if (stream == NULL) { + _set_errno(EINVAL); + return EOF; + } + + /* Syscall */ + RetVal = Syscall1(MOLLENOS_SYSCALL_VFSFLUSH, MOLLENOS_SYSCALL_PARAM(stream)); + + /* Clear error */ + _set_errno(EOK); + + /* Done */ + return 0; +} \ No newline at end of file diff --git a/install/Hdd/Shared/Includes/png.h b/install/Hdd/Shared/Includes/png.h new file mode 100644 index 000000000..d6d115ebe --- /dev/null +++ b/install/Hdd/Shared/Includes/png.h @@ -0,0 +1,3130 @@ + +/* png.h - header file for PNG reference library + * + * libpng version 1.6.21, January 15, 2016 + * + * Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) + * + * This code is released under the libpng license (See LICENSE, below) + * + * Authors and maintainers: + * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat + * libpng versions 0.89, June 1996, through 0.96, May 1997: Andreas Dilger + * libpng versions 0.97, January 1998, through 1.6.21, January 15, 2016: + * Glenn Randers-Pehrson. + * See also "Contributing Authors", below. + */ + +/* + * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE: + * + * If you modify libpng you may insert additional notices immediately following + * this sentence. + * + * This code is released under the libpng license. + * + * libpng versions 1.0.7, July 1, 2000, through 1.6.21, January 15, 2016, are + * Copyright (c) 2000-2002, 2004, 2006-2016 Glenn Randers-Pehrson, are + * derived from libpng-1.0.6, and are distributed according to the same + * disclaimer and license as libpng-1.0.6 with the following individuals + * added to the list of Contributing Authors: + * + * Simon-Pierre Cadieux + * Eric S. Raymond + * Mans Rullgard + * Cosmin Truta + * Gilles Vollant + * James Yu + * + * and with the following additions to the disclaimer: + * + * There is no warranty against interference with your enjoyment of the + * library or against infringement. There is no warranty that our + * efforts or the library will fulfill any of your particular purposes + * or needs. This library is provided with all faults, and the entire + * risk of satisfactory quality, performance, accuracy, and effort is with + * the user. + * + * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are + * Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from + * libpng-0.96, and are distributed according to the same disclaimer and + * license as libpng-0.96, with the following individuals added to the list + * of Contributing Authors: + * + * Tom Lane + * Glenn Randers-Pehrson + * Willem van Schaik + * + * libpng versions 0.89, June 1996, through 0.96, May 1997, are + * Copyright (c) 1996-1997 Andreas Dilger, are derived from libpng-0.88, + * and are distributed according to the same disclaimer and license as + * libpng-0.88, with the following individuals added to the list of + * Contributing Authors: + * + * John Bowler + * Kevin Bracey + * Sam Bushell + * Magnus Holmgren + * Greg Roelofs + * Tom Tanner + * + * libpng versions 0.5, May 1995, through 0.88, January 1996, are + * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * For the purposes of this copyright and license, "Contributing Authors" + * is defined as the following set of individuals: + * + * Andreas Dilger + * Dave Martindale + * Guy Eric Schalnat + * Paul Schmidt + * Tim Wegner + * + * The PNG Reference Library is supplied "AS IS". The Contributing Authors + * and Group 42, Inc. disclaim all warranties, expressed or implied, + * including, without limitation, the warranties of merchantability and of + * fitness for any purpose. The Contributing Authors and Group 42, Inc. + * assume no liability for direct, indirect, incidental, special, exemplary, + * or consequential damages, which may result from the use of the PNG + * Reference Library, even if advised of the possibility of such damage. + * + * Permission is hereby granted to use, copy, modify, and distribute this + * source code, or portions hereof, for any purpose, without fee, subject + * to the following restrictions: + * + * 1. The origin of this source code must not be misrepresented. + * + * 2. Altered versions must be plainly marked as such and must not + * be misrepresented as being the original source. + * + * 3. This Copyright notice may not be removed or altered from any + * source or altered source distribution. + * + * The Contributing Authors and Group 42, Inc. specifically permit, without + * fee, and encourage the use of this source code as a component to + * supporting the PNG file format in commercial products. If you use this + * source code in a product, acknowledgment is not required but would be + * appreciated. + * + * END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE. + */ + +/* + * A "png_get_copyright" function is available, for convenient use in "about" + * boxes and the like: + * + * printf("%s", png_get_copyright(NULL)); + * + * Also, the PNG logo (in PNG format, of course) is supplied in the + * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31). + */ + +/* + * Libpng is OSI Certified Open Source Software. OSI Certified Open Source is + * a certification mark of the Open Source Initiative. OSI has not addressed + * the additional disclaimers inserted at version 1.0.7. + */ + +/* + * The contributing authors would like to thank all those who helped + * with testing, bug fixes, and patience. This wouldn't have been + * possible without all of you. + * + * Thanks to Frank J. T. Wojcik for helping with the documentation. + */ + +/* Note about libpng version numbers: + * + * Due to various miscommunications, unforeseen code incompatibilities + * and occasional factors outside the authors' control, version numbering + * on the library has not always been consistent and straightforward. + * The following table summarizes matters since version 0.89c, which was + * the first widely used release: + * + * source png.h png.h shared-lib + * version string int version + * ------- ------ ----- ---------- + * 0.89c "1.0 beta 3" 0.89 89 1.0.89 + * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90] + * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95] + * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96] + * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97] + * 0.97c 0.97 97 2.0.97 + * 0.98 0.98 98 2.0.98 + * 0.99 0.99 98 2.0.99 + * 0.99a-m 0.99 99 2.0.99 + * 1.00 1.00 100 2.1.0 [100 should be 10000] + * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000] + * 1.0.1 png.h string is 10001 2.1.0 + * 1.0.1a-e identical to the 10002 from here on, the shared library + * 1.0.2 source version) 10002 is 2.V where V is the source code + * 1.0.2a-b 10003 version, except as noted. + * 1.0.3 10003 + * 1.0.3a-d 10004 + * 1.0.4 10004 + * 1.0.4a-f 10005 + * 1.0.5 (+ 2 patches) 10005 + * 1.0.5a-d 10006 + * 1.0.5e-r 10100 (not source compatible) + * 1.0.5s-v 10006 (not binary compatible) + * 1.0.6 (+ 3 patches) 10006 (still binary incompatible) + * 1.0.6d-f 10007 (still binary incompatible) + * 1.0.6g 10007 + * 1.0.6h 10007 10.6h (testing xy.z so-numbering) + * 1.0.6i 10007 10.6i + * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0) + * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible) + * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible) + * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible) + * 1.0.7 1 10007 (still compatible) + * ... + * 1.0.19 10 10019 10.so.0.19[.0] + * ... + * 1.2.53 13 10253 12.so.0.53[.0] + * ... + * 1.5.23 15 10523 15.so.15.23[.0] + * ... + * 1.6.21 16 10621 16.so.16.21[.0] + * + * Henceforth the source version will match the shared-library major + * and minor numbers; the shared-library major version number will be + * used for changes in backward compatibility, as it is intended. The + * PNG_LIBPNG_VER macro, which is not used within libpng but is available + * for applications, is an unsigned integer of the form xyyzz corresponding + * to the source version x.y.z (leading zeros in y and z). Beta versions + * were given the previous public release number plus a letter, until + * version 1.0.6j; from then on they were given the upcoming public + * release number plus "betaNN" or "rcNN". + * + * Binary incompatibility exists only when applications make direct access + * to the info_ptr or png_ptr members through png.h, and the compiled + * application is loaded with a different version of the library. + * + * DLLNUM will change each time there are forward or backward changes + * in binary compatibility (e.g., when a new feature is added). + * + * See libpng.txt or libpng.3 for more information. The PNG specification + * is available as a W3C Recommendation and as an ISO Specification, + * + * + * If you just need to read a PNG file and don't want to read the documentation + * skip to the end of this file and read the section entitled 'simplified API'. + */ + +/* Version information for png.h - this should match the version in png.c */ +#define PNG_LIBPNG_VER_STRING "1.6.21" +#define PNG_HEADER_VERSION_STRING \ + " libpng version 1.6.21 - January 15, 2016\n" + +#define PNG_LIBPNG_VER_SONUM 16 +#define PNG_LIBPNG_VER_DLLNUM 16 + +/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */ +#define PNG_LIBPNG_VER_MAJOR 1 +#define PNG_LIBPNG_VER_MINOR 6 +#define PNG_LIBPNG_VER_RELEASE 21 + +/* This should match the numeric part of the final component of + * PNG_LIBPNG_VER_STRING, omitting any leading zero: + */ + +#define PNG_LIBPNG_VER_BUILD 0 + +/* Release Status */ +#define PNG_LIBPNG_BUILD_ALPHA 1 +#define PNG_LIBPNG_BUILD_BETA 2 +#define PNG_LIBPNG_BUILD_RC 3 +#define PNG_LIBPNG_BUILD_STABLE 4 +#define PNG_LIBPNG_BUILD_RELEASE_STATUS_MASK 7 + +/* Release-Specific Flags */ +#define PNG_LIBPNG_BUILD_PATCH 8 /* Can be OR'ed with + PNG_LIBPNG_BUILD_STABLE only */ +#define PNG_LIBPNG_BUILD_PRIVATE 16 /* Cannot be OR'ed with + PNG_LIBPNG_BUILD_SPECIAL */ +#define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with + PNG_LIBPNG_BUILD_PRIVATE */ + +#define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_STABLE + +/* Careful here. At one time, Guy wanted to use 082, but that would be octal. + * We must not include leading zeros. + * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only + * version 1.0.0 was mis-numbered 100 instead of 10000). From + * version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release + */ +#define PNG_LIBPNG_VER 10621 /* 1.6.21 */ + +/* Library configuration: these options cannot be changed after + * the library has been built. + */ +#ifndef PNGLCONF_H + /* If pnglibconf.h is missing, you can + * copy scripts/pnglibconf.h.prebuilt to pnglibconf.h + */ +# include "pnglibconf.h" +#endif + +#ifndef PNG_VERSION_INFO_ONLY + /* Machine specific configuration. */ +# include "pngconf.h" +#endif + +/* + * Added at libpng-1.2.8 + * + * Ref MSDN: Private as priority over Special + * VS_FF_PRIVATEBUILD File *was not* built using standard release + * procedures. If this value is given, the StringFileInfo block must + * contain a PrivateBuild string. + * + * VS_FF_SPECIALBUILD File *was* built by the original company using + * standard release procedures but is a variation of the standard + * file of the same version number. If this value is given, the + * StringFileInfo block must contain a SpecialBuild string. + */ + +#ifdef PNG_USER_PRIVATEBUILD /* From pnglibconf.h */ +# define PNG_LIBPNG_BUILD_TYPE \ + (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE) +#else +# ifdef PNG_LIBPNG_SPECIALBUILD +# define PNG_LIBPNG_BUILD_TYPE \ + (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL) +# else +# define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE) +# endif +#endif + +#ifndef PNG_VERSION_INFO_ONLY + +/* Inhibit C++ name-mangling for libpng functions but not for system calls. */ +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/* Version information for C files, stored in png.c. This had better match + * the version above. + */ +#define png_libpng_ver png_get_header_ver(NULL) + +/* This file is arranged in several sections: + * + * 1. [omitted] + * 2. Any configuration options that can be specified by for the application + * code when it is built. (Build time configuration is in pnglibconf.h) + * 3. Type definitions (base types are defined in pngconf.h), structure + * definitions. + * 4. Exported library functions. + * 5. Simplified API. + * 6. Implementation options. + * + * The library source code has additional files (principally pngpriv.h) that + * allow configuration of the library. + */ + +/* Section 1: [omitted] */ + +/* Section 2: run time configuration + * See pnglibconf.h for build time configuration + * + * Run time configuration allows the application to choose between + * implementations of certain arithmetic APIs. The default is set + * at build time and recorded in pnglibconf.h, but it is safe to + * override these (and only these) settings. Note that this won't + * change what the library does, only application code, and the + * settings can (and probably should) be made on a per-file basis + * by setting the #defines before including png.h + * + * Use macros to read integers from PNG data or use the exported + * functions? + * PNG_USE_READ_MACROS: use the macros (see below) Note that + * the macros evaluate their argument multiple times. + * PNG_NO_USE_READ_MACROS: call the relevant library function. + * + * Use the alternative algorithm for compositing alpha samples that + * does not use division? + * PNG_READ_COMPOSITE_NODIV_SUPPORTED: use the 'no division' + * algorithm. + * PNG_NO_READ_COMPOSITE_NODIV: use the 'division' algorithm. + * + * How to handle benign errors if PNG_ALLOW_BENIGN_ERRORS is + * false? + * PNG_ALLOW_BENIGN_ERRORS: map calls to the benign error + * APIs to png_warning. + * Otherwise the calls are mapped to png_error. + */ + +/* Section 3: type definitions, including structures and compile time + * constants. + * See pngconf.h for base types that vary by machine/system + */ + +/* This triggers a compiler error in png.c, if png.c and png.h + * do not agree upon the version number. + */ +typedef char* png_libpng_version_1_6_21; + +/* Basic control structions. Read libpng-manual.txt or libpng.3 for more info. + * + * png_struct is the cache of information used while reading or writing a single + * PNG file. One of these is always required, although the simplified API + * (below) hides the creation and destruction of it. + */ +typedef struct png_struct_def png_struct; +typedef const png_struct * png_const_structp; +typedef png_struct * png_structp; +typedef png_struct * * png_structpp; + +/* png_info contains information read from or to be written to a PNG file. One + * or more of these must exist while reading or creating a PNG file. The + * information is not used by libpng during read but is used to control what + * gets written when a PNG file is created. "png_get_" function calls read + * information during read and "png_set_" functions calls write information + * when creating a PNG. + * been moved into a separate header file that is not accessible to + * applications. Read libpng-manual.txt or libpng.3 for more info. + */ +typedef struct png_info_def png_info; +typedef png_info * png_infop; +typedef const png_info * png_const_infop; +typedef png_info * * png_infopp; + +/* Types with names ending 'p' are pointer types. The corresponding types with + * names ending 'rp' are identical pointer types except that the pointer is + * marked 'restrict', which means that it is the only pointer to the object + * passed to the function. Applications should not use the 'restrict' types; + * it is always valid to pass 'p' to a pointer with a function argument of the + * corresponding 'rp' type. Different compilers have different rules with + * regard to type matching in the presence of 'restrict'. For backward + * compatibility libpng callbacks never have 'restrict' in their parameters and, + * consequentially, writing portable application code is extremely difficult if + * an attempt is made to use 'restrict'. + */ +typedef png_struct * PNG_RESTRICT png_structrp; +typedef const png_struct * PNG_RESTRICT png_const_structrp; +typedef png_info * PNG_RESTRICT png_inforp; +typedef const png_info * PNG_RESTRICT png_const_inforp; + +/* Three color definitions. The order of the red, green, and blue, (and the + * exact size) is not important, although the size of the fields need to + * be png_byte or png_uint_16 (as defined below). + */ +typedef struct png_color_struct +{ + png_byte red; + png_byte green; + png_byte blue; +} png_color; +typedef png_color * png_colorp; +typedef const png_color * png_const_colorp; +typedef png_color * * png_colorpp; + +typedef struct png_color_16_struct +{ + png_byte index; /* used for palette files */ + png_uint_16 red; /* for use in red green blue files */ + png_uint_16 green; + png_uint_16 blue; + png_uint_16 gray; /* for use in grayscale files */ +} png_color_16; +typedef png_color_16 * png_color_16p; +typedef const png_color_16 * png_const_color_16p; +typedef png_color_16 * * png_color_16pp; + +typedef struct png_color_8_struct +{ + png_byte red; /* for use in red green blue files */ + png_byte green; + png_byte blue; + png_byte gray; /* for use in grayscale files */ + png_byte alpha; /* for alpha channel files */ +} png_color_8; +typedef png_color_8 * png_color_8p; +typedef const png_color_8 * png_const_color_8p; +typedef png_color_8 * * png_color_8pp; + +/* + * The following two structures are used for the in-core representation + * of sPLT chunks. + */ +typedef struct png_sPLT_entry_struct +{ + png_uint_16 red; + png_uint_16 green; + png_uint_16 blue; + png_uint_16 alpha; + png_uint_16 frequency; +} png_sPLT_entry; +typedef png_sPLT_entry * png_sPLT_entryp; +typedef const png_sPLT_entry * png_const_sPLT_entryp; +typedef png_sPLT_entry * * png_sPLT_entrypp; + +/* When the depth of the sPLT palette is 8 bits, the color and alpha samples + * occupy the LSB of their respective members, and the MSB of each member + * is zero-filled. The frequency member always occupies the full 16 bits. + */ + +typedef struct png_sPLT_struct +{ + png_charp name; /* palette name */ + png_byte depth; /* depth of palette samples */ + png_sPLT_entryp entries; /* palette entries */ + png_int_32 nentries; /* number of palette entries */ +} png_sPLT_t; +typedef png_sPLT_t * png_sPLT_tp; +typedef const png_sPLT_t * png_const_sPLT_tp; +typedef png_sPLT_t * * png_sPLT_tpp; + +#ifdef PNG_TEXT_SUPPORTED +/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file, + * and whether that contents is compressed or not. The "key" field + * points to a regular zero-terminated C string. The "text" fields can be a + * regular C string, an empty string, or a NULL pointer. + * However, the structure returned by png_get_text() will always contain + * the "text" field as a regular zero-terminated C string (possibly + * empty), never a NULL pointer, so it can be safely used in printf() and + * other string-handling functions. Note that the "itxt_length", "lang", and + * "lang_key" members of the structure only exist when the library is built + * with iTXt chunk support. Prior to libpng-1.4.0 the library was built by + * default without iTXt support. Also note that when iTXt *is* supported, + * the "lang" and "lang_key" fields contain NULL pointers when the + * "compression" field contains * PNG_TEXT_COMPRESSION_NONE or + * PNG_TEXT_COMPRESSION_zTXt. Note that the "compression value" is not the + * same as what appears in the PNG tEXt/zTXt/iTXt chunk's "compression flag" + * which is always 0 or 1, or its "compression method" which is always 0. + */ +typedef struct png_text_struct +{ + int compression; /* compression value: + -1: tEXt, none + 0: zTXt, deflate + 1: iTXt, none + 2: iTXt, deflate */ + png_charp key; /* keyword, 1-79 character description of "text" */ + png_charp text; /* comment, may be an empty string (ie "") + or a NULL pointer */ + png_size_t text_length; /* length of the text string */ + png_size_t itxt_length; /* length of the itxt string */ + png_charp lang; /* language code, 0-79 characters + or a NULL pointer */ + png_charp lang_key; /* keyword translated UTF-8 string, 0 or more + chars or a NULL pointer */ +} png_text; +typedef png_text * png_textp; +typedef const png_text * png_const_textp; +typedef png_text * * png_textpp; +#endif + +/* Supported compression types for text in PNG files (tEXt, and zTXt). + * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */ +#define PNG_TEXT_COMPRESSION_NONE_WR -3 +#define PNG_TEXT_COMPRESSION_zTXt_WR -2 +#define PNG_TEXT_COMPRESSION_NONE -1 +#define PNG_TEXT_COMPRESSION_zTXt 0 +#define PNG_ITXT_COMPRESSION_NONE 1 +#define PNG_ITXT_COMPRESSION_zTXt 2 +#define PNG_TEXT_COMPRESSION_LAST 3 /* Not a valid value */ + +/* png_time is a way to hold the time in an machine independent way. + * Two conversions are provided, both from time_t and struct tm. There + * is no portable way to convert to either of these structures, as far + * as I know. If you know of a portable way, send it to me. As a side + * note - PNG has always been Year 2000 compliant! + */ +typedef struct png_time_struct +{ + png_uint_16 year; /* full year, as in, 1995 */ + png_byte month; /* month of year, 1 - 12 */ + png_byte day; /* day of month, 1 - 31 */ + png_byte hour; /* hour of day, 0 - 23 */ + png_byte minute; /* minute of hour, 0 - 59 */ + png_byte second; /* second of minute, 0 - 60 (for leap seconds) */ +} png_time; +typedef png_time * png_timep; +typedef const png_time * png_const_timep; +typedef png_time * * png_timepp; + +#if defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) ||\ + defined(PNG_USER_CHUNKS_SUPPORTED) +/* png_unknown_chunk is a structure to hold queued chunks for which there is + * no specific support. The idea is that we can use this to queue + * up private chunks for output even though the library doesn't actually + * know about their semantics. + * + * The data in the structure is set by libpng on read and used on write. + */ +typedef struct png_unknown_chunk_t +{ + png_byte name[5]; /* Textual chunk name with '\0' terminator */ + png_byte *data; /* Data, should not be modified on read! */ + png_size_t size; + + /* On write 'location' must be set using the flag values listed below. + * Notice that on read it is set by libpng however the values stored have + * more bits set than are listed below. Always treat the value as a + * bitmask. On write set only one bit - setting multiple bits may cause the + * chunk to be written in multiple places. + */ + png_byte location; /* mode of operation at read time */ +} +png_unknown_chunk; + +typedef png_unknown_chunk * png_unknown_chunkp; +typedef const png_unknown_chunk * png_const_unknown_chunkp; +typedef png_unknown_chunk * * png_unknown_chunkpp; +#endif + +/* Flag values for the unknown chunk location byte. */ +#define PNG_HAVE_IHDR 0x01 +#define PNG_HAVE_PLTE 0x02 +#define PNG_AFTER_IDAT 0x08 + +/* Maximum positive integer used in PNG is (2^31)-1 */ +#define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL) +#define PNG_UINT_32_MAX ((png_uint_32)(-1)) +#define PNG_SIZE_MAX ((png_size_t)(-1)) + +/* These are constants for fixed point values encoded in the + * PNG specification manner (x100000) + */ +#define PNG_FP_1 100000 +#define PNG_FP_HALF 50000 +#define PNG_FP_MAX ((png_fixed_point)0x7fffffffL) +#define PNG_FP_MIN (-PNG_FP_MAX) + +/* These describe the color_type field in png_info. */ +/* color type masks */ +#define PNG_COLOR_MASK_PALETTE 1 +#define PNG_COLOR_MASK_COLOR 2 +#define PNG_COLOR_MASK_ALPHA 4 + +/* color types. Note that not all combinations are legal */ +#define PNG_COLOR_TYPE_GRAY 0 +#define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE) +#define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR) +#define PNG_COLOR_TYPE_RGB_ALPHA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA) +#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA) +/* aliases */ +#define PNG_COLOR_TYPE_RGBA PNG_COLOR_TYPE_RGB_ALPHA +#define PNG_COLOR_TYPE_GA PNG_COLOR_TYPE_GRAY_ALPHA + +/* This is for compression type. PNG 1.0-1.2 only define the single type. */ +#define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */ +#define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE + +/* This is for filter type. PNG 1.0-1.2 only define the single type. */ +#define PNG_FILTER_TYPE_BASE 0 /* Single row per-byte filtering */ +#define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */ +#define PNG_FILTER_TYPE_DEFAULT PNG_FILTER_TYPE_BASE + +/* These are for the interlacing type. These values should NOT be changed. */ +#define PNG_INTERLACE_NONE 0 /* Non-interlaced image */ +#define PNG_INTERLACE_ADAM7 1 /* Adam7 interlacing */ +#define PNG_INTERLACE_LAST 2 /* Not a valid value */ + +/* These are for the oFFs chunk. These values should NOT be changed. */ +#define PNG_OFFSET_PIXEL 0 /* Offset in pixels */ +#define PNG_OFFSET_MICROMETER 1 /* Offset in micrometers (1/10^6 meter) */ +#define PNG_OFFSET_LAST 2 /* Not a valid value */ + +/* These are for the pCAL chunk. These values should NOT be changed. */ +#define PNG_EQUATION_LINEAR 0 /* Linear transformation */ +#define PNG_EQUATION_BASE_E 1 /* Exponential base e transform */ +#define PNG_EQUATION_ARBITRARY 2 /* Arbitrary base exponential transform */ +#define PNG_EQUATION_HYPERBOLIC 3 /* Hyperbolic sine transformation */ +#define PNG_EQUATION_LAST 4 /* Not a valid value */ + +/* These are for the sCAL chunk. These values should NOT be changed. */ +#define PNG_SCALE_UNKNOWN 0 /* unknown unit (image scale) */ +#define PNG_SCALE_METER 1 /* meters per pixel */ +#define PNG_SCALE_RADIAN 2 /* radians per pixel */ +#define PNG_SCALE_LAST 3 /* Not a valid value */ + +/* These are for the pHYs chunk. These values should NOT be changed. */ +#define PNG_RESOLUTION_UNKNOWN 0 /* pixels/unknown unit (aspect ratio) */ +#define PNG_RESOLUTION_METER 1 /* pixels/meter */ +#define PNG_RESOLUTION_LAST 2 /* Not a valid value */ + +/* These are for the sRGB chunk. These values should NOT be changed. */ +#define PNG_sRGB_INTENT_PERCEPTUAL 0 +#define PNG_sRGB_INTENT_RELATIVE 1 +#define PNG_sRGB_INTENT_SATURATION 2 +#define PNG_sRGB_INTENT_ABSOLUTE 3 +#define PNG_sRGB_INTENT_LAST 4 /* Not a valid value */ + +/* This is for text chunks */ +#define PNG_KEYWORD_MAX_LENGTH 79 + +/* Maximum number of entries in PLTE/sPLT/tRNS arrays */ +#define PNG_MAX_PALETTE_LENGTH 256 + +/* These determine if an ancillary chunk's data has been successfully read + * from the PNG header, or if the application has filled in the corresponding + * data in the info_struct to be written into the output file. The values + * of the PNG_INFO_ defines should NOT be changed. + */ +#define PNG_INFO_gAMA 0x0001 +#define PNG_INFO_sBIT 0x0002 +#define PNG_INFO_cHRM 0x0004 +#define PNG_INFO_PLTE 0x0008 +#define PNG_INFO_tRNS 0x0010 +#define PNG_INFO_bKGD 0x0020 +#define PNG_INFO_hIST 0x0040 +#define PNG_INFO_pHYs 0x0080 +#define PNG_INFO_oFFs 0x0100 +#define PNG_INFO_tIME 0x0200 +#define PNG_INFO_pCAL 0x0400 +#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ +#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ +#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ +#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ +#if INT_MAX >= 0x8000 /* else this might break */ +#define PNG_INFO_IDAT 0x8000 /* ESR, 1.0.6 */ +#endif + +/* This is used for the transformation routines, as some of them + * change these values for the row. It also should enable using + * the routines for other purposes. + */ +typedef struct png_row_info_struct +{ + png_uint_32 width; /* width of row */ + png_size_t rowbytes; /* number of bytes in row */ + png_byte color_type; /* color type of row */ + png_byte bit_depth; /* bit depth of row */ + png_byte channels; /* number of channels (1, 2, 3, or 4) */ + png_byte pixel_depth; /* bits per pixel (depth * channels) */ +} png_row_info; + +typedef png_row_info * png_row_infop; +typedef png_row_info * * png_row_infopp; + +/* These are the function types for the I/O functions and for the functions + * that allow the user to override the default I/O functions with his or her + * own. The png_error_ptr type should match that of user-supplied warning + * and error functions, while the png_rw_ptr type should match that of the + * user read/write data functions. Note that the 'write' function must not + * modify the buffer it is passed. The 'read' function, on the other hand, is + * expected to return the read data in the buffer. + */ +typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp)); +typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, png_size_t)); +typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp)); +typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32, + int)); +typedef PNG_CALLBACK(void, *png_write_status_ptr, (png_structp, png_uint_32, + int)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +typedef PNG_CALLBACK(void, *png_progressive_info_ptr, (png_structp, png_infop)); +typedef PNG_CALLBACK(void, *png_progressive_end_ptr, (png_structp, png_infop)); + +/* The following callback receives png_uint_32 row_number, int pass for the + * png_bytep data of the row. When transforming an interlaced image the + * row number is the row number within the sub-image of the interlace pass, so + * the value will increase to the height of the sub-image (not the full image) + * then reset to 0 for the next pass. + * + * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to + * find the output pixel (x,y) given an interlaced sub-image pixel + * (row,col,pass). (See below for these macros.) + */ +typedef PNG_CALLBACK(void, *png_progressive_row_ptr, (png_structp, png_bytep, + png_uint_32, int)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +typedef PNG_CALLBACK(void, *png_user_transform_ptr, (png_structp, png_row_infop, + png_bytep)); +#endif + +#ifdef PNG_USER_CHUNKS_SUPPORTED +typedef PNG_CALLBACK(int, *png_user_chunk_ptr, (png_structp, + png_unknown_chunkp)); +#endif +#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED +/* not used anywhere */ +/* typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp)); */ +#endif + +#ifdef PNG_SETJMP_SUPPORTED +/* This must match the function definition in , and the application + * must include this before png.h to obtain the definition of jmp_buf. The + * function is required to be PNG_NORETURN, but this is not checked. If the + * function does return the application will crash via an abort() or similar + * system level call. + * + * If you get a warning here while building the library you may need to make + * changes to ensure that pnglibconf.h records the calling convention used by + * your compiler. This may be very difficult - try using a different compiler + * to build the library! + */ +PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef); +#endif + +/* Transform masks for the high-level interface */ +#define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */ +#define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */ +#define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */ +#define PNG_TRANSFORM_PACKING 0x0004 /* read and write */ +#define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */ +#define PNG_TRANSFORM_EXPAND 0x0010 /* read only */ +#define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */ +#define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */ +#define PNG_TRANSFORM_BGR 0x0080 /* read and write */ +#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ +#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ +#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ +#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* write only */ +/* Added to libpng-1.2.34 */ +#define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER +#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */ +/* Added to libpng-1.4.0 */ +#define PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read only */ +/* Added to libpng-1.5.4 */ +#define PNG_TRANSFORM_EXPAND_16 0x4000 /* read only */ +#if INT_MAX >= 0x8000 /* else this might break */ +#define PNG_TRANSFORM_SCALE_16 0x8000 /* read only */ +#endif + +/* Flags for MNG supported features */ +#define PNG_FLAG_MNG_EMPTY_PLTE 0x01 +#define PNG_FLAG_MNG_FILTER_64 0x04 +#define PNG_ALL_MNG_FEATURES 0x05 + +/* NOTE: prior to 1.5 these functions had no 'API' style declaration, + * this allowed the zlib default functions to be used on Windows + * platforms. In 1.5 the zlib default malloc (which just calls malloc and + * ignores the first argument) should be completely compatible with the + * following. + */ +typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp, + png_alloc_size_t)); +typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp)); + +/* Section 4: exported functions + * Here are the function definitions most commonly used. This is not + * the place to find out how to use libpng. See libpng-manual.txt for the + * full explanation, see example.c for the summary. This just provides + * a simple one line description of the use of each function. + * + * The PNG_EXPORT() and PNG_EXPORTA() macros used below are defined in + * pngconf.h and in the *.dfn files in the scripts directory. + * + * PNG_EXPORT(ordinal, type, name, (args)); + * + * ordinal: ordinal that is used while building + * *.def files. The ordinal value is only + * relevant when preprocessing png.h with + * the *.dfn files for building symbol table + * entries, and are removed by pngconf.h. + * type: return type of the function + * name: function name + * args: function arguments, with types + * + * When we wish to append attributes to a function prototype we use + * the PNG_EXPORTA() macro instead. + * + * PNG_EXPORTA(ordinal, type, name, (args), attributes); + * + * ordinal, type, name, and args: same as in PNG_EXPORT(). + * attributes: function attributes + */ + +/* Returns the version number of the library */ +PNG_EXPORT(1, png_uint_32, png_access_version_number, (void)); + +/* Tell lib we have already handled the first magic bytes. + * Handling more than 8 bytes from the beginning of the file is an error. + */ +PNG_EXPORT(2, void, png_set_sig_bytes, (png_structrp png_ptr, int num_bytes)); + +/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a + * PNG file. Returns zero if the supplied bytes match the 8-byte PNG + * signature, and non-zero otherwise. Having num_to_check == 0 or + * start > 7 will always fail (ie return non-zero). + */ +PNG_EXPORT(3, int, png_sig_cmp, (png_const_bytep sig, png_size_t start, + png_size_t num_to_check)); + +/* Simple signature checking function. This is the same as calling + * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). + */ +#define png_check_sig(sig, n) !png_sig_cmp((sig), 0, (n)) + +/* Allocate and initialize png_ptr struct for reading, and any other memory. */ +PNG_EXPORTA(4, png_structp, png_create_read_struct, + (png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn), + PNG_ALLOCATED); + +/* Allocate and initialize png_ptr struct for writing, and any other memory */ +PNG_EXPORTA(5, png_structp, png_create_write_struct, + (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, + png_error_ptr warn_fn), + PNG_ALLOCATED); + +PNG_EXPORT(6, png_size_t, png_get_compression_buffer_size, + (png_const_structrp png_ptr)); + +PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structrp png_ptr, + png_size_t size)); + +/* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp + * match up. + */ +#ifdef PNG_SETJMP_SUPPORTED +/* This function returns the jmp_buf built in to *png_ptr. It must be + * supplied with an appropriate 'longjmp' function to use on that jmp_buf + * unless the default error function is overridden in which case NULL is + * acceptable. The size of the jmp_buf is checked against the actual size + * allocated by the library - the call will return NULL on a mismatch + * indicating an ABI mismatch. + */ +PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structrp png_ptr, + png_longjmp_ptr longjmp_fn, size_t jmp_buf_size)); +# define png_jmpbuf(png_ptr) \ + (*png_set_longjmp_fn((png_ptr), longjmp, (sizeof (jmp_buf)))) +#else +# define png_jmpbuf(png_ptr) \ + (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP) +#endif +/* This function should be used by libpng applications in place of + * longjmp(png_ptr->jmpbuf, val). If longjmp_fn() has been set, it + * will use it; otherwise it will call PNG_ABORT(). This function was + * added in libpng-1.5.0. + */ +PNG_EXPORTA(9, void, png_longjmp, (png_const_structrp png_ptr, int val), + PNG_NORETURN); + +#ifdef PNG_READ_SUPPORTED +/* Reset the compression stream */ +PNG_EXPORTA(10, int, png_reset_zstream, (png_structrp png_ptr), PNG_DEPRECATED); +#endif + +/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ +#ifdef PNG_USER_MEM_SUPPORTED +PNG_EXPORTA(11, png_structp, png_create_read_struct_2, + (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, + png_error_ptr warn_fn, + png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn), + PNG_ALLOCATED); +PNG_EXPORTA(12, png_structp, png_create_write_struct_2, + (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, + png_error_ptr warn_fn, + png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn), + PNG_ALLOCATED); +#endif + +/* Write the PNG file signature. */ +PNG_EXPORT(13, void, png_write_sig, (png_structrp png_ptr)); + +/* Write a PNG chunk - size, type, (optional) data, CRC. */ +PNG_EXPORT(14, void, png_write_chunk, (png_structrp png_ptr, png_const_bytep + chunk_name, png_const_bytep data, png_size_t length)); + +/* Write the start of a PNG chunk - length and chunk name. */ +PNG_EXPORT(15, void, png_write_chunk_start, (png_structrp png_ptr, + png_const_bytep chunk_name, png_uint_32 length)); + +/* Write the data of a PNG chunk started with png_write_chunk_start(). */ +PNG_EXPORT(16, void, png_write_chunk_data, (png_structrp png_ptr, + png_const_bytep data, png_size_t length)); + +/* Finish a chunk started with png_write_chunk_start() (includes CRC). */ +PNG_EXPORT(17, void, png_write_chunk_end, (png_structrp png_ptr)); + +/* Allocate and initialize the info structure */ +PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_const_structrp png_ptr), + PNG_ALLOCATED); + +/* DEPRECATED: this function allowed init structures to be created using the + * default allocation method (typically malloc). Use is deprecated in 1.6.0 and + * the API will be removed in the future. + */ +PNG_EXPORTA(19, void, png_info_init_3, (png_infopp info_ptr, + png_size_t png_info_struct_size), PNG_DEPRECATED); + +/* Writes all the PNG information before the image. */ +PNG_EXPORT(20, void, png_write_info_before_PLTE, + (png_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(21, void, png_write_info, + (png_structrp png_ptr, png_const_inforp info_ptr)); + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read the information before the actual image data. */ +PNG_EXPORT(22, void, png_read_info, + (png_structrp png_ptr, png_inforp info_ptr)); +#endif + +#ifdef PNG_TIME_RFC1123_SUPPORTED + /* Convert to a US string format: there is no localization support in this + * routine. The original implementation used a 29 character buffer in + * png_struct, this will be removed in future versions. + */ +#if PNG_LIBPNG_VER < 10700 +/* To do: remove this from libpng17 (and from libpng17/png.c and pngstruct.h) */ +PNG_EXPORTA(23, png_const_charp, png_convert_to_rfc1123, (png_structrp png_ptr, + png_const_timep ptime),PNG_DEPRECATED); +#endif +PNG_EXPORT(241, int, png_convert_to_rfc1123_buffer, (char out[29], + png_const_timep ptime)); +#endif + +#undef PNG_CONVERT_tIME_SUPPORTED +#ifdef PNG_CONVERT_tIME_SUPPORTED +/* Convert from a struct tm to png_time */ +PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime, const struct tm * ttime)); + +/* Convert from time_t to png_time. Uses gmtime() */ +PNG_EXPORT(25, void, png_convert_from_time_t, (png_timep ptime, time_t ttime)); +#endif /* CONVERT_tIME */ + +#ifdef PNG_READ_EXPAND_SUPPORTED +/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ +PNG_EXPORT(26, void, png_set_expand, (png_structrp png_ptr)); +PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structrp png_ptr)); +PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structrp png_ptr)); +PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_EXPAND_16_SUPPORTED +/* Expand to 16-bit channels, forces conversion of palette to RGB and expansion + * of a tRNS chunk if present. + */ +PNG_EXPORT(221, void, png_set_expand_16, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +/* Use blue, green, red order for pixels. */ +PNG_EXPORT(30, void, png_set_bgr, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED +/* Expand the grayscale to 24-bit RGB if necessary. */ +PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED +/* Reduce RGB to grayscale. */ +#define PNG_ERROR_ACTION_NONE 1 +#define PNG_ERROR_ACTION_WARN 2 +#define PNG_ERROR_ACTION_ERROR 3 +#define PNG_RGB_TO_GRAY_DEFAULT (-1)/*for red/green coefficients*/ + +PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structrp png_ptr, + int error_action, double red, double green)) +PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structrp png_ptr, + int error_action, png_fixed_point red, png_fixed_point green)) + +PNG_EXPORT(34, png_byte, png_get_rgb_to_gray_status, (png_const_structrp + png_ptr)); +#endif + +#ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED +PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth, + png_colorp palette)); +#endif + +#ifdef PNG_READ_ALPHA_MODE_SUPPORTED +/* How the alpha channel is interpreted - this affects how the color channels + * of a PNG file are returned to the calling application when an alpha channel, + * or a tRNS chunk in a palette file, is present. + * + * This has no effect on the way pixels are written into a PNG output + * datastream. The color samples in a PNG datastream are never premultiplied + * with the alpha samples. + * + * The default is to return data according to the PNG specification: the alpha + * channel is a linear measure of the contribution of the pixel to the + * corresponding composited pixel, and the color channels are unassociated + * (not premultiplied). The gamma encoded color channels must be scaled + * according to the contribution and to do this it is necessary to undo + * the encoding, scale the color values, perform the composition and reencode + * the values. This is the 'PNG' mode. + * + * The alternative is to 'associate' the alpha with the color information by + * storing color channel values that have been scaled by the alpha. + * image. These are the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' modes + * (the latter being the two common names for associated alpha color channels). + * + * For the 'OPTIMIZED' mode, a pixel is treated as opaque only if the alpha + * value is equal to the maximum value. + * + * The final choice is to gamma encode the alpha channel as well. This is + * broken because, in practice, no implementation that uses this choice + * correctly undoes the encoding before handling alpha composition. Use this + * choice only if other serious errors in the software or hardware you use + * mandate it; the typical serious error is for dark halos to appear around + * opaque areas of the composited PNG image because of arithmetic overflow. + * + * The API function png_set_alpha_mode specifies which of these choices to use + * with an enumerated 'mode' value and the gamma of the required output: + */ +#define PNG_ALPHA_PNG 0 /* according to the PNG standard */ +#define PNG_ALPHA_STANDARD 1 /* according to Porter/Duff */ +#define PNG_ALPHA_ASSOCIATED 1 /* as above; this is the normal practice */ +#define PNG_ALPHA_PREMULTIPLIED 1 /* as above */ +#define PNG_ALPHA_OPTIMIZED 2 /* 'PNG' for opaque pixels, else 'STANDARD' */ +#define PNG_ALPHA_BROKEN 3 /* the alpha channel is gamma encoded */ + +PNG_FP_EXPORT(227, void, png_set_alpha_mode, (png_structrp png_ptr, int mode, + double output_gamma)) +PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structrp png_ptr, + int mode, png_fixed_point output_gamma)) +#endif + +#if defined(PNG_GAMMA_SUPPORTED) || defined(PNG_READ_ALPHA_MODE_SUPPORTED) +/* The output_gamma value is a screen gamma in libpng terminology: it expresses + * how to decode the output values, not how they are encoded. + */ +#define PNG_DEFAULT_sRGB -1 /* sRGB gamma and color space */ +#define PNG_GAMMA_MAC_18 -2 /* Old Mac '1.8' gamma and color space */ +#define PNG_GAMMA_sRGB 220000 /* Television standards--matches sRGB gamma */ +#define PNG_GAMMA_LINEAR PNG_FP_1 /* Linear */ +#endif + +/* The following are examples of calls to png_set_alpha_mode to achieve the + * required overall gamma correction and, where necessary, alpha + * premultiplication. + * + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); + * This is the default libpng handling of the alpha channel - it is not + * pre-multiplied into the color components. In addition the call states + * that the output is for a sRGB system and causes all PNG files without gAMA + * chunks to be assumed to be encoded using sRGB. + * + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); + * In this case the output is assumed to be something like an sRGB conformant + * display preceeded by a power-law lookup table of power 1.45. This is how + * early Mac systems behaved. + * + * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR); + * This is the classic Jim Blinn approach and will work in academic + * environments where everything is done by the book. It has the shortcoming + * of assuming that input PNG data with no gamma information is linear - this + * is unlikely to be correct unless the PNG files where generated locally. + * Most of the time the output precision will be so low as to show + * significant banding in dark areas of the image. + * + * png_set_expand_16(pp); + * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB); + * This is a somewhat more realistic Jim Blinn inspired approach. PNG files + * are assumed to have the sRGB encoding if not marked with a gamma value and + * the output is always 16 bits per component. This permits accurate scaling + * and processing of the data. If you know that your input PNG files were + * generated locally you might need to replace PNG_DEFAULT_sRGB with the + * correct value for your system. + * + * png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB); + * If you just need to composite the PNG image onto an existing background + * and if you control the code that does this you can use the optimization + * setting. In this case you just copy completely opaque pixels to the + * output. For pixels that are not completely transparent (you just skip + * those) you do the composition math using png_composite or png_composite_16 + * below then encode the resultant 8-bit or 16-bit values to match the output + * encoding. + * + * Other cases + * If neither the PNG nor the standard linear encoding work for you because + * of the software or hardware you use then you have a big problem. The PNG + * case will probably result in halos around the image. The linear encoding + * will probably result in a washed out, too bright, image (it's actually too + * contrasty.) Try the ALPHA_OPTIMIZED mode above - this will probably + * substantially reduce the halos. Alternatively try: + * + * png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB); + * This option will also reduce the halos, but there will be slight dark + * halos round the opaque parts of the image where the background is light. + * In the OPTIMIZED mode the halos will be light halos where the background + * is dark. Take your pick - the halos are unavoidable unless you can get + * your hardware/software fixed! (The OPTIMIZED approach is slightly + * faster.) + * + * When the default gamma of PNG files doesn't match the output gamma. + * If you have PNG files with no gamma information png_set_alpha_mode allows + * you to provide a default gamma, but it also sets the ouput gamma to the + * matching value. If you know your PNG files have a gamma that doesn't + * match the output you can take advantage of the fact that + * png_set_alpha_mode always sets the output gamma but only sets the PNG + * default if it is not already set: + * + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); + * The first call sets both the default and the output gamma values, the + * second call overrides the output gamma without changing the default. This + * is easier than achieving the same effect with png_set_gamma. You must use + * PNG_ALPHA_PNG for the first call - internal checking in png_set_alpha will + * fire if more than one call to png_set_alpha_mode and png_set_background is + * made in the same read operation, however multiple calls with PNG_ALPHA_PNG + * are ignored. + */ + +#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED +PNG_EXPORT(36, void, png_set_strip_alpha, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +PNG_EXPORT(37, void, png_set_swap_alpha, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +PNG_EXPORT(38, void, png_set_invert_alpha, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +/* Add a filler byte to 8-bit or 16-bit Gray or 24-bit or 48-bit RGB images. */ +PNG_EXPORT(39, void, png_set_filler, (png_structrp png_ptr, png_uint_32 filler, + int flags)); +/* The values of the PNG_FILLER_ defines should NOT be changed */ +# define PNG_FILLER_BEFORE 0 +# define PNG_FILLER_AFTER 1 +/* Add an alpha byte to 8-bit or 16-bit Gray or 24-bit or 48-bit RGB images. */ +PNG_EXPORT(40, void, png_set_add_alpha, (png_structrp png_ptr, + png_uint_32 filler, int flags)); +#endif /* READ_FILLER || WRITE_FILLER */ + +#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +/* Swap bytes in 16-bit depth files. */ +PNG_EXPORT(41, void, png_set_swap, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) +/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ +PNG_EXPORT(42, void, png_set_packing, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_PACKSWAP_SUPPORTED) || \ + defined(PNG_WRITE_PACKSWAP_SUPPORTED) +/* Swap packing order of pixels in bytes. */ +PNG_EXPORT(43, void, png_set_packswap, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) +/* Converts files to legal bit depths. */ +PNG_EXPORT(44, void, png_set_shift, (png_structrp png_ptr, png_const_color_8p + true_bits)); +#endif + +#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ + defined(PNG_WRITE_INTERLACING_SUPPORTED) +/* Have the code handle the interlacing. Returns the number of passes. + * MUST be called before png_read_update_info or png_start_read_image, + * otherwise it will not have the desired effect. Note that it is still + * necessary to call png_read_row or png_read_rows png_get_image_height + * times for each pass. +*/ +PNG_EXPORT(45, int, png_set_interlace_handling, (png_structrp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +/* Invert monochrome files */ +PNG_EXPORT(46, void, png_set_invert_mono, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_BACKGROUND_SUPPORTED +/* Handle alpha and tRNS by replacing with a background color. Prior to + * libpng-1.5.4 this API must not be called before the PNG file header has been + * read. Doing so will result in unexpected behavior and possible warnings or + * errors if the PNG file contains a bKGD chunk. + */ +PNG_FP_EXPORT(47, void, png_set_background, (png_structrp png_ptr, + png_const_color_16p background_color, int background_gamma_code, + int need_expand, double background_gamma)) +PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structrp png_ptr, + png_const_color_16p background_color, int background_gamma_code, + int need_expand, png_fixed_point background_gamma)) +#endif +#ifdef PNG_READ_BACKGROUND_SUPPORTED +# define PNG_BACKGROUND_GAMMA_UNKNOWN 0 +# define PNG_BACKGROUND_GAMMA_SCREEN 1 +# define PNG_BACKGROUND_GAMMA_FILE 2 +# define PNG_BACKGROUND_GAMMA_UNIQUE 3 +#endif + +#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED +/* Scale a 16-bit depth file down to 8-bit, accurately. */ +PNG_EXPORT(229, void, png_set_scale_16, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED +#define PNG_READ_16_TO_8 SUPPORTED /* Name prior to 1.5.4 */ +/* Strip the second byte of information from a 16-bit depth file. */ +PNG_EXPORT(48, void, png_set_strip_16, (png_structrp png_ptr)); +#endif + +#ifdef PNG_READ_QUANTIZE_SUPPORTED +/* Turn on quantizing, and reduce the palette to the number of colors + * available. + */ +PNG_EXPORT(49, void, png_set_quantize, (png_structrp png_ptr, + png_colorp palette, int num_palette, int maximum_colors, + png_const_uint_16p histogram, int full_quantize)); +#endif + +#ifdef PNG_READ_GAMMA_SUPPORTED +/* The threshold on gamma processing is configurable but hard-wired into the + * library. The following is the floating point variant. + */ +#define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001) + +/* Handle gamma correction. Screen_gamma=(display_exponent). + * NOTE: this API simply sets the screen and file gamma values. It will + * therefore override the value for gamma in a PNG file if it is called after + * the file header has been read - use with care - call before reading the PNG + * file for best results! + * + * These routines accept the same gamma values as png_set_alpha_mode (described + * above). The PNG_GAMMA_ defines and PNG_DEFAULT_sRGB can be passed to either + * API (floating point or fixed.) Notice, however, that the 'file_gamma' value + * is the inverse of a 'screen gamma' value. + */ +PNG_FP_EXPORT(50, void, png_set_gamma, (png_structrp png_ptr, + double screen_gamma, double override_file_gamma)) +PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structrp png_ptr, + png_fixed_point screen_gamma, png_fixed_point override_file_gamma)) +#endif + +#ifdef PNG_WRITE_FLUSH_SUPPORTED +/* Set how many lines between output flushes - 0 for no flushing */ +PNG_EXPORT(51, void, png_set_flush, (png_structrp png_ptr, int nrows)); +/* Flush the current PNG output buffer */ +PNG_EXPORT(52, void, png_write_flush, (png_structrp png_ptr)); +#endif + +/* Optional update palette with requested transformations */ +PNG_EXPORT(53, void, png_start_read_image, (png_structrp png_ptr)); + +/* Optional call to update the users info structure */ +PNG_EXPORT(54, void, png_read_update_info, (png_structrp png_ptr, + png_inforp info_ptr)); + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read one or more rows of image data. */ +PNG_EXPORT(55, void, png_read_rows, (png_structrp png_ptr, png_bytepp row, + png_bytepp display_row, png_uint_32 num_rows)); +#endif + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read a row of data. */ +PNG_EXPORT(56, void, png_read_row, (png_structrp png_ptr, png_bytep row, + png_bytep display_row)); +#endif + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read the whole image into memory at once. */ +PNG_EXPORT(57, void, png_read_image, (png_structrp png_ptr, png_bytepp image)); +#endif + +/* Write a row of image data */ +PNG_EXPORT(58, void, png_write_row, (png_structrp png_ptr, + png_const_bytep row)); + +/* Write a few rows of image data: (*row) is not written; however, the type + * is declared as writeable to maintain compatibility with previous versions + * of libpng and to allow the 'display_row' array from read_rows to be passed + * unchanged to write_rows. + */ +PNG_EXPORT(59, void, png_write_rows, (png_structrp png_ptr, png_bytepp row, + png_uint_32 num_rows)); + +/* Write the image data */ +PNG_EXPORT(60, void, png_write_image, (png_structrp png_ptr, png_bytepp image)); + +/* Write the end of the PNG file. */ +PNG_EXPORT(61, void, png_write_end, (png_structrp png_ptr, + png_inforp info_ptr)); + +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read the end of the PNG file. */ +PNG_EXPORT(62, void, png_read_end, (png_structrp png_ptr, png_inforp info_ptr)); +#endif + +/* Free any memory associated with the png_info_struct */ +PNG_EXPORT(63, void, png_destroy_info_struct, (png_const_structrp png_ptr, + png_infopp info_ptr_ptr)); + +/* Free any memory associated with the png_struct and the png_info_structs */ +PNG_EXPORT(64, void, png_destroy_read_struct, (png_structpp png_ptr_ptr, + png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); + +/* Free any memory associated with the png_struct and the png_info_structs */ +PNG_EXPORT(65, void, png_destroy_write_struct, (png_structpp png_ptr_ptr, + png_infopp info_ptr_ptr)); + +/* Set the libpng method of handling chunk CRC errors */ +PNG_EXPORT(66, void, png_set_crc_action, (png_structrp png_ptr, int crit_action, + int ancil_action)); + +/* Values for png_set_crc_action() say how to handle CRC errors in + * ancillary and critical chunks, and whether to use the data contained + * therein. Note that it is impossible to "discard" data in a critical + * chunk. For versions prior to 0.90, the action was always error/quit, + * whereas in version 0.90 and later, the action for CRC errors in ancillary + * chunks is warn/discard. These values should NOT be changed. + * + * value action:critical action:ancillary + */ +#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */ +#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */ +#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */ +#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */ +#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ +#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ + +#ifdef PNG_WRITE_SUPPORTED +/* These functions give the user control over the scan-line filtering in + * libpng and the compression methods used by zlib. These functions are + * mainly useful for testing, as the defaults should work with most users. + * Those users who are tight on memory or want faster performance at the + * expense of compression can modify them. See the compression library + * header file (zlib.h) for an explination of the compression functions. + */ + +/* Set the filtering method(s) used by libpng. Currently, the only valid + * value for "method" is 0. + */ +PNG_EXPORT(67, void, png_set_filter, (png_structrp png_ptr, int method, + int filters)); +#endif /* WRITE */ + +/* Flags for png_set_filter() to say which filters to use. The flags + * are chosen so that they don't conflict with real filter types + * below, in case they are supplied instead of the #defined constants. + * These values should NOT be changed. + */ +#define PNG_NO_FILTERS 0x00 +#define PNG_FILTER_NONE 0x08 +#define PNG_FILTER_SUB 0x10 +#define PNG_FILTER_UP 0x20 +#define PNG_FILTER_AVG 0x40 +#define PNG_FILTER_PAETH 0x80 +#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ + PNG_FILTER_AVG | PNG_FILTER_PAETH) + +/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. + * These defines should NOT be changed. + */ +#define PNG_FILTER_VALUE_NONE 0 +#define PNG_FILTER_VALUE_SUB 1 +#define PNG_FILTER_VALUE_UP 2 +#define PNG_FILTER_VALUE_AVG 3 +#define PNG_FILTER_VALUE_PAETH 4 +#define PNG_FILTER_VALUE_LAST 5 + +#ifdef PNG_WRITE_SUPPORTED +#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* DEPRECATED */ +PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structrp png_ptr, + int heuristic_method, int num_weights, png_const_doublep filter_weights, + png_const_doublep filter_costs)) +PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed, + (png_structrp png_ptr, int heuristic_method, int num_weights, + png_const_fixed_point_p filter_weights, + png_const_fixed_point_p filter_costs)) +#endif /* WRITE_WEIGHTED_FILTER */ + +/* The following are no longer used and will be removed from libpng-1.7: */ +#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */ +#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */ +#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ +#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ + +/* Set the library compression level. Currently, valid values range from + * 0 - 9, corresponding directly to the zlib compression levels 0 - 9 + * (0 - no compression, 9 - "maximal" compression). Note that tests have + * shown that zlib compression levels 3-6 usually perform as well as level 9 + * for PNG images, and do considerably fewer caclulations. In the future, + * these values may not correspond directly to the zlib compression levels. + */ +#ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED +PNG_EXPORT(69, void, png_set_compression_level, (png_structrp png_ptr, + int level)); + +PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structrp png_ptr, + int mem_level)); + +PNG_EXPORT(71, void, png_set_compression_strategy, (png_structrp png_ptr, + int strategy)); + +/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a + * smaller value of window_bits if it can do so safely. + */ +PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structrp png_ptr, + int window_bits)); + +PNG_EXPORT(73, void, png_set_compression_method, (png_structrp png_ptr, + int method)); +#endif /* WRITE_CUSTOMIZE_COMPRESSION */ + +#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED +/* Also set zlib parameters for compressing non-IDAT chunks */ +PNG_EXPORT(222, void, png_set_text_compression_level, (png_structrp png_ptr, + int level)); + +PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structrp png_ptr, + int mem_level)); + +PNG_EXPORT(224, void, png_set_text_compression_strategy, (png_structrp png_ptr, + int strategy)); + +/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a + * smaller value of window_bits if it can do so safely. + */ +PNG_EXPORT(225, void, png_set_text_compression_window_bits, + (png_structrp png_ptr, int window_bits)); + +PNG_EXPORT(226, void, png_set_text_compression_method, (png_structrp png_ptr, + int method)); +#endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */ +#endif /* WRITE */ + +/* These next functions are called for input/output, memory, and error + * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, + * and call standard C I/O routines such as fread(), fwrite(), and + * fprintf(). These functions can be made to use other I/O routines + * at run time for those applications that need to handle I/O in a + * different manner by calling png_set_???_fn(). See libpng-manual.txt for + * more information. + */ + +#ifdef PNG_STDIO_SUPPORTED +/* Initialize the input/output for the PNG file to the default functions. */ +PNG_EXPORT(74, void, png_init_io, (png_structrp png_ptr, png_FILE_p fp)); +#endif + +/* Replace the (error and abort), and warning functions with user + * supplied functions. If no messages are to be printed you must still + * write and use replacement functions. The replacement error_fn should + * still do a longjmp to the last setjmp location if you are using this + * method of error handling. If error_fn or warning_fn is NULL, the + * default function will be used. + */ + +PNG_EXPORT(75, void, png_set_error_fn, (png_structrp png_ptr, + png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); + +/* Return the user pointer associated with the error functions */ +PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_structrp png_ptr)); + +/* Replace the default data output functions with a user supplied one(s). + * If buffered output is not used, then output_flush_fn can be set to NULL. + * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time + * output_flush_fn will be ignored (and thus can be NULL). + * It is probably a mistake to use NULL for output_flush_fn if + * write_data_fn is not also NULL unless you have built libpng with + * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's + * default flush function, which uses the standard *FILE structure, will + * be used. + */ +PNG_EXPORT(77, void, png_set_write_fn, (png_structrp png_ptr, png_voidp io_ptr, + png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); + +/* Replace the default data input function with a user supplied one. */ +PNG_EXPORT(78, void, png_set_read_fn, (png_structrp png_ptr, png_voidp io_ptr, + png_rw_ptr read_data_fn)); + +/* Return the user pointer associated with the I/O functions */ +PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_const_structrp png_ptr)); + +PNG_EXPORT(80, void, png_set_read_status_fn, (png_structrp png_ptr, + png_read_status_ptr read_row_fn)); + +PNG_EXPORT(81, void, png_set_write_status_fn, (png_structrp png_ptr, + png_write_status_ptr write_row_fn)); + +#ifdef PNG_USER_MEM_SUPPORTED +/* Replace the default memory allocation functions with user supplied one(s). */ +PNG_EXPORT(82, void, png_set_mem_fn, (png_structrp png_ptr, png_voidp mem_ptr, + png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +/* Return the user pointer associated with the memory functions */ +PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structrp png_ptr)); +#endif + +#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED +PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structrp png_ptr, + png_user_transform_ptr read_user_transform_fn)); +#endif + +#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED +PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structrp png_ptr, + png_user_transform_ptr write_user_transform_fn)); +#endif + +#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED +PNG_EXPORT(86, void, png_set_user_transform_info, (png_structrp png_ptr, + png_voidp user_transform_ptr, int user_transform_depth, + int user_transform_channels)); +/* Return the user pointer associated with the user transform functions */ +PNG_EXPORT(87, png_voidp, png_get_user_transform_ptr, + (png_const_structrp png_ptr)); +#endif + +#ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED +/* Return information about the row currently being processed. Note that these + * APIs do not fail but will return unexpected results if called outside a user + * transform callback. Also note that when transforming an interlaced image the + * row number is the row number within the sub-image of the interlace pass, so + * the value will increase to the height of the sub-image (not the full image) + * then reset to 0 for the next pass. + * + * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to + * find the output pixel (x,y) given an interlaced sub-image pixel + * (row,col,pass). (See below for these macros.) + */ +PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structrp)); +PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structrp)); +#endif + +#ifdef PNG_READ_USER_CHUNKS_SUPPORTED +/* This callback is called only for *unknown* chunks. If + * PNG_HANDLE_AS_UNKNOWN_SUPPORTED is set then it is possible to set known + * chunks to be treated as unknown, however in this case the callback must do + * any processing required by the chunk (e.g. by calling the appropriate + * png_set_ APIs.) + * + * There is no write support - on write, by default, all the chunks in the + * 'unknown' list are written in the specified position. + * + * The integer return from the callback function is interpreted thus: + * + * negative: An error occurred; png_chunk_error will be called. + * zero: The chunk was not handled, the chunk will be saved. A critical + * chunk will cause an error at this point unless it is to be saved. + * positive: The chunk was handled, libpng will ignore/discard it. + * + * See "INTERACTION WTIH USER CHUNK CALLBACKS" below for important notes about + * how this behavior will change in libpng 1.7 + */ +PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structrp png_ptr, + png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); +#endif + +#ifdef PNG_USER_CHUNKS_SUPPORTED +PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structrp png_ptr)); +#endif + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +/* Sets the function callbacks for the push reader, and a pointer to a + * user-defined structure available to the callback functions. + */ +PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structrp png_ptr, + png_voidp progressive_ptr, png_progressive_info_ptr info_fn, + png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn)); + +/* Returns the user pointer associated with the push read functions */ +PNG_EXPORT(91, png_voidp, png_get_progressive_ptr, + (png_const_structrp png_ptr)); + +/* Function to be called when data becomes available */ +PNG_EXPORT(92, void, png_process_data, (png_structrp png_ptr, + png_inforp info_ptr, png_bytep buffer, png_size_t buffer_size)); + +/* A function which may be called *only* within png_process_data to stop the + * processing of any more data. The function returns the number of bytes + * remaining, excluding any that libpng has cached internally. A subsequent + * call to png_process_data must supply these bytes again. If the argument + * 'save' is set to true the routine will first save all the pending data and + * will always return 0. + */ +PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structrp, int save)); + +/* A function which may be called *only* outside (after) a call to + * png_process_data. It returns the number of bytes of data to skip in the + * input. Normally it will return 0, but if it returns a non-zero value the + * application must skip than number of bytes of input data and pass the + * following data to the next call to png_process_data. + */ +PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structrp)); + +/* Function that combines rows. 'new_row' is a flag that should come from + * the callback and be non-NULL if anything needs to be done; the library + * stores its own version of the new data internally and ignores the passed + * in value. + */ +PNG_EXPORT(93, void, png_progressive_combine_row, (png_const_structrp png_ptr, + png_bytep old_row, png_const_bytep new_row)); +#endif /* PROGRESSIVE_READ */ + +PNG_EXPORTA(94, png_voidp, png_malloc, (png_const_structrp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED); +/* Added at libpng version 1.4.0 */ +PNG_EXPORTA(95, png_voidp, png_calloc, (png_const_structrp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED); + +/* Added at libpng version 1.2.4 */ +PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_const_structrp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED); + +/* Frees a pointer allocated by png_malloc() */ +PNG_EXPORT(97, void, png_free, (png_const_structrp png_ptr, png_voidp ptr)); + +/* Free data that was allocated internally */ +PNG_EXPORT(98, void, png_free_data, (png_const_structrp png_ptr, + png_inforp info_ptr, png_uint_32 free_me, int num)); + +/* Reassign responsibility for freeing existing data, whether allocated + * by libpng or by the application; this works on the png_info structure passed + * in, it does not change the state for other png_info structures. + * + * It is unlikely that this function works correctly as of 1.6.0 and using it + * may result either in memory leaks or double free of allocated data. + */ +PNG_EXPORT(99, void, png_data_freer, (png_const_structrp png_ptr, + png_inforp info_ptr, int freer, png_uint_32 mask)); + +/* Assignments for png_data_freer */ +#define PNG_DESTROY_WILL_FREE_DATA 1 +#define PNG_SET_WILL_FREE_DATA 1 +#define PNG_USER_WILL_FREE_DATA 2 +/* Flags for png_ptr->free_me and info_ptr->free_me */ +#define PNG_FREE_HIST 0x0008 +#define PNG_FREE_ICCP 0x0010 +#define PNG_FREE_SPLT 0x0020 +#define PNG_FREE_ROWS 0x0040 +#define PNG_FREE_PCAL 0x0080 +#define PNG_FREE_SCAL 0x0100 +#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED +# define PNG_FREE_UNKN 0x0200 +#endif +/* PNG_FREE_LIST 0x0400 removed in 1.6.0 because it is ignored */ +#define PNG_FREE_PLTE 0x1000 +#define PNG_FREE_TRNS 0x2000 +#define PNG_FREE_TEXT 0x4000 +#define PNG_FREE_ALL 0x7fff +#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ + +#ifdef PNG_USER_MEM_SUPPORTED +PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED PNG_DEPRECATED); +PNG_EXPORTA(101, void, png_free_default, (png_const_structrp png_ptr, + png_voidp ptr), PNG_DEPRECATED); +#endif + +#ifdef PNG_ERROR_TEXT_SUPPORTED +/* Fatal error in PNG image of libpng - can't continue */ +PNG_EXPORTA(102, void, png_error, (png_const_structrp png_ptr, + png_const_charp error_message), PNG_NORETURN); + +/* The same, but the chunk name is prepended to the error string. */ +PNG_EXPORTA(103, void, png_chunk_error, (png_const_structrp png_ptr, + png_const_charp error_message), PNG_NORETURN); + +#else +/* Fatal error in PNG image of libpng - can't continue */ +PNG_EXPORTA(104, void, png_err, (png_const_structrp png_ptr), PNG_NORETURN); +# define png_error(s1,s2) png_err(s1) +# define png_chunk_error(s1,s2) png_err(s1) +#endif + +#ifdef PNG_WARNINGS_SUPPORTED +/* Non-fatal error in libpng. Can continue, but may have a problem. */ +PNG_EXPORT(105, void, png_warning, (png_const_structrp png_ptr, + png_const_charp warning_message)); + +/* Non-fatal error in libpng, chunk name is prepended to message. */ +PNG_EXPORT(106, void, png_chunk_warning, (png_const_structrp png_ptr, + png_const_charp warning_message)); +#else +# define png_warning(s1,s2) ((void)(s1)) +# define png_chunk_warning(s1,s2) ((void)(s1)) +#endif + +#ifdef PNG_BENIGN_ERRORS_SUPPORTED +/* Benign error in libpng. Can continue, but may have a problem. + * User can choose whether to handle as a fatal error or as a warning. */ +PNG_EXPORT(107, void, png_benign_error, (png_const_structrp png_ptr, + png_const_charp warning_message)); + +#ifdef PNG_READ_SUPPORTED +/* Same, chunk name is prepended to message (only during read) */ +PNG_EXPORT(108, void, png_chunk_benign_error, (png_const_structrp png_ptr, + png_const_charp warning_message)); +#endif + +PNG_EXPORT(109, void, png_set_benign_errors, + (png_structrp png_ptr, int allowed)); +#else +# ifdef PNG_ALLOW_BENIGN_ERRORS +# define png_benign_error png_warning +# define png_chunk_benign_error png_chunk_warning +# else +# define png_benign_error png_error +# define png_chunk_benign_error png_chunk_error +# endif +#endif + +/* The png_set_ functions are for storing values in the png_info_struct. + * Similarly, the png_get_ calls are used to read values from the + * png_info_struct, either storing the parameters in the passed variables, or + * setting pointers into the png_info_struct where the data is stored. The + * png_get_ functions return a non-zero value if the data was available + * in info_ptr, or return zero and do not change any of the parameters if the + * data was not available. + * + * These functions should be used instead of directly accessing png_info + * to avoid problems with future changes in the size and internal layout of + * png_info_struct. + */ +/* Returns "flag" if chunk data is valid in info_ptr. */ +PNG_EXPORT(110, png_uint_32, png_get_valid, (png_const_structrp png_ptr, + png_const_inforp info_ptr, png_uint_32 flag)); + +/* Returns number of bytes needed to hold a transformed row. */ +PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +#ifdef PNG_INFO_IMAGE_SUPPORTED +/* Returns row_pointers, which is an array of pointers to scanlines that was + * returned from png_read_png(). + */ +PNG_EXPORT(112, png_bytepp, png_get_rows, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Set row_pointers, which is an array of pointers to scanlines for use + * by png_write_png(). + */ +PNG_EXPORT(113, void, png_set_rows, (png_const_structrp png_ptr, + png_inforp info_ptr, png_bytepp row_pointers)); +#endif + +/* Returns number of color channels in image. */ +PNG_EXPORT(114, png_byte, png_get_channels, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +#ifdef PNG_EASY_ACCESS_SUPPORTED +/* Returns image width in pixels. */ +PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image height in pixels. */ +PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image bit_depth. */ +PNG_EXPORT(117, png_byte, png_get_bit_depth, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image color_type. */ +PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image filter_type. */ +PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image interlace_type. */ +PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image compression_type. */ +PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); + +/* Returns image resolution in pixels per meter, from pHYs chunk data. */ +PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +/* Returns pixel aspect ratio, computed from pHYs chunk data. */ +PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio, + (png_const_structrp png_ptr, png_const_inforp info_ptr)) +PNG_FIXED_EXPORT(210, png_fixed_point, png_get_pixel_aspect_ratio_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr)) + +/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ +PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(128, png_int_32, png_get_x_offset_microns, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); +PNG_EXPORT(129, png_int_32, png_get_y_offset_microns, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +#endif /* EASY_ACCESS */ + +#ifdef PNG_READ_SUPPORTED +/* Returns pointer to signature string read from PNG header */ +PNG_EXPORT(130, png_const_bytep, png_get_signature, (png_const_structrp png_ptr, + png_const_inforp info_ptr)); +#endif + +#ifdef PNG_bKGD_SUPPORTED +PNG_EXPORT(131, png_uint_32, png_get_bKGD, (png_const_structrp png_ptr, + png_inforp info_ptr, png_color_16p *background)); +#endif + +#ifdef PNG_bKGD_SUPPORTED +PNG_EXPORT(132, void, png_set_bKGD, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_color_16p background)); +#endif + +#ifdef PNG_cHRM_SUPPORTED +PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structrp png_ptr, + png_const_inforp info_ptr, double *white_x, double *white_y, double *red_x, + double *red_y, double *green_x, double *green_y, double *blue_x, + double *blue_y)) +PNG_FP_EXPORT(230, png_uint_32, png_get_cHRM_XYZ, (png_const_structrp png_ptr, + png_const_inforp info_ptr, double *red_X, double *red_Y, double *red_Z, + double *green_X, double *green_Y, double *green_Z, double *blue_X, + double *blue_Y, double *blue_Z)) +PNG_FIXED_EXPORT(134, png_uint_32, png_get_cHRM_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr, + png_fixed_point *int_white_x, png_fixed_point *int_white_y, + png_fixed_point *int_red_x, png_fixed_point *int_red_y, + png_fixed_point *int_green_x, png_fixed_point *int_green_y, + png_fixed_point *int_blue_x, png_fixed_point *int_blue_y)) +PNG_FIXED_EXPORT(231, png_uint_32, png_get_cHRM_XYZ_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr, + png_fixed_point *int_red_X, png_fixed_point *int_red_Y, + png_fixed_point *int_red_Z, png_fixed_point *int_green_X, + png_fixed_point *int_green_Y, png_fixed_point *int_green_Z, + png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y, + png_fixed_point *int_blue_Z)) +#endif + +#ifdef PNG_cHRM_SUPPORTED +PNG_FP_EXPORT(135, void, png_set_cHRM, (png_const_structrp png_ptr, + png_inforp info_ptr, + double white_x, double white_y, double red_x, double red_y, double green_x, + double green_y, double blue_x, double blue_y)) +PNG_FP_EXPORT(232, void, png_set_cHRM_XYZ, (png_const_structrp png_ptr, + png_inforp info_ptr, double red_X, double red_Y, double red_Z, + double green_X, double green_Y, double green_Z, double blue_X, + double blue_Y, double blue_Z)) +PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (png_const_structrp png_ptr, + png_inforp info_ptr, png_fixed_point int_white_x, + png_fixed_point int_white_y, png_fixed_point int_red_x, + png_fixed_point int_red_y, png_fixed_point int_green_x, + png_fixed_point int_green_y, png_fixed_point int_blue_x, + png_fixed_point int_blue_y)) +PNG_FIXED_EXPORT(233, void, png_set_cHRM_XYZ_fixed, (png_const_structrp png_ptr, + png_inforp info_ptr, png_fixed_point int_red_X, png_fixed_point int_red_Y, + png_fixed_point int_red_Z, png_fixed_point int_green_X, + png_fixed_point int_green_Y, png_fixed_point int_green_Z, + png_fixed_point int_blue_X, png_fixed_point int_blue_Y, + png_fixed_point int_blue_Z)) +#endif + +#ifdef PNG_gAMA_SUPPORTED +PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA, (png_const_structrp png_ptr, + png_const_inforp info_ptr, double *file_gamma)) +PNG_FIXED_EXPORT(138, png_uint_32, png_get_gAMA_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr, + png_fixed_point *int_file_gamma)) +#endif + +#ifdef PNG_gAMA_SUPPORTED +PNG_FP_EXPORT(139, void, png_set_gAMA, (png_const_structrp png_ptr, + png_inforp info_ptr, double file_gamma)) +PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_const_structrp png_ptr, + png_inforp info_ptr, png_fixed_point int_file_gamma)) +#endif + +#ifdef PNG_hIST_SUPPORTED +PNG_EXPORT(141, png_uint_32, png_get_hIST, (png_const_structrp png_ptr, + png_inforp info_ptr, png_uint_16p *hist)); +#endif + +#ifdef PNG_hIST_SUPPORTED +PNG_EXPORT(142, void, png_set_hIST, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_uint_16p hist)); +#endif + +PNG_EXPORT(143, png_uint_32, png_get_IHDR, (png_const_structrp png_ptr, + png_const_inforp info_ptr, png_uint_32 *width, png_uint_32 *height, + int *bit_depth, int *color_type, int *interlace_method, + int *compression_method, int *filter_method)); + +PNG_EXPORT(144, void, png_set_IHDR, (png_const_structrp png_ptr, + png_inforp info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, + int color_type, int interlace_method, int compression_method, + int filter_method)); + +#ifdef PNG_oFFs_SUPPORTED +PNG_EXPORT(145, png_uint_32, png_get_oFFs, (png_const_structrp png_ptr, + png_const_inforp info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, + int *unit_type)); +#endif + +#ifdef PNG_oFFs_SUPPORTED +PNG_EXPORT(146, void, png_set_oFFs, (png_const_structrp png_ptr, + png_inforp info_ptr, png_int_32 offset_x, png_int_32 offset_y, + int unit_type)); +#endif + +#ifdef PNG_pCAL_SUPPORTED +PNG_EXPORT(147, png_uint_32, png_get_pCAL, (png_const_structrp png_ptr, + png_inforp info_ptr, png_charp *purpose, png_int_32 *X0, + png_int_32 *X1, int *type, int *nparams, png_charp *units, + png_charpp *params)); +#endif + +#ifdef PNG_pCAL_SUPPORTED +PNG_EXPORT(148, void, png_set_pCAL, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_charp purpose, png_int_32 X0, png_int_32 X1, + int type, int nparams, png_const_charp units, png_charpp params)); +#endif + +#ifdef PNG_pHYs_SUPPORTED +PNG_EXPORT(149, png_uint_32, png_get_pHYs, (png_const_structrp png_ptr, + png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, + int *unit_type)); +#endif + +#ifdef PNG_pHYs_SUPPORTED +PNG_EXPORT(150, void, png_set_pHYs, (png_const_structrp png_ptr, + png_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); +#endif + +PNG_EXPORT(151, png_uint_32, png_get_PLTE, (png_const_structrp png_ptr, + png_inforp info_ptr, png_colorp *palette, int *num_palette)); + +PNG_EXPORT(152, void, png_set_PLTE, (png_structrp png_ptr, + png_inforp info_ptr, png_const_colorp palette, int num_palette)); + +#ifdef PNG_sBIT_SUPPORTED +PNG_EXPORT(153, png_uint_32, png_get_sBIT, (png_const_structrp png_ptr, + png_inforp info_ptr, png_color_8p *sig_bit)); +#endif + +#ifdef PNG_sBIT_SUPPORTED +PNG_EXPORT(154, void, png_set_sBIT, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_color_8p sig_bit)); +#endif + +#ifdef PNG_sRGB_SUPPORTED +PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structrp png_ptr, + png_const_inforp info_ptr, int *file_srgb_intent)); +#endif + +#ifdef PNG_sRGB_SUPPORTED +PNG_EXPORT(156, void, png_set_sRGB, (png_const_structrp png_ptr, + png_inforp info_ptr, int srgb_intent)); +PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_const_structrp png_ptr, + png_inforp info_ptr, int srgb_intent)); +#endif + +#ifdef PNG_iCCP_SUPPORTED +PNG_EXPORT(158, png_uint_32, png_get_iCCP, (png_const_structrp png_ptr, + png_inforp info_ptr, png_charpp name, int *compression_type, + png_bytepp profile, png_uint_32 *proflen)); +#endif + +#ifdef PNG_iCCP_SUPPORTED +PNG_EXPORT(159, void, png_set_iCCP, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_charp name, int compression_type, + png_const_bytep profile, png_uint_32 proflen)); +#endif + +#ifdef PNG_sPLT_SUPPORTED +PNG_EXPORT(160, int, png_get_sPLT, (png_const_structrp png_ptr, + png_inforp info_ptr, png_sPLT_tpp entries)); +#endif + +#ifdef PNG_sPLT_SUPPORTED +PNG_EXPORT(161, void, png_set_sPLT, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_sPLT_tp entries, int nentries)); +#endif + +#ifdef PNG_TEXT_SUPPORTED +/* png_get_text also returns the number of text chunks in *num_text */ +PNG_EXPORT(162, int, png_get_text, (png_const_structrp png_ptr, + png_inforp info_ptr, png_textp *text_ptr, int *num_text)); +#endif + +/* Note while png_set_text() will accept a structure whose text, + * language, and translated keywords are NULL pointers, the structure + * returned by png_get_text will always contain regular + * zero-terminated C strings. They might be empty strings but + * they will never be NULL pointers. + */ + +#ifdef PNG_TEXT_SUPPORTED +PNG_EXPORT(163, void, png_set_text, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_textp text_ptr, int num_text)); +#endif + +#ifdef PNG_tIME_SUPPORTED +PNG_EXPORT(164, png_uint_32, png_get_tIME, (png_const_structrp png_ptr, + png_inforp info_ptr, png_timep *mod_time)); +#endif + +#ifdef PNG_tIME_SUPPORTED +PNG_EXPORT(165, void, png_set_tIME, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_timep mod_time)); +#endif + +#ifdef PNG_tRNS_SUPPORTED +PNG_EXPORT(166, png_uint_32, png_get_tRNS, (png_const_structrp png_ptr, + png_inforp info_ptr, png_bytep *trans_alpha, int *num_trans, + png_color_16p *trans_color)); +#endif + +#ifdef PNG_tRNS_SUPPORTED +PNG_EXPORT(167, void, png_set_tRNS, (png_structrp png_ptr, + png_inforp info_ptr, png_const_bytep trans_alpha, int num_trans, + png_const_color_16p trans_color)); +#endif + +#ifdef PNG_sCAL_SUPPORTED +PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, (png_const_structrp png_ptr, + png_const_inforp info_ptr, int *unit, double *width, double *height)) +#if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \ + defined(PNG_FLOATING_POINT_SUPPORTED) +/* NOTE: this API is currently implemented using floating point arithmetic, + * consequently it can only be used on systems with floating point support. + * In any case the range of values supported by png_fixed_point is small and it + * is highly recommended that png_get_sCAL_s be used instead. + */ +PNG_FIXED_EXPORT(214, png_uint_32, png_get_sCAL_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit, + png_fixed_point *width, png_fixed_point *height)) +#endif +PNG_EXPORT(169, png_uint_32, png_get_sCAL_s, + (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit, + png_charpp swidth, png_charpp sheight)); + +PNG_FP_EXPORT(170, void, png_set_sCAL, (png_const_structrp png_ptr, + png_inforp info_ptr, int unit, double width, double height)) +PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_const_structrp png_ptr, + png_inforp info_ptr, int unit, png_fixed_point width, + png_fixed_point height)) +PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr, + png_inforp info_ptr, int unit, + png_const_charp swidth, png_const_charp sheight)); +#endif /* sCAL */ + +#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED +/* Provide the default handling for all unknown chunks or, optionally, for + * specific unknown chunks. + * + * NOTE: prior to 1.6.0 the handling specified for particular chunks on read was + * ignored and the default was used, the per-chunk setting only had an effect on + * write. If you wish to have chunk-specific handling on read in code that must + * work on earlier versions you must use a user chunk callback to specify the + * desired handling (keep or discard.) + * + * The 'keep' parameter is a PNG_HANDLE_CHUNK_ value as listed below. The + * parameter is interpreted as follows: + * + * READ: + * PNG_HANDLE_CHUNK_AS_DEFAULT: + * Known chunks: do normal libpng processing, do not keep the chunk (but + * see the comments below about PNG_HANDLE_AS_UNKNOWN_SUPPORTED) + * Unknown chunks: for a specific chunk use the global default, when used + * as the default discard the chunk data. + * PNG_HANDLE_CHUNK_NEVER: + * Discard the chunk data. + * PNG_HANDLE_CHUNK_IF_SAFE: + * Keep the chunk data if the chunk is not critical else raise a chunk + * error. + * PNG_HANDLE_CHUNK_ALWAYS: + * Keep the chunk data. + * + * If the chunk data is saved it can be retrieved using png_get_unknown_chunks, + * below. Notice that specifying "AS_DEFAULT" as a global default is equivalent + * to specifying "NEVER", however when "AS_DEFAULT" is used for specific chunks + * it simply resets the behavior to the libpng default. + * + * INTERACTION WTIH USER CHUNK CALLBACKS: + * The per-chunk handling is always used when there is a png_user_chunk_ptr + * callback and the callback returns 0; the chunk is then always stored *unless* + * it is critical and the per-chunk setting is other than ALWAYS. Notice that + * the global default is *not* used in this case. (In effect the per-chunk + * value is incremented to at least IF_SAFE.) + * + * IMPORTANT NOTE: this behavior will change in libpng 1.7 - the global and + * per-chunk defaults will be honored. If you want to preserve the current + * behavior when your callback returns 0 you must set PNG_HANDLE_CHUNK_IF_SAFE + * as the default - if you don't do this libpng 1.6 will issue a warning. + * + * If you want unhandled unknown chunks to be discarded in libpng 1.6 and + * earlier simply return '1' (handled). + * + * PNG_HANDLE_AS_UNKNOWN_SUPPORTED: + * If this is *not* set known chunks will always be handled by libpng and + * will never be stored in the unknown chunk list. Known chunks listed to + * png_set_keep_unknown_chunks will have no effect. If it is set then known + * chunks listed with a keep other than AS_DEFAULT will *never* be processed + * by libpng, in addition critical chunks must either be processed by the + * callback or saved. + * + * The IHDR and IEND chunks must not be listed. Because this turns off the + * default handling for chunks that would otherwise be recognized the + * behavior of libpng transformations may well become incorrect! + * + * WRITE: + * When writing chunks the options only apply to the chunks specified by + * png_set_unknown_chunks (below), libpng will *always* write known chunks + * required by png_set_ calls and will always write the core critical chunks + * (as required for PLTE). + * + * Each chunk in the png_set_unknown_chunks list is looked up in the + * png_set_keep_unknown_chunks list to find the keep setting, this is then + * interpreted as follows: + * + * PNG_HANDLE_CHUNK_AS_DEFAULT: + * Write safe-to-copy chunks and write other chunks if the global + * default is set to _ALWAYS, otherwise don't write this chunk. + * PNG_HANDLE_CHUNK_NEVER: + * Do not write the chunk. + * PNG_HANDLE_CHUNK_IF_SAFE: + * Write the chunk if it is safe-to-copy, otherwise do not write it. + * PNG_HANDLE_CHUNK_ALWAYS: + * Write the chunk. + * + * Note that the default behavior is effectively the opposite of the read case - + * in read unknown chunks are not stored by default, in write they are written + * by default. Also the behavior of PNG_HANDLE_CHUNK_IF_SAFE is very different + * - on write the safe-to-copy bit is checked, on read the critical bit is + * checked and on read if the chunk is critical an error will be raised. + * + * num_chunks: + * =========== + * If num_chunks is positive, then the "keep" parameter specifies the manner + * for handling only those chunks appearing in the chunk_list array, + * otherwise the chunk list array is ignored. + * + * If num_chunks is 0 the "keep" parameter specifies the default behavior for + * unknown chunks, as described above. + * + * If num_chunks is negative, then the "keep" parameter specifies the manner + * for handling all unknown chunks plus all chunks recognized by libpng + * except for the IHDR, PLTE, tRNS, IDAT, and IEND chunks (which continue to + * be processed by libpng. + */ +PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr, + int keep, png_const_bytep chunk_list, int num_chunks)); + +/* The "keep" PNG_HANDLE_CHUNK_ parameter for the specified chunk is returned; + * the result is therefore true (non-zero) if special handling is required, + * false for the default handling. + */ +PNG_EXPORT(173, int, png_handle_as_unknown, (png_const_structrp png_ptr, + png_const_bytep chunk_name)); +#endif + +#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED +PNG_EXPORT(174, void, png_set_unknown_chunks, (png_const_structrp png_ptr, + png_inforp info_ptr, png_const_unknown_chunkp unknowns, + int num_unknowns)); + /* NOTE: prior to 1.6.0 this routine set the 'location' field of the added + * unknowns to the location currently stored in the png_struct. This is + * invariably the wrong value on write. To fix this call the following API + * for each chunk in the list with the correct location. If you know your + * code won't be compiled on earlier versions you can rely on + * png_set_unknown_chunks(write-ptr, png_get_unknown_chunks(read-ptr)) doing + * the correct thing. + */ + +PNG_EXPORT(175, void, png_set_unknown_chunk_location, + (png_const_structrp png_ptr, png_inforp info_ptr, int chunk, int location)); + +PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structrp png_ptr, + png_inforp info_ptr, png_unknown_chunkpp entries)); +#endif + +/* Png_free_data() will turn off the "valid" flag for anything it frees. + * If you need to turn it off for a chunk that your application has freed, + * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); + */ +PNG_EXPORT(177, void, png_set_invalid, (png_const_structrp png_ptr, + png_inforp info_ptr, int mask)); + +#ifdef PNG_INFO_IMAGE_SUPPORTED +/* The "params" pointer is currently not used and is for future expansion. */ +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +PNG_EXPORT(178, void, png_read_png, (png_structrp png_ptr, png_inforp info_ptr, + int transforms, png_voidp params)); +#endif +#ifdef PNG_WRITE_SUPPORTED +PNG_EXPORT(179, void, png_write_png, (png_structrp png_ptr, png_inforp info_ptr, + int transforms, png_voidp params)); +#endif +#endif + +PNG_EXPORT(180, png_const_charp, png_get_copyright, + (png_const_structrp png_ptr)); +PNG_EXPORT(181, png_const_charp, png_get_header_ver, + (png_const_structrp png_ptr)); +PNG_EXPORT(182, png_const_charp, png_get_header_version, + (png_const_structrp png_ptr)); +PNG_EXPORT(183, png_const_charp, png_get_libpng_ver, + (png_const_structrp png_ptr)); + +#ifdef PNG_MNG_FEATURES_SUPPORTED +PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structrp png_ptr, + png_uint_32 mng_features_permitted)); +#endif + +/* For use in png_set_keep_unknown, added to version 1.2.6 */ +#define PNG_HANDLE_CHUNK_AS_DEFAULT 0 +#define PNG_HANDLE_CHUNK_NEVER 1 +#define PNG_HANDLE_CHUNK_IF_SAFE 2 +#define PNG_HANDLE_CHUNK_ALWAYS 3 +#define PNG_HANDLE_CHUNK_LAST 4 + +/* Strip the prepended error numbers ("#nnn ") from error and warning + * messages before passing them to the error or warning handler. + */ +#ifdef PNG_ERROR_NUMBERS_SUPPORTED +PNG_EXPORT(185, void, png_set_strip_error_numbers, (png_structrp png_ptr, + png_uint_32 strip_mode)); +#endif + +/* Added in libpng-1.2.6 */ +#ifdef PNG_SET_USER_LIMITS_SUPPORTED +PNG_EXPORT(186, void, png_set_user_limits, (png_structrp png_ptr, + png_uint_32 user_width_max, png_uint_32 user_height_max)); +PNG_EXPORT(187, png_uint_32, png_get_user_width_max, + (png_const_structrp png_ptr)); +PNG_EXPORT(188, png_uint_32, png_get_user_height_max, + (png_const_structrp png_ptr)); +/* Added in libpng-1.4.0 */ +PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structrp png_ptr, + png_uint_32 user_chunk_cache_max)); +PNG_EXPORT(190, png_uint_32, png_get_chunk_cache_max, + (png_const_structrp png_ptr)); +/* Added in libpng-1.4.1 */ +PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structrp png_ptr, + png_alloc_size_t user_chunk_cache_max)); +PNG_EXPORT(192, png_alloc_size_t, png_get_chunk_malloc_max, + (png_const_structrp png_ptr)); +#endif + +#if defined(PNG_INCH_CONVERSIONS_SUPPORTED) +PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +PNG_EXPORT(194, png_uint_32, png_get_x_pixels_per_inch, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +PNG_EXPORT(195, png_uint_32, png_get_y_pixels_per_inch, + (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +PNG_FP_EXPORT(196, float, png_get_x_offset_inches, + (png_const_structrp png_ptr, png_const_inforp info_ptr)) +#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ +PNG_FIXED_EXPORT(211, png_fixed_point, png_get_x_offset_inches_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr)) +#endif + +PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structrp png_ptr, + png_const_inforp info_ptr)) +#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ +PNG_FIXED_EXPORT(212, png_fixed_point, png_get_y_offset_inches_fixed, + (png_const_structrp png_ptr, png_const_inforp info_ptr)) +#endif + +# ifdef PNG_pHYs_SUPPORTED +PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structrp png_ptr, + png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, + int *unit_type)); +# endif /* pHYs */ +#endif /* INCH_CONVERSIONS */ + +/* Added in libpng-1.4.0 */ +#ifdef PNG_IO_STATE_SUPPORTED +PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_const_structrp png_ptr)); + +/* Removed from libpng 1.6; use png_get_io_chunk_type. */ +PNG_REMOVED(200, png_const_bytep, png_get_io_chunk_name, (png_structrp png_ptr), + PNG_DEPRECATED) + +PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type, + (png_const_structrp png_ptr)); + +/* The flags returned by png_get_io_state() are the following: */ +# define PNG_IO_NONE 0x0000 /* no I/O at this moment */ +# define PNG_IO_READING 0x0001 /* currently reading */ +# define PNG_IO_WRITING 0x0002 /* currently writing */ +# define PNG_IO_SIGNATURE 0x0010 /* currently at the file signature */ +# define PNG_IO_CHUNK_HDR 0x0020 /* currently at the chunk header */ +# define PNG_IO_CHUNK_DATA 0x0040 /* currently at the chunk data */ +# define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */ +# define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */ +# define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */ +#endif /* IO_STATE */ + +/* Interlace support. The following macros are always defined so that if + * libpng interlace handling is turned off the macros may be used to handle + * interlaced images within the application. + */ +#define PNG_INTERLACE_ADAM7_PASSES 7 + +/* Two macros to return the first row and first column of the original, + * full, image which appears in a given pass. 'pass' is in the range 0 + * to 6 and the result is in the range 0 to 7. + */ +#define PNG_PASS_START_ROW(pass) (((1&~(pass))<<(3-((pass)>>1)))&7) +#define PNG_PASS_START_COL(pass) (((1& (pass))<<(3-(((pass)+1)>>1)))&7) + +/* A macro to return the offset between pixels in the output row for a pair of + * pixels in the input - effectively the inverse of the 'COL_SHIFT' macro that + * follows. Note that ROW_OFFSET is the offset from one row to the next whereas + * COL_OFFSET is from one column to the next, within a row. + */ +#define PNG_PASS_ROW_OFFSET(pass) ((pass)>2?(8>>(((pass)-1)>>1)):8) +#define PNG_PASS_COL_OFFSET(pass) (1<<((7-(pass))>>1)) + +/* Two macros to help evaluate the number of rows or columns in each + * pass. This is expressed as a shift - effectively log2 of the number or + * rows or columns in each 8x8 tile of the original image. + */ +#define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3) +#define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3) + +/* Hence two macros to determine the number of rows or columns in a given + * pass of an image given its height or width. In fact these macros may + * return non-zero even though the sub-image is empty, because the other + * dimension may be empty for a small image. + */ +#define PNG_PASS_ROWS(height, pass) (((height)+(((1<>PNG_PASS_ROW_SHIFT(pass)) +#define PNG_PASS_COLS(width, pass) (((width)+(((1<>PNG_PASS_COL_SHIFT(pass)) + +/* For the reader row callbacks (both progressive and sequential) it is + * necessary to find the row in the output image given a row in an interlaced + * image, so two more macros: + */ +#define PNG_ROW_FROM_PASS_ROW(y_in, pass) \ + (((y_in)<>(((7-(off))-(pass))<<2)) & 0xF) | \ + ((0x01145AF0>>(((7-(off))-(pass))<<2)) & 0xF0)) + +#define PNG_ROW_IN_INTERLACE_PASS(y, pass) \ + ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1) +#define PNG_COL_IN_INTERLACE_PASS(x, pass) \ + ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1) + +#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED +/* With these routines we avoid an integer divide, which will be slower on + * most machines. However, it does take more operations than the corresponding + * divide method, so it may be slower on a few RISC systems. There are two + * shifts (by 8 or 16 bits) and an addition, versus a single integer divide. + * + * Note that the rounding factors are NOT supposed to be the same! 128 and + * 32768 are correct for the NODIV code; 127 and 32767 are correct for the + * standard method. + * + * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] + */ + + /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ + +# define png_composite(composite, fg, alpha, bg) \ + { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \ + * (png_uint_16)(alpha) \ + + (png_uint_16)(bg)*(png_uint_16)(255 \ + - (png_uint_16)(alpha)) + 128); \ + (composite) = (png_byte)(((temp + (temp >> 8)) >> 8) & 0xff); } + +# define png_composite_16(composite, fg, alpha, bg) \ + { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \ + * (png_uint_32)(alpha) \ + + (png_uint_32)(bg)*(65535 \ + - (png_uint_32)(alpha)) + 32768); \ + (composite) = (png_uint_16)(0xffff & ((temp + (temp >> 16)) >> 16)); } + +#else /* Standard method using integer division */ + +# define png_composite(composite, fg, alpha, bg) \ + (composite) = \ + (png_byte)(0xff & (((png_uint_16)(fg) * (png_uint_16)(alpha) + \ + (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ + 127) / 255)) + +# define png_composite_16(composite, fg, alpha, bg) \ + (composite) = \ + (png_uint_16)(0xffff & (((png_uint_32)(fg) * (png_uint_32)(alpha) + \ + (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \ + 32767) / 65535)) +#endif /* READ_COMPOSITE_NODIV */ + +#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED +PNG_EXPORT(201, png_uint_32, png_get_uint_32, (png_const_bytep buf)); +PNG_EXPORT(202, png_uint_16, png_get_uint_16, (png_const_bytep buf)); +PNG_EXPORT(203, png_int_32, png_get_int_32, (png_const_bytep buf)); +#endif + +PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_const_structrp png_ptr, + png_const_bytep buf)); +/* No png_get_int_16 -- may be added if there's a real need for it. */ + +/* Place a 32-bit number into a buffer in PNG byte order (big-endian). */ +#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED +PNG_EXPORT(205, void, png_save_uint_32, (png_bytep buf, png_uint_32 i)); +#endif +#ifdef PNG_SAVE_INT_32_SUPPORTED +PNG_EXPORT(206, void, png_save_int_32, (png_bytep buf, png_int_32 i)); +#endif + +/* Place a 16-bit number into a buffer in PNG byte order. + * The parameter is declared unsigned int, not png_uint_16, + * just to avoid potential problems on pre-ANSI C compilers. + */ +#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED +PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i)); +/* No png_save_int_16 -- may be added if there's a real need for it. */ +#endif + +#ifdef PNG_USE_READ_MACROS +/* Inline macros to do direct reads of bytes from the input buffer. + * The png_get_int_32() routine assumes we are using two's complement + * format for negative values, which is almost certainly true. + */ +# define PNG_get_uint_32(buf) \ + (((png_uint_32)(*(buf)) << 24) + \ + ((png_uint_32)(*((buf) + 1)) << 16) + \ + ((png_uint_32)(*((buf) + 2)) << 8) + \ + ((png_uint_32)(*((buf) + 3)))) + + /* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the + * function) incorrectly returned a value of type png_uint_32. + */ +# define PNG_get_uint_16(buf) \ + ((png_uint_16) \ + (((unsigned int)(*(buf)) << 8) + \ + ((unsigned int)(*((buf) + 1))))) + +# define PNG_get_int_32(buf) \ + ((png_int_32)((*(buf) & 0x80) \ + ? -((png_int_32)(((png_get_uint_32(buf)^0xffffffffU)+1U)&0x7fffffffU)) \ + : (png_int_32)png_get_uint_32(buf))) + + /* If PNG_PREFIX is defined the same thing as below happens in pnglibconf.h, + * but defining a macro name prefixed with PNG_PREFIX. + */ +# ifndef PNG_PREFIX +# define png_get_uint_32(buf) PNG_get_uint_32(buf) +# define png_get_uint_16(buf) PNG_get_uint_16(buf) +# define png_get_int_32(buf) PNG_get_int_32(buf) +# endif +#else +# ifdef PNG_PREFIX + /* No macros; revert to the (redefined) function */ +# define PNG_get_uint_32 (png_get_uint_32) +# define PNG_get_uint_16 (png_get_uint_16) +# define PNG_get_int_32 (png_get_int_32) +# endif +#endif + +#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED +PNG_EXPORT(242, void, png_set_check_for_invalid_index, + (png_structrp png_ptr, int allowed)); +# ifdef PNG_GET_PALETTE_MAX_SUPPORTED +PNG_EXPORT(243, int, png_get_palette_max, (png_const_structp png_ptr, + png_const_infop info_ptr)); +# endif +#endif /* CHECK_FOR_INVALID_INDEX */ + +/******************************************************************************* + * Section 5: SIMPLIFIED API + ******************************************************************************* + * + * Please read the documentation in libpng-manual.txt (TODO: write said + * documentation) if you don't understand what follows. + * + * The simplified API hides the details of both libpng and the PNG file format + * itself. It allows PNG files to be read into a very limited number of + * in-memory bitmap formats or to be written from the same formats. If these + * formats do not accomodate your needs then you can, and should, use the more + * sophisticated APIs above - these support a wide variety of in-memory formats + * and a wide variety of sophisticated transformations to those formats as well + * as a wide variety of APIs to manipulate ancillary information. + * + * To read a PNG file using the simplified API: + * + * 1) Declare a 'png_image' structure (see below) on the stack, set the + * version field to PNG_IMAGE_VERSION and the 'opaque' pointer to NULL + * (this is REQUIRED, your program may crash if you don't do it.) + * 2) Call the appropriate png_image_begin_read... function. + * 3) Set the png_image 'format' member to the required sample format. + * 4) Allocate a buffer for the image and, if required, the color-map. + * 5) Call png_image_finish_read to read the image and, if required, the + * color-map into your buffers. + * + * There are no restrictions on the format of the PNG input itself; all valid + * color types, bit depths, and interlace methods are acceptable, and the + * input image is transformed as necessary to the requested in-memory format + * during the png_image_finish_read() step. The only caveat is that if you + * request a color-mapped image from a PNG that is full-color or makes + * complex use of an alpha channel the transformation is extremely lossy and the + * result may look terrible. + * + * To write a PNG file using the simplified API: + * + * 1) Declare a 'png_image' structure on the stack and memset() it to all zero. + * 2) Initialize the members of the structure that describe the image, setting + * the 'format' member to the format of the image samples. + * 3) Call the appropriate png_image_write... function with a pointer to the + * image and, if necessary, the color-map to write the PNG data. + * + * png_image is a structure that describes the in-memory format of an image + * when it is being read or defines the in-memory format of an image that you + * need to write: + */ +#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) || \ + defined(PNG_SIMPLIFIED_WRITE_SUPPORTED) + +#define PNG_IMAGE_VERSION 1 + +typedef struct png_control *png_controlp; +typedef struct +{ + png_controlp opaque; /* Initialize to NULL, free with png_image_free */ + png_uint_32 version; /* Set to PNG_IMAGE_VERSION */ + png_uint_32 width; /* Image width in pixels (columns) */ + png_uint_32 height; /* Image height in pixels (rows) */ + png_uint_32 format; /* Image format as defined below */ + png_uint_32 flags; /* A bit mask containing informational flags */ + png_uint_32 colormap_entries; + /* Number of entries in the color-map */ + + /* In the event of an error or warning the following field will be set to a + * non-zero value and the 'message' field will contain a '\0' terminated + * string with the libpng error or warning message. If both warnings and + * an error were encountered, only the error is recorded. If there + * are multiple warnings, only the first one is recorded. + * + * The upper 30 bits of this value are reserved, the low two bits contain + * a value as follows: + */ +# define PNG_IMAGE_WARNING 1 +# define PNG_IMAGE_ERROR 2 + /* + * The result is a two-bit code such that a value more than 1 indicates + * a failure in the API just called: + * + * 0 - no warning or error + * 1 - warning + * 2 - error + * 3 - error preceded by warning + */ +# define PNG_IMAGE_FAILED(png_cntrl) ((((png_cntrl).warning_or_error)&0x03)>1) + + png_uint_32 warning_or_error; + + char message[64]; +} png_image, *png_imagep; + +/* The samples of the image have one to four channels whose components have + * original values in the range 0 to 1.0: + * + * 1: A single gray or luminance channel (G). + * 2: A gray/luminance channel and an alpha channel (GA). + * 3: Three red, green, blue color channels (RGB). + * 4: Three color channels and an alpha channel (RGBA). + * + * The components are encoded in one of two ways: + * + * a) As a small integer, value 0..255, contained in a single byte. For the + * alpha channel the original value is simply value/255. For the color or + * luminance channels the value is encoded according to the sRGB specification + * and matches the 8-bit format expected by typical display devices. + * + * The color/gray channels are not scaled (pre-multiplied) by the alpha + * channel and are suitable for passing to color management software. + * + * b) As a value in the range 0..65535, contained in a 2-byte integer. All + * channels can be converted to the original value by dividing by 65535; all + * channels are linear. Color channels use the RGB encoding (RGB end-points) of + * the sRGB specification. This encoding is identified by the + * PNG_FORMAT_FLAG_LINEAR flag below. + * + * When the simplified API needs to convert between sRGB and linear colorspaces, + * the actual sRGB transfer curve defined in the sRGB specification (see the + * article at http://en.wikipedia.org/wiki/SRGB) is used, not the gamma=1/2.2 + * approximation used elsewhere in libpng. + * + * When an alpha channel is present it is expected to denote pixel coverage + * of the color or luminance channels and is returned as an associated alpha + * channel: the color/gray channels are scaled (pre-multiplied) by the alpha + * value. + * + * The samples are either contained directly in the image data, between 1 and 8 + * bytes per pixel according to the encoding, or are held in a color-map indexed + * by bytes in the image data. In the case of a color-map the color-map entries + * are individual samples, encoded as above, and the image data has one byte per + * pixel to select the relevant sample from the color-map. + */ + +/* PNG_FORMAT_* + * + * #defines to be used in png_image::format. Each #define identifies a + * particular layout of sample data and, if present, alpha values. There are + * separate defines for each of the two component encodings. + * + * A format is built up using single bit flag values. All combinations are + * valid. Formats can be built up from the flag values or you can use one of + * the predefined values below. When testing formats always use the FORMAT_FLAG + * macros to test for individual features - future versions of the library may + * add new flags. + * + * When reading or writing color-mapped images the format should be set to the + * format of the entries in the color-map then png_image_{read,write}_colormap + * called to read or write the color-map and set the format correctly for the + * image data. Do not set the PNG_FORMAT_FLAG_COLORMAP bit directly! + * + * NOTE: libpng can be built with particular features disabled. If you see + * compiler errors because the definition of one of the following flags has been + * compiled out it is because libpng does not have the required support. It is + * possible, however, for the libpng configuration to enable the format on just + * read or just write; in that case you may see an error at run time. You can + * guard against this by checking for the definition of the appropriate + * "_SUPPORTED" macro, one of: + * + * PNG_SIMPLIFIED_{READ,WRITE}_{BGR,AFIRST}_SUPPORTED + */ +#define PNG_FORMAT_FLAG_ALPHA 0x01U /* format with an alpha channel */ +#define PNG_FORMAT_FLAG_COLOR 0x02U /* color format: otherwise grayscale */ +#define PNG_FORMAT_FLAG_LINEAR 0x04U /* 2-byte channels else 1-byte */ +#define PNG_FORMAT_FLAG_COLORMAP 0x08U /* image data is color-mapped */ + +#ifdef PNG_FORMAT_BGR_SUPPORTED +# define PNG_FORMAT_FLAG_BGR 0x10U /* BGR colors, else order is RGB */ +#endif + +#ifdef PNG_FORMAT_AFIRST_SUPPORTED +# define PNG_FORMAT_FLAG_AFIRST 0x20U /* alpha channel comes first */ +#endif + +/* Commonly used formats have predefined macros. + * + * First the single byte (sRGB) formats: + */ +#define PNG_FORMAT_GRAY 0 +#define PNG_FORMAT_GA PNG_FORMAT_FLAG_ALPHA +#define PNG_FORMAT_AG (PNG_FORMAT_GA|PNG_FORMAT_FLAG_AFIRST) +#define PNG_FORMAT_RGB PNG_FORMAT_FLAG_COLOR +#define PNG_FORMAT_BGR (PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_BGR) +#define PNG_FORMAT_RGBA (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_ALPHA) +#define PNG_FORMAT_ARGB (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_AFIRST) +#define PNG_FORMAT_BGRA (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_ALPHA) +#define PNG_FORMAT_ABGR (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_AFIRST) + +/* Then the linear 2-byte formats. When naming these "Y" is used to + * indicate a luminance (gray) channel. + */ +#define PNG_FORMAT_LINEAR_Y PNG_FORMAT_FLAG_LINEAR +#define PNG_FORMAT_LINEAR_Y_ALPHA (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_ALPHA) +#define PNG_FORMAT_LINEAR_RGB (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR) +#define PNG_FORMAT_LINEAR_RGB_ALPHA \ + (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA) + +/* With color-mapped formats the image data is one byte for each pixel, the byte + * is an index into the color-map which is formatted as above. To obtain a + * color-mapped format it is sufficient just to add the PNG_FOMAT_FLAG_COLORMAP + * to one of the above definitions, or you can use one of the definitions below. + */ +#define PNG_FORMAT_RGB_COLORMAP (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_COLORMAP) +#define PNG_FORMAT_BGR_COLORMAP (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_COLORMAP) +#define PNG_FORMAT_RGBA_COLORMAP (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_COLORMAP) +#define PNG_FORMAT_ARGB_COLORMAP (PNG_FORMAT_ARGB|PNG_FORMAT_FLAG_COLORMAP) +#define PNG_FORMAT_BGRA_COLORMAP (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_COLORMAP) +#define PNG_FORMAT_ABGR_COLORMAP (PNG_FORMAT_ABGR|PNG_FORMAT_FLAG_COLORMAP) + +/* PNG_IMAGE macros + * + * These are convenience macros to derive information from a png_image + * structure. The PNG_IMAGE_SAMPLE_ macros return values appropriate to the + * actual image sample values - either the entries in the color-map or the + * pixels in the image. The PNG_IMAGE_PIXEL_ macros return corresponding values + * for the pixels and will always return 1 for color-mapped formats. The + * remaining macros return information about the rows in the image and the + * complete image. + * + * NOTE: All the macros that take a png_image::format parameter are compile time + * constants if the format parameter is, itself, a constant. Therefore these + * macros can be used in array declarations and case labels where required. + * Similarly the macros are also pre-processor constants (sizeof is not used) so + * they can be used in #if tests. + * + * First the information about the samples. + */ +#define PNG_IMAGE_SAMPLE_CHANNELS(fmt)\ + (((fmt)&(PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA))+1) + /* Return the total number of channels in a given format: 1..4 */ + +#define PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt)\ + ((((fmt) & PNG_FORMAT_FLAG_LINEAR) >> 2)+1) + /* Return the size in bytes of a single component of a pixel or color-map + * entry (as appropriate) in the image: 1 or 2. + */ + +#define PNG_IMAGE_SAMPLE_SIZE(fmt)\ + (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt)) + /* This is the size of the sample data for one sample. If the image is + * color-mapped it is the size of one color-map entry (and image pixels are + * one byte in size), otherwise it is the size of one image pixel. + */ + +#define PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(fmt)\ + (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * 256) + /* The maximum size of the color-map required by the format expressed in a + * count of components. This can be used to compile-time allocate a + * color-map: + * + * png_uint_16 colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(linear_fmt)]; + * + * png_byte colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(sRGB_fmt)]; + * + * Alternatively use the PNG_IMAGE_COLORMAP_SIZE macro below to use the + * information from one of the png_image_begin_read_ APIs and dynamically + * allocate the required memory. + */ + +/* Corresponding information about the pixels */ +#define PNG_IMAGE_PIXEL_(test,fmt)\ + (((fmt)&PNG_FORMAT_FLAG_COLORMAP)?1:test(fmt)) + +#define PNG_IMAGE_PIXEL_CHANNELS(fmt)\ + PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_CHANNELS,fmt) + /* The number of separate channels (components) in a pixel; 1 for a + * color-mapped image. + */ + +#define PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)\ + PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_COMPONENT_SIZE,fmt) + /* The size, in bytes, of each component in a pixel; 1 for a color-mapped + * image. + */ + +#define PNG_IMAGE_PIXEL_SIZE(fmt) PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_SIZE,fmt) + /* The size, in bytes, of a complete pixel; 1 for a color-mapped image. */ + +/* Information about the whole row, or whole image */ +#define PNG_IMAGE_ROW_STRIDE(image)\ + (PNG_IMAGE_PIXEL_CHANNELS((image).format) * (image).width) + /* Return the total number of components in a single row of the image; this + * is the minimum 'row stride', the minimum count of components between each + * row. For a color-mapped image this is the minimum number of bytes in a + * row. + */ + +#define PNG_IMAGE_BUFFER_SIZE(image, row_stride)\ + (PNG_IMAGE_PIXEL_COMPONENT_SIZE((image).format)*(image).height*(row_stride)) + /* Return the size, in bytes, of an image buffer given a png_image and a row + * stride - the number of components to leave space for in each row. + */ + +#define PNG_IMAGE_SIZE(image)\ + PNG_IMAGE_BUFFER_SIZE(image, PNG_IMAGE_ROW_STRIDE(image)) + /* Return the size, in bytes, of the image in memory given just a png_image; + * the row stride is the minimum stride required for the image. + */ + +#define PNG_IMAGE_COLORMAP_SIZE(image)\ + (PNG_IMAGE_SAMPLE_SIZE((image).format) * (image).colormap_entries) + /* Return the size, in bytes, of the color-map of this image. If the image + * format is not a color-map format this will return a size sufficient for + * 256 entries in the given format; check PNG_FORMAT_FLAG_COLORMAP if + * you don't want to allocate a color-map in this case. + */ + +/* PNG_IMAGE_FLAG_* + * + * Flags containing additional information about the image are held in the + * 'flags' field of png_image. + */ +#define PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB 0x01 + /* This indicates the the RGB values of the in-memory bitmap do not + * correspond to the red, green and blue end-points defined by sRGB. + */ + +#define PNG_IMAGE_FLAG_FAST 0x02 + /* On write emphasise speed over compression; the resultant PNG file will be + * larger but will be produced significantly faster, particular for large + * images. Do not use this option for images which will be distributed, only + * used it when producing intermediate files that will be read back in + * repeatedly. For a typical 24-bit image the option will double the read + * speed at the cost of increasing the image size by 25%, however for many + * more compressible images the PNG file can be 10 times larger with only a + * slight speed gain. + */ + +#define PNG_IMAGE_FLAG_16BIT_sRGB 0x04 + /* On read if the image is a 16-bit per component image and there is no gAMA + * or sRGB chunk assume that the components are sRGB encoded. Notice that + * images output by the simplified API always have gamma information; setting + * this flag only affects the interpretation of 16-bit images from an + * external source. It is recommended that the application expose this flag + * to the user; the user can normally easily recognize the difference between + * linear and sRGB encoding. This flag has no effect on write - the data + * passed to the write APIs must have the correct encoding (as defined + * above.) + * + * If the flag is not set (the default) input 16-bit per component data is + * assumed to be linear. + * + * NOTE: the flag can only be set after the png_image_begin_read_ call, + * because that call initializes the 'flags' field. + */ + +#ifdef PNG_SIMPLIFIED_READ_SUPPORTED +/* READ APIs + * --------- + * + * The png_image passed to the read APIs must have been initialized by setting + * the png_controlp field 'opaque' to NULL (or, safer, memset the whole thing.) + */ +#ifdef PNG_STDIO_SUPPORTED +PNG_EXPORT(234, int, png_image_begin_read_from_file, (png_imagep image, + const char *file_name)); + /* The named file is opened for read and the image header is filled in + * from the PNG header in the file. + */ + +PNG_EXPORT(235, int, png_image_begin_read_from_stdio, (png_imagep image, + FILE* file)); + /* The PNG header is read from the stdio FILE object. */ +#endif /* STDIO */ + +PNG_EXPORT(236, int, png_image_begin_read_from_memory, (png_imagep image, + png_const_voidp memory, png_size_t size)); + /* The PNG header is read from the given memory buffer. */ + +PNG_EXPORT(237, int, png_image_finish_read, (png_imagep image, + png_const_colorp background, void *buffer, png_int_32 row_stride, + void *colormap)); + /* Finish reading the image into the supplied buffer and clean up the + * png_image structure. + * + * row_stride is the step, in byte or 2-byte units as appropriate, + * between adjacent rows. A positive stride indicates that the top-most row + * is first in the buffer - the normal top-down arrangement. A negative + * stride indicates that the bottom-most row is first in the buffer. + * + * background need only be supplied if an alpha channel must be removed from + * a png_byte format and the removal is to be done by compositing on a solid + * color; otherwise it may be NULL and any composition will be done directly + * onto the buffer. The value is an sRGB color to use for the background, + * for grayscale output the green channel is used. + * + * background must be supplied when an alpha channel must be removed from a + * single byte color-mapped output format, in other words if: + * + * 1) The original format from png_image_begin_read_from_* had + * PNG_FORMAT_FLAG_ALPHA set. + * 2) The format set by the application does not. + * 3) The format set by the application has PNG_FORMAT_FLAG_COLORMAP set and + * PNG_FORMAT_FLAG_LINEAR *not* set. + * + * For linear output removing the alpha channel is always done by compositing + * on black and background is ignored. + * + * colormap must be supplied when PNG_FORMAT_FLAG_COLORMAP is set. It must + * be at least the size (in bytes) returned by PNG_IMAGE_COLORMAP_SIZE. + * image->colormap_entries will be updated to the actual number of entries + * written to the colormap; this may be less than the original value. + */ + +PNG_EXPORT(238, void, png_image_free, (png_imagep image)); + /* Free any data allocated by libpng in image->opaque, setting the pointer to + * NULL. May be called at any time after the structure is initialized. + */ +#endif /* SIMPLIFIED_READ */ + +#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED +#ifdef PNG_STDIO_SUPPORTED +/* WRITE APIS + * ---------- + * For write you must initialize a png_image structure to describe the image to + * be written. To do this use memset to set the whole structure to 0 then + * initialize fields describing your image. + * + * version: must be set to PNG_IMAGE_VERSION + * opaque: must be initialized to NULL + * width: image width in pixels + * height: image height in rows + * format: the format of the data (image and color-map) you wish to write + * flags: set to 0 unless one of the defined flags applies; set + * PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB for color format images where the RGB + * values do not correspond to the colors in sRGB. + * colormap_entries: set to the number of entries in the color-map (0 to 256) + */ +PNG_EXPORT(239, int, png_image_write_to_file, (png_imagep image, + const char *file, int convert_to_8bit, const void *buffer, + png_int_32 row_stride, const void *colormap)); + /* Write the image to the named file. */ + +PNG_EXPORT(240, int, png_image_write_to_stdio, (png_imagep image, FILE *file, + int convert_to_8_bit, const void *buffer, png_int_32 row_stride, + const void *colormap)); + /* Write the image to the given (FILE*). */ + +/* With both write APIs if image is in one of the linear formats with 16-bit + * data then setting convert_to_8_bit will cause the output to be an 8-bit PNG + * gamma encoded according to the sRGB specification, otherwise a 16-bit linear + * encoded PNG file is written. + * + * With color-mapped data formats the colormap parameter point to a color-map + * with at least image->colormap_entries encoded in the specified format. If + * the format is linear the written PNG color-map will be converted to sRGB + * regardless of the convert_to_8_bit flag. + * + * With all APIs row_stride is handled as in the read APIs - it is the spacing + * from one row to the next in component sized units (1 or 2 bytes) and if + * negative indicates a bottom-up row layout in the buffer. If row_stride is zero, + * libpng will calculate it for you from the image width and number of channels. + * + * Note that the write API does not support interlacing, sub-8-bit pixels, indexed + * PNG (color_type 3) or most ancillary chunks. + */ +#endif /* STDIO */ +#endif /* SIMPLIFIED_WRITE */ +/******************************************************************************* + * END OF SIMPLIFIED API + ******************************************************************************/ +#endif /* SIMPLIFIED_{READ|WRITE} */ + +/******************************************************************************* + * Section 6: IMPLEMENTATION OPTIONS + ******************************************************************************* + * + * Support for arbitrary implementation-specific optimizations. The API allows + * particular options to be turned on or off. 'Option' is the number of the + * option and 'onoff' is 0 (off) or non-0 (on). The value returned is given + * by the PNG_OPTION_ defines below. + * + * HARDWARE: normally hardware capabilites, such as the Intel SSE instructions, + * are detected at run time, however sometimes it may be impossible + * to do this in user mode, in which case it is necessary to discover + * the capabilities in an OS specific way. Such capabilities are + * listed here when libpng has support for them and must be turned + * ON by the application if present. + * + * SOFTWARE: sometimes software optimizations actually result in performance + * decrease on some architectures or systems, or with some sets of + * PNG images. 'Software' options allow such optimizations to be + * selected at run time. + */ +#ifdef PNG_SET_OPTION_SUPPORTED +#ifdef PNG_ARM_NEON_API_SUPPORTED +# define PNG_ARM_NEON 0 /* HARDWARE: ARM Neon SIMD instructions supported */ +#endif +#define PNG_MAXIMUM_INFLATE_WINDOW 2 /* SOFTWARE: force maximum window */ +#define PNG_SKIP_sRGB_CHECK_PROFILE 4 /* SOFTWARE: Check ICC profile for sRGB */ +#define PNG_OPTION_NEXT 6 /* Next option - numbers must be even */ + +/* Return values: NOTE: there are four values and 'off' is *not* zero */ +#define PNG_OPTION_UNSET 0 /* Unset - defaults to off */ +#define PNG_OPTION_INVALID 1 /* Option number out of range */ +#define PNG_OPTION_OFF 2 +#define PNG_OPTION_ON 3 + +PNG_EXPORT(244, int, png_set_option, (png_structrp png_ptr, int option, + int onoff)); +#endif /* SET_OPTION */ + +/******************************************************************************* + * END OF HARDWARE AND SOFTWARE OPTIONS + ******************************************************************************/ + +/* Maintainer: Put new public prototypes here ^, in libpng.3, in project + * defs, and in scripts/symbols.def. + */ + +/* The last ordinal number (this is the *last* one already used; the next + * one to use is one more than this.) + */ +#ifdef PNG_EXPORT_LAST_ORDINAL + PNG_EXPORT_LAST_ORDINAL(244); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* PNG_VERSION_INFO_ONLY */ +/* Do not put anything past this line */ +#endif /* PNG_H */ diff --git a/install/Hdd/Shared/Libraries/zlib.lib b/install/Hdd/Shared/Libraries/zlib.lib new file mode 100644 index 0000000000000000000000000000000000000000..799d27f8e54544abca3abe9de92d47696b9abeb1 GIT binary patch literal 277672 zcmeFa349dg{Xaf4yV;rDkPyOsW;ejX0D&Z2%L>X3%CTtT9StD|L_-pDpy0J4q9`8q zY`uzB+gh#l+gAOq_f>7REmm9WZLM0ZZLOksBK+T<=a_kBvk6D+ufG1@1ZJL@&-1yS z&+~bXd9IDjtZJ!Vb8u)<*!x#9Wm?J9$tBZbQ@!wF@mf+cHO3!ThBQq(MAJe?bbgK5 zsA;p#>hjV9k7(>F9jocxxQy^onz20KUVl7GGY;_b{rNskz5IGobFRV7nx9{l8y2** zG_`1z8!BsCTGqC%##2N6s(DRoo9i2D7dBL_Zsm}pYFk?Cn;P-5wsvjx+Gg?4yq-U7 zsBLM|D%%^YLD*8;3ZlxI`qs9}>ZY1nJU7%fu5Mc+-`ZL#s~YN8gIOgW>l)fy*Ho^m zZzCf2y`ic4WDclrtZ(B_t!+&$wKbKi+_<)?h6bom-&ogB)m94u&Ffq0SFZuS1hrMI zYJdvj)p?i)Oy^}mV~z8?sJ3l>eRUhsTGirW0J^xgs-_l}5}Xc&R;87mSNCmMRST3C zm@8W9*SZ=UQQKPUs>j|+9aQ$Zq_!636~tv3)hS!wSnZXY(-T|)mmh= zh+I+ISX18!x0CPOSmI3>OMTiwh%9>msGb@Plowf0QlNf%xIq1 zX;ZYy)wOWtmg-93Os<#9C*mPoUl^&XrlGclc#8*@dl~@z_qzrwj)}@_Whfg}*b%75 zHjdG>vu0`9BLQ6-TdHeEg$*sR+|bVYqoLjRXP=hT{aW*2KUH^{FYRBpM*l+WUr?ie zR+s;RT9#(Ae_43y{GVS7XnxJmbkD#4w^hUbr<$;O9=7F(t>V=3J+5;5z z1A|SHT}0Va?4&1IQd~T38q6_$N=d2PliagM*Ouy|rwl(jw)+>oZhh(YWp`Zn!aar2 zvd8{7Ow;=IGBt|3YpAB>p$?|Mi8U>?)otr)`J1L4j)w`ld=p_PPn%d>-!Q6fwG%M_ zIA^Be&DQc}GrZLe4&J9eO}oNyUfF|#SKsJF=-{;_;JkYAYEN?_c0=(CP3P5%*Sg+` zsDsQ4205=@yqZ-`#AA5+V2JbT;K8Ov)SRLV+7d6E7q3{+(zF`ghVVi_TEk;ci%qjD zmep6cG_^L>wS|wWZ*8w?2$!|B*VH$KOG+meR~$930!?{Eb?L;KhK9m$AFwWJTi;w; zQ{SK!)oEaPWGi~K6)V=%H`F&*%&%=dxviy$&n=5Z3u`2BU3E!m@x*4B zya?U^`2|C$M|cVlnv@S=I51c4o?EZps>A%C*dtO|2DeO{~%iU!|&!9d_jr zPdxi||IvHi$getJp4Cl_brXqaXvYgbTk!R1Z|}I^n8}l`+4}qZ$^+(!+-EFnUc7Zs z_MZ|v7mVHf_A@^p(Jz1c0kdSaW;N8@v*YLo1|0Q|mAj5P?##z4ubyRS9|lHi8}S9` z&(lV0$zJeV-OxUgz-$8MaNrIJ)Cri&fgektius8I<`8CYj=56;Rm@K%upeRm2BjU+ zKa)U}{BsHHPnb`0%r7KRRp~1U3?zX$gfO+-KV)fCtmH@KW?z;cKA6mdZWl!Ga5;UL z=dQ`q^sfR&?uh}0J&)H2{G)WU!AUGI+(INDfFvh*tp*}3_byQI4_nDPAFMAVypwZq z`wZ*{tjW{$#{+uqi$JE2T6_?0G_w$+B~JvCC&PI7kgx}$dK|kZ&!^?SAyD!CyIJQ7 z^aJCIi1Dv-ak~hpOBw3h9F=_-OSTEHeTvu?;UU=zwdANZc?P=P%~|bBoA4E+6=rKq zS?!17TTW{?w8z0iewS}XS6UyNM6ufnVt?qvfbmhl*by*34j7*VjGY1F(}3|=!1z31 zd=W6RwNtX@u5YWY)3k85*2tdmNM) z;qKGX=?BQyzn*>RSGCpS<2t-fj18FZ70s8ks=cnRwk6Ce9N>eQuU~y*E1>n&^|g&{ zVHmp!-`1uEVZQ8|suMP4p>C=;7#BfjOJ!T^){p8A#}na>GWL zzo=X<*A9gDDDXZpAb5{X=wqT^2PSWx)25Yfo?Eyip^v2(|3R7w(YEb3_DR6>h|0yCgMe>2*TDKJzhFi0pc zSSTg(4$`BBP)Pac@n19YAi+!4=;H=WB!WAv|#BOI`>~;DC1p78XTK?%&Ca z0E<4(oX|)`O*n@S2FUmO$7)*f59d7-=H5RR3MID!7fRr{8%kWym3R?Kj5mwMnMJl# zNV;L?Uw{eh{5I@7%Pg8Hjr>c1Q?nG$nQg`oA>Hmqggx7|=P*Ow zgSY5R$62;nOhxG|_aYX~GS`gG>fkJMOnV;j`(MH_Z15I|V9iW&0S2d*`SdRX1)8qs z=s8Bf=NoPI(+u6`8)f#zV4u%7QiO#(Gz!dojJ5cT5oR9>eM1HQ5P>&Xgo6Zre}Ugm z;P(;uc>=Gu2y+E~w!jYwd{f{D1YVX1{Q_SX_!`I8cR7jCjjsb*9b2)o8B@-FKL#2L zbA0??z^9Kjd9rmqYHAo;!U&$`V_0ou38Tcs3^bgt0(a#F%J~fVq5nkwZV; z)G$k+K?!v?L9hW9Y_oQ#*-N=7wp9S^P-! zJdxR!0S9cAm6eSW7@=(6sEc`uERzJ$Qe^3l}W8<<9$-7MCA4 z9)76p&%A*%1>!tpo(pLa^OEkg$BvH%X=ZI% z@pmwG%OUFg9i_>qAC9~CPo2BNfG==p_RjmK&f8)31voTw=lx?iV$P22>Vs2wF)*J< z^Mqo)js~)QI?dR5{}_&#tD`ADpH8!N-am#T=IKxvfI~BN-apb|Qi)hdhY36S>ue5L z&X-P|I!#%5*ZF+uw*KyX=^6dHKVLcomfDy3(tBZvYtpQdX}%OA{n~OiQ{dXf!Bgf- z*JJjeqBA^YzVwe^^QU~57d<)rl=;%<0l%$pM?9GRTRC4UR|9-IXH2Dbw0>cK=S=@d zMaP{p{RNz6pXW>ud@i!{`OOm!crx;vpWl>rr5VomN8EhQEpOiT{-{}(G!HAe5Yvg< zGtCD+63_${tsRw9Yok$lofkoEdp^zAByYjop5Om!mi|VTu_2&ur&+E>W#VkDoH+Bp zk)?@MMYQH0D~;a$6*o% z{7uGWYZjJV*0wZOHB`2?Vc`lGjb)53&e{M7O<`5G0yu&J+q2d+)z>s*J}&8lHrd+s z4wi#+g9B;?tRJImQl{}5cjc7^^80jVWlwkgy592mR~RoP_M_MRCqt>>@D z0zDS!u|SUndMwamfgTI=Sl}D5K*Bfyvr+prZACL+gpAoQn!ySl$kfzujH^C^an*+c zMGppw9tafOAK+62BQPa~sjui`e5Pv5=6PGfsRsiz96f=C-!YtxJBHf}1&SXiJFV11 zGJE4#A#1|t5v4t8(49A{g{J&x&#*bpYBWgbt5EQ+*(EA~Dn{jy;_wc%1#T6dVTci^G#Q&)*tGDsV?K#|xID5ceI5yNtzM zMsY=$N{Ma=JV-nZD8{#aYy|kB zfEZ$4s*XJu>iUB+B5l-H*B=P5v1dl$3`-Z{^HbOF=TQnt7;qXWehlo`*Q8Kbv=flWt7{&f}4fPsVgl`OA7yfa07>)RzYi+Y`wsuX(ZD7$HrR4o((?sOQVq9 zKZfHO`=t>`?;peQjQ!H+qxX;Dc*cHd6 zH^#SH{-+Z>W$gEGcuw<^9r3=cW50ZZ*SB-zm+N*Q7TR_BrXJ`p5H6Jm8UEwhblY4xH)(=GplO^?~o|>2!qpB6EKx z5tV&hJpU=_hkyOd!4tNxe7f%=_2FM%e)SIyd{>Y3_dNZ9!6zJ9F>3erohN{<j@ljKSX9$*-~(<2AR!)aV!lfyZW#l1Cuo z3BuE{-8%;xO!Ta)O#Nz8zsA(BHT4@zJ@*C^qrlj;&kskC0*LTqBHYmnRd#ZVwm6TL zrI}juDK$-}Hm<3yYIc-)AGn_o?xxATI;?*icinCz~uYV^`kIzA_oL&o8jf(4Tyo{q(kpHYT-ouG!7O2F~T2zEN+hh zKRI3pg|XH25mAFj5<81Sl9Gmx6X{ha;hsiEtwtfw6Uz1Z_f#mv(Gfn+0nCb;nlV>iZdHpV^@ikGN zdNOXu;w?GAk1P#v%FU*JzNueg>X$R6ef) zb3Yk78%IR6SHq+@AmUronHRapjOfc4sQ8 z6RT_2I9Moqj6Xg`41YhYgG+Kr`UR%0YgapXHJQ;2&5hlX(}h_;#B51ASYzHqeB5xKWNYMMLe(2hIn!p`CAH zO-5TwRb>r3EIrYH^V5_8ll?8O&H?9exx-`|$h z;a7tDWgX`!NiSWy%CTK1CN@w|P-?Ta?>G~a&Wxs^T_BUSs=-ayQp!Xu&CLSblUfOjDp z__X)$?ZV0-zj_&XS1&9r@~an+{pyv4clE-)%kwh|mO>zzSvYv{XWVD@)guEaj(+MT|#zB2r4G7&&3k5OhSGqAw?4MQwdosA^(z);SzF#gq$EDuSv)( z33*UL&Xka^C8RGPlxNAl_T5WfGEn-obia!X`_s$r6(Mg@g4A32T*D ztrC*_*unZ(!cd`e9njv0r;8k{izIA`j9Vfh$!8p_XC!RA#2POl$=e;Q+a>H|iFLAs zB>&-H{X@crO01z0lDy8rx=zB5msrP3Nb(g2>lFz*NMao%A<6q4totSGbcuDkge1Rm zu)dNoG>Y6_XurkN`3~0k61GUjEs~JrQx4Ws5;jI+jggS#j~uKYN!V(MwOT@w?>boT zO4vY&HBds5*Em?$NZ8R5>u3o{{@KC$vxH5TSkomWd9QBJu@VxJ-0om)m#|3^Ym$T{f97EQOv0KZR+EGz|LtJ?Tfzz?R)K_I z7n6j2U&1OSq*6kXZ#YktV^KI~vUEMaF$tg|H~xyQlUBVhy~ADb=0un1R* z5FIrZze0q?B5W2R^|^?Cu?WYCaE%BDiSQT^#zc6U2+_G?^z%hHN`y5c>?gu<5l#_d zn+VY<7(3rcg+YHicAKQ%H>_h4P|C zi=L^`p^zF43dtB0Qsqw}RkjpTGZ2xkAlfOWT#P}cnhGV6{* zaVG>5)>W4wjKsR{orOpQ>(+M`!bq&Uf1n`}$vzVfG(;w{&x`+7h)iUkHUF&;PRKr| z{;!5;G4%h-m#hO&={cX|sK9hoBJ4tCr>hq#A6>mrnPJ;i=NBp)y{ikAtKOXpm80IB z3zf6}-@H&c>;KIQjhFs^`9kBV|DU}~8a{;qGIauE<4+B}Y}{odE*opv=%zQG>5W-> zH;NcMlV0WdMqB}egTT0xH1(^LXYBgp9knl_-R0-7Gk#f6D(e?MF}j>kU? zR~Xk=T*bIzxMt&8fomnMW?ac6rco%|Cc;NV_!k~xuH({96(J=^0TNDvNhk>2QITPEW%B8h>j!kZp&Uj%7!>U2BR{F_Urhm$Aj`Bj=2@131Goc{Z3}Lt}-xuxN)oC62xW zqSu-a(lYDh%jn!M#WuL)MnF?L%+2$z$6mfUZOK7cIgCAOe-Ep`E1@I}bJr z)5yY{?3GCLDicUsBE$I1}$Puz1a@_m(uW zn8W)TmpA>`f|~sQ9RN0)=G`O?%-dARQnxh?>jA>rJns{M1!Iy8t^ii_24VFwSY0s2 zF39V{EC;Rx1~UAUZe{p&V1f+40U5qiX884hL4)s8RP=Ls_9E1Ze_`5RngWEg7Xh-r zFjJq?@t4dA=$oxD_LZ61X*!PK_<)1QPswB(Bh#!C|I)O-;zuEF>nMGfX@8w2eU~DA zL}6^VN3!D~`y%;k)85S`-_%j^9@Ew=Z@Tv=lKU3MbW2UM<3IZ%S+i{2V#h!J0FqTU zj_H_j>AM^cnXIRm3g5aVjl++*Z{6(C?hXkgZnVp|Q0ys9-kL_fjbmb0vXY^9Ng&HX zI+T+x^4TAP93J^uw>Z41s-WyMFFcQ%Mxd ziX&L@BKE;1pCPhr%fV>VgEH#3h_Z96R5lT-d{5G z3S+&kQ~+we7go8t+A@J;KizP$ltei%%(kp_6eDZ-S*82J&`o|hl)vWzSvZjw^=Ueey3-*73?C;gb^&W4{ zp{n8H$nxqs1FJ%!rl>n)h4PZ(1^wX)R4cwrUf_%8ST@t;6})B^lBNi=lVtoVF){3* zB{%RNNbl|+V1lakHdL+stfIcMUi~M)(ScT~A1bW3BHSIRCs$1Mm(z3m7hw%jvFMP4 zPjGaETh)F*ID=Ij3plStz-f!a_-%T9Eds``vHsA%iD*a{L?q`OB6@>}-e5!@64B5u zh)A$kxsQlsSQjL8B8Hb_2S|{EAM@Z79_-}7r#$!!L3E_I@Ad^?Wznz#jE}PH(Ut&- zp3^8R6&4jiTkl9LYNh(R4ckoKust1iaPkeR$yn}`ZbnZsKH9RQyx*`J@=^nNbEEKZ z-B$sYt1TP2xgPDjkPIWOX9g?KJV04=xJS)&ZfMV#$HvE4_E-zZ#7m@ijFlQL)0@Ok z%b}-ev#Jw^Flx~e9=@*XlEl?h76~jp(_m4VaFPBI9qLw|6sH-@kW4jBrT_`{K>#;@ zY8Y`H6&puc$X`eck?$;h^Qox&L1B+`RO(C@&U6AAc1?ENOp?X$Q-ipy308b8)m=g2 zIl*I{PMrfBp$z}b2!SpdQG5`*vRx@dNy^Arkp-O85ctj;5h0(&sHfS_c^&1B*Jbn* zaW-fQyGSGdH*}m0D+{Rzsb%n=OMt?;L^&ARy%vd0^4P%X z#HJJ;9FwP`Lq5M6F21Gk710k!lhd2hHOazZ>|-t4=A{Z7hqcs5(ubTF=jxYO@d1=0 z`Gj0TPXp+wlsWN0JUY(7yxu2`Hi)pMd9?2=2aAz;tg|OXPIu~zX_N!;X_h^m1P=yF z)uNs8n@k=tO?bqRy%LG;s8iG67c#gr4egYal?<{qCsO4VfJhV(BahUF;$gsWTKr^7 zvFxZBrItN~k~IdgRB^gR4Cnn@_6)BT?3hw>YT;O%Wx!aH=B-6KvkF;RW{wRqd#2_1 zOdA-^VhqO-!vasXRmjf`S+h~HDDnJvAMhgCjt6n7fSgB`=Yy^IOiJSf5_qsvei)9! zg0fw$uW$;Ks4Vb_1%8dJLNmAL)X%P=#$lHM@+X|GnP&n zEhhP*_U%Z;QPeY1aYaQyk4YVs922J?1anvN#+AlGKsX0H{lkvf^cwt;Zq4KB@~| z-0PyRn-5Y6NWMoSVT=(w$qUAlT$KuFD(rA1(3eVMR6q)ZornN7DYNWyZj(v^81`Y^ z@}UMWfe+mcA3DY=I$Ao=T7aX+Td8AUrOtcRjf7R9V(mkZxrvBQ=z@q2e)INZn?V8# zoI;c}pGZglny`QYSLkI)Uzmu^Q%Dr;`%LbH8HI9>4O`KyAD)9FEm8$}`f`cdBYtYfqZ+ zqfkoa4Xbd4C>_!?XQnZAze^qE*hj1|5&!j^vp|H3tIo2yW@mSqCSF!J15v*u83VhH z%EvkM?2lJlb`5vg3jna!SQ%3#Mv&T!!dN{s$`&9;t31g2YnRkYS!#_!;W^T9ZQ8uK zIDAO4*M*QLv#(0fxzz&CK1!-HUU?A_C~oB%*dgy|;H_yyPInT&RaA)f13&eZs(=rn z&v=q2?QWluN2eSio~ldjDCQA2!l)>phWQ6ogUko18WbkS)BwgCxi!T! zLA=4T*K)`C9+V+pVC79}cr7KXk@?DX8I*OLg=v6WT1Q7sSSPp{QBnXvN9^-eSBV~oO$c>;<)pJNxpr`i3uVX1XyOjvJ&G);@t&&QS)a_>C zCThoyuFH#;jCU$1$F-1X{%R4D>EGzoBB4-?>)8ko|IbZ$Ksy|ILr{i!; z4JTtzbQyrUlhPmV1nK@34P@Y5Aj3CUlc#7n#n7pjM$Txo>}IO!e%_giYCd#TCX~$W zBzbBPr1K^*NXcuu52&W&)hz0?w<1EMI}LgtVc#XNKO$^J+D!Uj+ca+nx`Wh-W^Gw| z)xjoH?AhwgmK2Ig4|Gs!70V3;o;KGp8_oZZ=9#umz?_klQ< z-lD(vXU>0%WnUmPA^q{Se<5T4BC+QRo=#%Jv5Tzz6URn@=%a|5q?f?X?t}x$&C8&# zhr!ES-K~~=p)d!Lg(9(wnYyo#x|ys&Sbg@!{8i5U63gb?Uh9fm{@%E~&bZm&25n*A z^C>&u0MJuzP$Ic~W$E|}2~|tSr7UG{5+N^KotKioGLiAiEc?@kNT9NuCr2C?sL`l8BtuX)D;l$Il*pVFsEw! zf?zi?m{Yaw0xWeM6%=wfRBhk41eu#@oW!l#c7w+LzEu|et|BwO&9ZN@1W43R+pN@g zSp{$v-6OG^S)T48HLkU|R9-(h$>sQ@O2&Fpt)FOvg-A88pKc%_g|Q!4scV@~mZ}20 zQ~jg^JAM=8xPd3sPq$b$Ft2BrH*(5b8Kw{M_75#&-)&avicIwsWA7EuVM(*n=BUBnYD&k6IDH@6>&Q&zZ0Ih9iI8D=rECc|UjeuL6Bpxaq5K)7SP@gj>40=q|k0v||WPpY%9ySI(Peo^CiV%R;a7 zeregr(9F);S&ixSA~%ZvHyCHKvUk6TME1 zVBJDr>iGbA#=|kv&PT9Vr3H+>!0?QEn?V{R?ni`t(7f}}@BU0=+zQ%e&^yu`WK0IQ zO!$;V`tbQc&L9-DIl&;8fKOQ{L-cIQVlX4HL0|=;3zR(_+ znMROUMNC{UDBC|6??+xR4gBr?K{!I+pxrOXcErZgWGYL&pqV2Tb1Q!0mc^V7W@6x9FjQ;FgO~XyRnFP5tzWyw!_f|2a5&;iv|XZ21t)v%!MDu zgC#sz#)IVuu%m`$244l18sPe2hIV8)WeVn53W8WAA50CDdBhIQ5^agX!L75xgsIe4 z3X(^RGmGLPsH0dew9{D>7iC{(Q37R3s=sMzo-wmPd6pu|)i0H19&)8T71LuQIg6sC z)QL~A9Aflh7R4Wr25sb*%FfM~v>e>$98$TZ3FqyJ-;VMUlwdwKcHez$tnjgM@Uij1 z)FA0&dRP86zQ@1NSLxKh(#+Eh|6;l0^{u}~90<>oE=vriPJwa91jf&1OB7BS4GB zy^OJ#!&r25ung`wN4V!axaa(!nrdfMm-;$PBJ8w}eH}ioptKgQ3Fm){T^pZ2uFn6_ zW*M`UiYTR7PBTw8T$|;r>e_+$VL==DoLR7&aBnYnKXaZBHz>?JKF9l7ssc`Qis{Qs zM8G~QSdO!!lI3t`bdC=R+Ov5PIg-2i(Fm|GOZk{_dKJ2leZMFgWc+^N@$UD_F`V&n z9T+RkNjl?S4tXP!Gx%Z+*4Yn zOq|`^Q8_t^alx`>I)N9v2KZL=U!uHyjs@o=PiN&}MG&8y6KJC%Z9hyU;Bp^YC|4h1 zA0=}?w~VdjWuUBEWuT3hfhLrJmD2UwNxip)dhFn^m1&~aanY-~CHgEbx&@-ErRcK> z7OhiDU3HhGu1=J?H7IrUj7$_ah0HB(^=ZXTL2`1;%}^`_bP?17;6ghsZZ3-JReLRN zF3~qFtwV8hMY;N=(#*q)n}X@Fkt}YR;!`YJyv404Xd{ypi@Jgd(NJSNf58M#6k%y|EIf6U&6(v`dhCtDMpIwzHBwcj_chyaBRc}qpIlGno zdB8wNr?y))?PXLV%AyUZY0nN8ofRxPGgx$nta87DNc0UaCsj7_ev6zExC*e;8E*Z% zi66$v$F<3}+Njuh?0f0EUQ9aq?nzoVePx)?CODhP>CM3Y7#cbK-agPoU&5|^$Vq-l z+p@SS+&EIl>%qm|9Q2N6D>{o)MdfI=%7XT?+yHU}+YofhLL4628H<}Zi=PmSO+m~S z>_y|B65__7YFKAbx)`lL*~rI+p-py2MJtA(?G!(`YS+MpcG?kfQQY>n>yC(7rWo&=mgeb*U>Uw5 z%GEF3JlxPqN<21_9g$4&Ja-tq7){TLe=lewuQCcIL__4BQr&0b>~<4XPL5(+Ft6^j z?C)Vt3MFDYd<(&|Ty`~TRL^vH1l-BVOj2Y9ri~-8+oO=nNyJvqRhQ+ zIxG_`9rj1uVPD`5`)6|4?ZRQTKB$^EkvouZ-Cz~8QbIhl)0t5`^Wz;*TvvaQi+_p4 ztK~&Cg*s{^OOP6`4p*hcyMkVW1TFK$|DirF$C~yzInoXNB<{ zB6(B&bWSJvJ22S9^!s?QZzpm8B#>dB)2%+;!`gZ1Bax3=dX)M3XS<0<)nOJ7nE_Wy6 z%MMAP&2X^97sQu|Bd@^D%U>|7ew8MUN~+!`1W;*toGCRK;Iilw!PGrS#cPq&{i3dR zGq%G3h>~8X2jdQaJRv#^Pol%{R2OWOZ)HBNqOf&ZtkhF!JqZQLBirfvx(I4#)P;81 z^>tC)u4UI-gk@vM_X7(e9_~KPz1SIk^7w`yocLSr{!G0x(-jSyVeF(YbgF(03;`U)>PbR%z>gmHuq%QifvT>LVQE>6O2+E@G z22=O)?vS@Ak;V42O?X$7fWM;zyx#>|rE=(^fV}@LE+F56?ogU}x=}z_wy6aq5dSb} zBNHJfL>~`VOpMHy7+LPV?ojO0wJl$|%tk2 z1ntL&a0T&s7|ym^cDX5$tfj!i0e{Et7H+JC%A$Hmd>&`!tQ7Jt99<7Vt$j8qmXo-B zfN$FMI-D$p)m#5LX`WA6TC?toQa)wV%)=a2#q{(pyZn@8ImhUoJrQQeMn0{y>rDj0J1wK?OQ4y9Wbsl?o5d4^Z;Ez*a$t_4@77#sA< zCQvg#cArqZcgW7;mOF(+XOcyfG+?(EQ8W5xR+Y%fEZrc_**keGKVTX(F zDXsaab9naf;k$Uhklo*tJxlC z4)f3)5XXm7%vPet%HnP%`U)^XqTfcM!!pHJlE|=In4F5l`L-^Ijbw?xicu@LYGdJY z=ycrEMR6-*Pr>ZaSY(y`2c>x$i!3$~es!8HoT{5;lbmI`CJoE67{@}c(h$aXfrZ(f zF(G?oNJ&M~!It*5M#jc6`+kq?tDt^U=5=PWSQ@WQ)83OtYk)XQ_qsGJM{7!>MV?D( zyq={I4>#b!9via9gy5rv-SW{}zzRP4CVX_9^wC>Mn{i$Es5L59#BBIOMy=qgMszuJ z>Z2~oe)yAnf{AzlrXj-UfYN%+6bg=so z>75^+!o1C$Qh$&%olYH-Se#k)A;vGo@mQ%)4rO(roqF0ds^#6T9&yN2|GAvhY;&Re z!#{&JJ^W3iBKJR?j5Glm((yRb!Fsw+;lYlF?1iD|G&Hkfl03GE<=L+(wFjJK(W%sK z=cCh#^?}73`!tu*@&Hz;{)UNsIh*UUJZMOe%X~>4wj@$F$h{Zj-~mHaUEk zfPW?6Ukdma9Ik)nNZOf6l5Tu%YKeTKrt1MqYip^kRg$>|$<*~MD?{3KBV=jo6peHv+tN-_ z08r2$@MX>63S}M4L;oypG5<^`WWZu^VZj-~f-#F*aJqm`<8Wh&6@W5W<7$~KEVZ)8 z;zo(!J4u8^BAg(?aXj?dg5OvncZ`q|74XqQ{wNOD2f$D|96{InSz1kPYqesRx0qe} zX12?4OIxFuK{rNNo~+Z2A(mEqT3bsMapd`#e1kX|BQ33IU2RKUL({1q4nr+%RaGl; z#>s!(D73UXZIb~8xU`6F470SgRi{-p)Hbee^C}Pqd3_uFS0RsB+G!nt16>agdNB_$ z265KaO*LK}3IO+T9SoC59}*m1qoP9I>KFH{oIt?mKT2dvxiEj3$d)5Swj3_tD@3*= zM7A8}`0rw*s-d#FslBmH$(jg?v92%jD(txULN|e;BvS%&4Bc3so=HnBjipyL@v;tv zG>j!6L~cS67-v%e`4OfXVmA01BGrD~f25@$V-#Bjd`7eI=qBOOjohPsYemu|LA zwXMf_R(kV-$6*a%6&R#DRAstDRdni5{+ulQW7QzlGycnk6}}_F%S3po2rm)g#Uk9w z!>o(M`-LLhBEkzqc)kcXBcuxUJYn5UurAeK=W^>B=WslIy<_E5y$N@maGh%?#R+x2 zJ+t-CB1dFSt`y%5>DE63SnVxdAJdI9xpSt2Pq(z@mfCgc;3O2TZyG4XQ zKu8{Pv+$6cgokVs9`b#Tr(ffE$W_v=yk2!Yj`8*d!5oBqd|LJU!KXVWRUU>io%3PcTiNA5T9hL9K}{< z;)$ee5J_njVUq~gh@{mz9I7*MAg$^$X;t5uRzz`1CW^MsDA4)4oonO&kqEc((6~Xo ze@}#$3;3lXyhMZ-i*PGK`o6o6zx%d`aI=U%kB9m>PO8t&kfCRFnxSWA&d@V5nNBy( zB|cSc_0{AUtH?8WaVgY|O`TN_y0I~+H8r=TlZd_@Di7U%SqJmN$*<^OUbGkZN4-MO z+?a{xrp{@QDZdm(`-L#tT`(H|2D}r@@C7J6yAq9dJuC#6Q$E z9tL)C8G)TV^zYzd)`ueeyNG{Bgs=0^|B8rzNrcbw(6?Q@|4xKY3i#tZG#(4`@8?H@ z{QLQlApd@Tn8)iW$3gBz%H&6!=%CU^oUY#kBV>%YJ5#!K{h@--|avF&ED@oAvI%CKJGvRDW7(rky23i?CwAT@7F_}G(&L3fx;CB zgm??wKg65*ei+h0i){2oJk=@r00*p0L3mgn(>>A{R(ndgf zh0s!0Ri9kBwyG7as?7L8URI2P5cky)A?~ZgL(Et8p%BE& zskNf5X;p1=Q%hTIO+`a<aoyfb9_ag5{{t@|C(8Hx-^&xViBB!V3zw6kb?3Ah`)O zX7Ab6O>3Jc*4Ny9<6pErdo=vg-t4;Cs>F% zN6+8H>iULJb*mW+Kl%rp0fg%LV>qiD7!146fOBiegMb%?Q{TwI=$8TK^dT8>(0`}D zEL=YQ;VtY%xiLPi>lp+k6*#;5Dbeha;UF{V52YA5hj-AKbO=qFIxVdJl}wpdGIesv zwAfS?8V;8f7f+i8)RL0osU<9GB@(!2kFG7%M^71kbZqx8dfocc?aS`C?uB~_qh*g} zkJq%my-bbb-nBIi8N&WlgA;(vJt1ASP#!myFgoE41J0Rgc(b*<*{b0QkB)_)Up-g< z96Vusidzeu8Du@>&%qNJKvBOOs%by86eK)4cp?)hb~~(j+^A0QL`G2TL%3|%L;WLu zFliC_Ykfm)OT2JiykbR5)9RM0wc&+;w1&r?7Mo^QEUT|>X=-h%YYQJ$-`ZZ)5H4dS zIb2dYvAE)>c@?Yb8!M_yC)PAH6o#?qS1W2;-&|W$-=G!MX<&IIt2|cl%45E$JeIM_ zBT-gS-ZZy%1+P4)W+*C|SUNFQQQufcosQOt)mqV_)+xm^rfEerO|4qdarIi!(b{C( zj?sz|t8uL=)rywQ2ikhAsH&xU&7pH91G2DbeSu)#zhBb7DX{#yzux)rNvB4n*clpJ!1hs*5QGiJ}A2?xLb;ABKgz5r&1W@%pq<{w&CUZy4g2LODu`@tn! z+ZCV@5GsriL^0XgCk%ww?=#AYkW@pnOkIkaO``tH2(q=$J2L&y%XA#6zgMP;{?OI6 zR&`VJ`j-0DYudDpNTxn131we|Y#qt`GO%>Pay69%{30+fF@J#yC7Tpe%JybMC1I@D zgc`m{VPWwwtBJz%q(0%288fC9l@^yw4lk=}IXOJ126bi_&D=N>vv`INmmgOat^h6* zmxU{cD}*Z>R}QY;xccDgi)$dRp|}cgjl?w`*JNA=;hKl53|BR-R$R$*NlNku?EW~r zzs2r`4mdqQl?hChJiK&uk$CmW$GduwYUTyt<$;YyyvQuHXhla-S?**K|_g_C+Ob|*EG z`XF`>vwJbS&t~_PxD#JksW_vRq(!79qy=QkWr_!Y30;(Vbdf;1C_!`$5f^1FUBkpR z93fq#&TO;y@yVqfx@xEpdj5JW&|`rf3-nl^#{xYT=&?YL1$r#7R|_PJ3an<;5|eZ4 z@`qXd`xXYW=j++ozTSC*bY086C4czb1-Sz(t#`tx%t{zlxDe`voNhpZErtywjDO>Y zh&BFZCJK`Nylq+{oZP)njA=dX7%b-wVmWsovnbCj>TMR~nngKgQ7@D4O&gog?Swuq zp^s1K6B2q+LZ6t>CnfaagkF-+OB4F!ggzyqPfh6468iLn9!uym5_&wLAC%B%CiGbe z{osUtNJ5{T(B~xdxe0w zkUX=?E-_R6OhnQW@7|HvWHX^RM8~*5eg+f8@^$g?Qq!Jn(rV_lWzqgB^C_l1)np)t z`4ltNpO~j|>0TI{2JVf-J;&Tk$EdMLTDI&Q^dx_wOo+vX4}B`_`iM_8?P*NxDbYb@ zDi8EKEjk)Y99+;+79Gfx>CIC*-LzvS1Bpe}OYG@pYM@N1J~B1~y0nrm64+4*Iv6Bw z#tE~{#zV}sXF!M4AeJUZH!60JNeZzSp-a1ckjs^hn3`!~d)B&WA-C3;jq|oyld(E` zHd~^d&`%XHx)Y;|nA1cI9ky_jMd!20%?ayMyhdydIKPEOCpZ;7~8DU8hp z`PpP$2F;koWZijYoG_C~lxrI=b4+`#YhgxP7@N;5%wB|^7ytl1;6tTae9O-!fTha| zT^E@4!Zep(;CeT?{36PoK?E1qbw1a3fhjlCt&c-mg*XVp;riPlJV-_roEoO@C zaZH({^K|XSCXQ=bXxfXICnsrML7^HIJJd||0+av2?+~KAF;)dL4pW>-4+F zPb)}Wn9pEJ#h04)GH#K}nR1?LWw~i5(yEo^Y1PUK((Ve7?!8_ir#swC^Bg+ z^1uJ3=qSs~zVZ}{6kzdkBEFB<979j{3pV5Mv!9?R(g!$*Tp)>o9xYEsJV+6v&FBOd zmnK92>WKR=MR55^nwyh4JOVh^;ZZ!<$C3_@5iXK4(dGL%fgq~b1wBC^&T)_A_A9`! zXRO?emYFl*(8sa_YqO5#UOej*yQ!PB={Wxhj^v^o?v0X=C)&QVh@tQH{ot4_%H_7IhUY} zdX}Oh`1LBM>A`PeajNGL1?hi8pn3_FR=ps0f?aWeezD(VX4 z_9%et3d)v0fjML7)p+nf!QmhDK9#mHQlKw zRf2`FYR3Cjm$&9LZklM^lCQb3yn*YSw=7(*gM^)$@dh5^wWeJyOHS7cjf$;i3jM_u z$rVbCMosW)xO2(g@?LyP;VWT}P2O}libRase~vPFe+4s^ytnWWuQzS3_1mrt*NiKr z8Q*bZMLz*KAo~f)zcH3Jc-4|W{GE_T2v21lKatUn!@f@#1p;F*Ie`=P4~iOKrV0ou zz4)I1+9xyX{)>~QMo_#wIp+faQzKy$bWw&=1Q!_MT-cea>>S#({!8-TpexU^8-zG= zVl6!5WYbDWP{Jn3Lw?sIhg7zlQgDMT`jvSZCe`iUe(F{8ckOX5wY&0=;UhAYpd z#ZF<#`jiNUn{JHm8%T8E^_d!lAHHS4&jDn)_yr!~Ev9`6iT#qJGS19)b_;>OCNNcC zvMUAHZi02}gHvZX4>#$O)U|A78e(aMCWAEhzP|t0? zWftSZi6_WU+*(BsfLC;*V(rq%5z5`{RG5M=z|^e@fP!Z@OL#$S9cg6(in`TX;f9F$ zI+H4Cr_<>7_m-7(4$+{JR-INVm`ib@FPM@(%lmM>iR*fkL%Ajf@2wZcHZT?QI58QV zkqRV_C78)&XRi+klx|xjcDfngK*`D{S*M%O(vzKixd1W%4qV`B^#iOt5MOWFjB+5M z$OeQbKzh?4M1l8U1nE^jS_vFu?6fSRl{nM10qxjIoS~xfR^klPK9dw50_IFTx0M(U zkbQ=U)=m^5p1acGBS;YM0q*o;E@`{5A{DB~ zdJ;3vMHMx-@`abA1!ta$)3I)PRY|LN*#6>4c(6ChPLAUl$P=d+6%$wf`RpxzC5T|j zbbX+d_!>4o1;tq=e5deafS37rn{}25&lKSq2(fxHaJqQkfGxjx&sxv7{AR7= zaDO|;%W4zvts-m@;VB|)=39pSO`P7p*2JPA-REyGv3LaG$tGJI>8}^~t3_BV!fGD+ zR*J31m7I@p0*4zFB0L@;^zOu&~4_!15`4ioYYkPnwF+!58hxT zrM(3UT^)9&QDm}pDWvOc=t`?kusp^zY?Cc5QPY6MGrBRz)LNRF*vfpdQd~DiV*5O$ z*WGb_4NKNgGIkx?-NJFPF|{Ad07V7eh{7z5HME?@!5Ts9RH{`?4P&gSHPzL%l1Az_ zVBIJ%wYvHS>~eFGr5pXR(SJR*Pdgyfm}JsA6*Zw)1f&~bC`3EL9ZW21HZ?57g+>Z& zAlX=5Mo+7$oqv4$HNEo%zwVyR0G335yO#dyS4O@c>4#OmZSAzecc=9TTeW*-{}_&Eoh^-Lc>jnfG->+uu==;Rb+*%rXOv7~1YNJQeGZ>Ja-Hp+ z_!>fnu)hOcXG@*2eOYIFNv@_{lV(7)nSLGkx z4X$Np@RuGC2*gXP=!OcR#uDJBTrxWO#GZX4!QNzE&upo#qRCx%M2|iC{os!G`LM@ zFiJv)6Z9tnnvl>@1ie#08zj_|hN~oW2;tr*QoP>@h-1`OY3lchvpbrS>%Mv<( zpbrXYc1WbcgF9D3J-8=I=m_HQsNishg!U)s(*k;#gev)-n+nKP<44rC*0wFFtwm2+ zEF2#R!k5EX4gCPE8%S!~2kJF>e)NxwSU|tZG;+`I z(7L40f%J7EeXT!klOby8nmnI=HN+j_kgRB_U+b=(KLaFh5Xrgtsi@>7AUO#nTJEvb z*G3^@pIoilMw4~Vl0O3a9|--IgK#SVaMWTf6Ta6pQqXH9`qRxdX#P&c=>_ccB_DN~ zlIuYA7oxgl2yRJGB@6V$c|NkmiveHm>sd0F94nCd-XxOi=yojFB(LZX^9`#F_!|Pf zUJMvP(|44qA8YC>P5lGYH^jmbQN~!ym}wb@SjN+qkrOmV1&u_|Xb2it1&ybJ#&bdA zg`n|r(8vxMb3?|7A>)jYaaqX7ebZ530sBD7Vrr9v{FTH{$GmRxJs4;uWjpdAcdTR1 zMYV17>#N)9n;NTH);sF|5u|Ss>G7DR z9Fx(4?_}4b$#dQ(+FjSr7!Pq`7d0(484lV+K>fLPjS zbJ?8od5htVpu?A}-x!2lAa`c1-cTuam!jYz%Fym*n@$>0ir8Kdr8Fsm(No~6#${b9u!N|Ys_iXg=?BQtrWQDyy1Pfo&1h2Bl8=F&HVa*l zRn^eYR9#uujxwYrdoiP5oK=TicoLS!L=Avh=9M3+8ZZbA#+%C)EK{@{0iKs;ZK$N9 z;i}eFwu0vf#`Dyybxrj(&2<1!xwf>yX8Exz7R*m5#JvEHQ2G^EKfr8req#9o1vm`A zKJX_msvppO-YaBjIp*R8bJX;ZR^!aM9@uce#*#{l%GKgD6vj)@ULza}v6r%w)R1J9 zooz4!X&5z^9;#;gU|8%%$6~@>mNtl)M@e%wXh)DH_^*0lAJBi_p>GC*e$3#fWX)aQ zRttNFEo~T_ZN;$)v)*7f#+gg6ohl7Nk84h2b-(!%1IQEVfqj8UJH zN%d{EO7jtVC1Z7OONLQjAOqww5_G<;pYV2KIk3=}Fpl=cEK%_8bZf zBRkJi#52?D*F+&xf(>vER*mvJN~QR*s;{b5a+4Y}U!{4EVq{9x)K@4{up5m@XL@~? zC@5{@D`g7S8Orla@ysY*Bns(|*!||Dq(OO}pi=y=sxLO`ITXpQYRpoV=5vaXDZ!>c zhvo?7nY3{7| z&D#_sQvxeHG{-5=*fGf9Os^}6LgvXl1#5%y99Jp+NEBoZ%0;pPy(9mPla%Li;+e_# zC1FS`wT{37OC{zomF5$Qktx9@SBL&6XhfGN^u8K&_(jpS}3_$jajJD{F7p2Iw04fKT&xep;BB=6f#Gu6|A$A=Yv&> zSBXOA2=;(FG8&cVi7Leds=m1j7Cxqwx8*9$E{a)+i}GE?I$WV3dpf1$T*8uisjbN= z3Pp){W_j`$QAlg4o`UVVPO2g*#m%ZF*u3jtvCX~C+Z>hVuc{O^ACFb&vA32{GrcY+ z3h7;HYqDOUn4wZUM-*fYvKEE(PJUCbJlo=#$@n>8NGw2{XRKjX-VRl1c2JD8ms)Qh zsZdaU5DrOC()Mj9C2DKZu24)B&rGkUNrp^`+M3iV6r)v&pQ!q(Wfv>J6`BPq&HHLf zpsADk6O?D{XJ&Aw*R@0;%SoAnb*Az>OQm?3D5O8Ct;t%2qDZBO! zCB?`*QCkyLNAe}g7nUcF6NU6HwKZu4oZ<*;vUp}`f0CdwPt?{#tuG`eM)55m=1oQ;Lx(Q9bf#g%^3mY+R%-;maJ6mM8eB3jTEQ%q0AtC}fVP zt;uSIVvI_0CsEKvd{yfv&sSp>sWcx@j7$gQI`oywv#e>EUN;hj%#msZ>ulxu5b?|? zUMC8fBQkeM$0mhhl1lNAs;`=MY-dnt5-QDZidl&ZDQDKEcapL~V9_(Blys-(R)kV3 znL>g$EBM9YnWf`V;z%4wg4&jlR4Fa2QrtvP8KXXT@n!NR;YlfKThi&5$#;lC`j#vU zl#))rO#VO=(zht2_y3Q*_W+Zk%EE@bdV0F5dq^TEDmXpkIC_;qf?_kuilDCUqOF3i z0Y$L)ERG?g54G`}Thx;OV)y z?mg$+lWwf4Q^Xi!<+s&&Df>-?Fi?Q>^DXR5z9zhp#GXqATllnwKW@EC3?qr@qvWf} z!q`#gC0~yc!$@L}rz0(lDjQ=NG58~0o2wRfCLa^tNMcK0bZ2rAF(?~-We`%+V$q$+ z%Y-og$dSWf6y2HR2w|Ysa%b`*;f*BrsC}SCi(L3NSwakBldUYM$yUCn&P$s-NDN~W zdps?=Gr5u&{Lv-bv?Q~ws zej6bSls!hYurv9d@J14QE?I9olPB4Nv4}mMjNfcnb|&xIt=M)fx-+?e7^c75vq{mN z$#cY@HmEJ8hOe*$#=Gp!_#<6g zyDjWYz9hVn1MT|wL#@0SX(eBm6T?`<_KuS+jNNozV!TNVV-aIr^4MTu>|kTuO$`1B zWy{{e&g6I8ILWz0qBt;#JTjpPn9nj!oHPKhs8%wfY6#B~Ug76#=GSllWT#@y?nt}% zHT{q??a=u<`88ZvQ9Z=r#M0TXNg+oyu!gGM+^>O{2-~Y_)HFl-gtO%#WnUgfyz}KD z$ALWL#mGZ92;||^WaJr!d?3$JxH9rk>OdY!XXNRDd>~JETp4*dlm+r|ne5ARFJP{Ho7r|C$m7|F%mZ{O&*b&Ft%~R zu%;1XP}MpSDcRVxI~;e_$EW059B!lvHC;@N`kY2e0pRrye8Q~}*!Y}ANmWxrLu$gX ziN~f?d8%P@ino}DO&n2|!W#s`8|n#K575mFIR^XG;D*OJsNdYwaY@^B;l0n!ZLR33@SE%S+|sL4^oCZ~oY^gJk>0HBV6PvP;eVZKMr zMxEtvTJ_rBHbiXX?d%QzHfUgj1~zD5g9bKeV1ouWXkdc|{*(sROT@-Op@@xxGtngC zTIl$V2W6rM1XlYVf4&OK);SY0T5Y*hp_#8dR3DuSh_IRO5MgomrgQ_Coor!tm-Gw5 zvQejuErMJll&i_Aj>!f!*D^@T6sxvXv)ZXvEmiP6Bt}@SNS1NR zWFVet7DNgV5Bt)tWQ??9tm-tXEtR46SgUqdO`c(u6zSuv+JUIOw8ARbKfjU#)v;W~AcOwrGB=kxIo_g_y$A0=0PZ_!O++-5dO5*{c)*4*G1X2)*hZ;I-`P$^ z91l31j^pts;+e{ji|7Tt&p8^nk!bD!O6-(X~0mS>!u_pkL?FI2#b?_^U}b zTZJc{HE#z|)`3#Hl6kzd!$>K}uY-oq2N7sE4GkaT)=V=>W=urH=wW|9Jz9p$ z#EUzT>SJ65?U~X`Q7Qw};6UOU{86w{dE)mlSaPVp=PbohUgms31hH4sBb_F6WQ&#z<^qsu}L@!9JDB2BTJ;)VEELw@df8roRk z#xO-Cq9vXl53@G`4r7DWQIxD!N0FX)GnJM1$@&yY%rc!Kol0NeiVNvVccU%p{3kg)oXetnP$VvJb2Gt#>9^^*)(9w}?j_V* z8>+w@oxKlG79mb-=g^U6K{EV7Ot|^7cRm0(vZ01p*}$VHlD2=0EzP%EviuQbW|Pdt ze)6Ki<{NbZRN{Ta$!SiLvJQRn9S}jEJOO=jiCeSStyyF`MnHCMYeR~arpMGabE z2+Q16k^!m2@;=wQ)^+pg^*UEvZ*}Br$m$m$BCd0*uPuU_=iQ8SnY-Hem&){V=`UZg z_*&oTn=etbUxy)f-KN?4ZsrO4BZ}bG5PBUPhLI}a)`udJ|IOM}u&cZcR!(M|vW(LzV zjMFaTY?N`@XPk{QPKS)sG2?8KaW>63oifg58E5m1vqi?~oN>BjoGmj>dB#a)oCDLsWeS!#>L`jS6KL z01WmW)eqOo5QY{BwS}tA1te<10EhS_O3f0a8z5lsTi40nCxZy=eH83{r(3hityyUX z2)rQ70b;sJPC-(Ax0_oDsnv{b4Gnqy8}FJ&a(Dac$zMg5r|*;f{R~C4&8B=Y^Y5P%TJdtUf!8S6~l!ei)*_KJcG_kVE1eWW+;m z?oJt}I51hj^H%AHCA)J0S^ZL6&D=vdsTG2js$K=lPfr!Bmt$qD1XEoI!154OE%fBt zeqLCN0)oyDLnuKDwriAk5iq3S7b8>qh%1zEm*A@Up29}6=qVQHQ+`PE1;EVRBef@W zSe1U%B_(-bTD=rN0_7p~NhDie5@pQ_D#(vQiw4TOj1t}HD%RS8V@@lVlUdnJ`Y~zL zg@g)mC2Ri#S3%2**ht_TN@rnxEDnRLh253_V{i;2T!BpOwiIn&G%C)YonMUd&ueucmSo@SB zuR4-no&M4$9z(S?Jf~1AzM|@kQkm@fz-nwOQQzj2$vu-R7FUCA@!>~U=M8&`ab&(geUw`>Wnwr|yM+tuxS$>cy( z{f1p>X+`6{WmgAUQMm8eOsa(}JYF8P|GoNMyK>iXt8nD+j`rYM6Iml%JC4MFR^f0^! zPSuIO@~ZT25`IP)ii%RF_<==E0Z8pnBzY=wGMx5l$cW!u@jJdV5%Y5IQVh=K?JCoy zo``#cl(@R3gjbvNM8d0n3&QoE;`GL!zgNHG!bX5-@9e}`usc3Qfg`obh@z%;2T(R? zcyfFj92c%Snd=kxgy+@9JW=Z5BLWd!`nxL}4{V+hmMJWGv@G4q%e@1RD@i(Ajzi#b z6!8@A%rIgnD#NR;$L1D%W%tE8KuW|JLuW9vBiEisAC&`PUAdu|N$s@u233Eij7bQ2 z{G^%AL}gP-7ddu-2YvONE_9hTDVT zcND`?5UqPG6=5wPZLE>nd!hr8&JHUp@EqRAP>*BBx|8-0dB#hh z&Hj$PS~>`n z*Tq-fe1ItBU4)!e-o?m>P4jtctN2Q#J4+5OA?aouY?;r&0)horD8#{~08t!VhMeT! za%4njPn7%462nI}Dmf}rO|f>;SxQApJ4?AIDrl>Pz^nem)g1sp=t=#jXwGp%KrPu8 z0m|Yj*wsk0m#3>pYH=Z;+$Z)(x&$D#TYI9)Q{@F|R;8<@zOEp>X8PJTUtd>-n=PcT ztJtg@D6d9N>T4-7qS_N%+aBKmPND8+I*LDkpS%p<5b+u$7E5$x+!GFrMX$oZRQE>) zCNnr)OWFY`B}d@WSwwkKjxLXP$_Dh8ABIx>`8w1I;hUaAgEqZ9Q{^~ODz?+67oOOj z_PQQON-N8W-j!uHGFRgb5HeM=@IN~l zmx?{K0}k-So>a`;lnOlWy@r0akH*{E6MrM#Jz<3gp2PdCs{h_g(tjuLeasC+2Ry*) zfT_y#fu0zY*8vZf9q{1w&;bW)jt6<-Ag}fSPaMb&xUVi9=!yNv+WlcU@*N|UK7>#Y zvT8W9?JOh@;o&(M_J1vi>}J%|7^t zHY25CsuH`iJ@jqJ_$#5|jNgp;0p0uwjQ^r-tf0WV@BZ-g5u=YeH z@zB>;{Vh`afO{@=(o>bb#3N4VlLDzi7AH#6A0(u=XhT+`GHD4B-zk?1G(8$Vnr=Vd2DiuR%fkM zYXhXVf+dP9w_Tjdb8omj9Lqn~$!p0{h@zs_5g3Tg?WK<(gZ#?w$H<6~a`Qa_0A=aR z=rW%mYjIv+$)T8Sfl-AMK7az{Pszn)94Hk9d2E34&rr^jTj^O!2z=U3J*xA0m>Xrb zF!~n&85{?lFG+ua?LvW-)0cCY2GCaox*W>@|1J!iuVq9RFH0|yZu>nUWyg`Nm8TbL2LD51*yn%XpUSDPlCpS-MEx(a^myeZ z5)kLBJHc_3^7zP`I#&$_>>q&x{(e%)&qyqp@*E2t@oHNsdDWev0sCG=9(17d;w_M( z>LitD3Vi+2B12Y-7ERTVJX;RQt~!JHlJ2jdEUxB6dWAk0N-x!elTv?WpCz7H>WM4K z$8TXi^6iJ(vh*?n{vHNgkG&*Hx_{^{8fQz_dE#1|x-pK`k@(FDi*m&8NO&MbPh1{JT~9U= zVc>j2;84CSeS_=`NkZBkX}Q)w8Hp`#){$DV_(qA^8reVEk=g(U{IyjHzRzIGM86K7 zdfaL&C9j$%o#BoYf>tWbo44{vY-@F-TdB8=T4cy-(XxbUXiXidJt&J?*^zEC9qG2b zj&!3ZZu7*=d26AyZ|_j=+!`p;@zdZ#Du zq7eLUjoM>a`U=(%R8sbLY^Tdo=|`k2DI&b=ny0h~irX!Z<)39%gq0I$GC0eu1c*Az z+zL6lil{Pwz@#jAb66EE_>=viI*j3=HWYuzbP;D1H56`TcilBQC(2ZB;{x}A;Cv!g+=Dxjsj zgk9|4i|mx(tuysp0+{JRJ-yzdvzCfCv;?nv;!R4x4+mPF71$){+oTuizD3|2!@%mG z%G_kYZS=RLGw($BcVL-7G3w!s+?y^}^J*Jw)zY1Da`Co*56`M2Lo-u)h1(312fe@y zww;zJY1D-dfvvh-6`p)>LGEcW7`>}C^NuIpqp-ap29+O`Pb0}kVs=K6?Ad9G`1aa# zls|Qot`Ept+y+JoI!Y}$c%OXkLf}`-1LmdWeLnPp%XoSE15bRYXRuv~gzJxp*Eie< zRjFSI{aBjuF9iNXx|4arWA`Sv%-rv_%jEtID*RNd@Dopb#wK2ptfNtp(OWm0NWoz{O`fG^3av3L*4@{`{u9iu(D#!_l46+i1He)7aGY+_F~A#Yyz z6ido>`CVFNFA^+C0P3&EA=!t(!PF4wxV5k2zX7B+LY%)7JI35V2P22%5F`cpYv=QKC_ohUVZ<&Y_TfYe2B=Q( zeyki?C-NTD7*dRSuyQy8AcIRmzxsD?S8Tl_N}|3c>II3uF_}jDCS_XEw=6MGNMjsH zX4Dqpvi8W5FJTkI7w`h z7$mkx81Vj6FvoUIh%Sln<6Nl(7lo@t98%d02wynyyZ5_c1^_;-AqX43`JsLSVI*ma_R36hwj-g2VuafIgeDPwdjcPg+?q~-CzGH&t4nv4if{A_)RbJ6u1PdI7H(o2H3@~N zCjF{(HwpK)zXAXUQwY~h!*L?U0%Hd)*HqT+kO&{kN=}*`MyfSOa1=TXsLc)@k6~ev zgU4f8hi6SCdD(x!+;J?#^QnbSDvw8HQJbjkoe(>-3-{Ee zJrbf9Svw^x(NWDiO#dn6@-a39xx`ocOt(3eBK^hhFQsNgM#vdb9Bm1z?_&>uCK?@uCgV6;fw?D~U$lQUpgo+|1 zw0fGd01GSAgQU1~h&UL1;!vwkU>$i_LL8pgCytbT;>dOG6RsGd&3AZ09FeF!G$9U4 zU~PPmE*+c@2UDiGVFgTriXKZw0P> zBg|AX=ty=R)iB)mx)Qq|m9%3Y0D~hmgToVIBpI9!B&=%=Oo&0eyofYL7q$T{yK!ZD z4B;+buX1Uhff%);6GAp{Nw|S}C=TIQf_XeI{0ik?5JnjY6vT81P!tW^QJjaD74TLg z6sO;9yflnC*mqRT$s6uXXZ&br>ROp}pVhmy+BBl3T`H zLt&4z*gQ(wByT7PM!;xgdXiMaH6S-gOqTg;k+1&9?rX{?-~w|i^7@ivwWaLOwq$2< zN;qk?kEu?%*PM!;r|xy3>~Ytr251~-n;AIt@bAN^<#k1RYNEE0QeICfrzXU-yz%Hb zIUXIi&f}3Mj?o=^T0$Jl7H>d{gWcN63DJmw2?fgoW}|SdMP7Fd9`czZ@{dQePLN8w zk({0=M-k{QUo=?R3@Zg{u`N>Lj4Mvk?3|boCzG9uhH&egY*2^ve3DOC+2HK%}a=j$nM=_moG`( zgG}uu2{9v4+}SoNPcM*)yO&K}3TIoqMrSKA&bA~WuE=w?tEIDDy&jzHN-fqE32{}T zc5y;1p|f44OD|1`%PH)AWP8~Whtw`pvAxJg_dHDVE8h&ybYqZ8Qn3M`co!`|EHx&UuSF0RQhbbO5Z5Nlw`$U z{JjYf#nW5J$>rty$cU$H=GJD#|3SE|Kd|EeFpL?j`2DxEJ^}<({xOpOGb?_};{&g5 zc?aNxcL1MI2(<(Fw=~hGENEt;7xGQ?8NpiK0elV+Wuh;TlP3BS8S!u1MEkG(4(qFM zlZW^_EId`Gc358n0{Z?2$)D0UNw&DdvLp`n4bAk;{ka7hSOzYP-od9W7s(qr$l1HG zZz-U%#Y@r_-?5;XEndmD#rFhj*%to+h_b~G$VprL7a8#qhlC%C;RiQvejR|pW!(M0UzEcXh|3}TQIC`Hb(8dujiyvTu6tGvlLDg z^n@@v&T7=DhYP?#;zQ|M9`aazTS)79f1gkd(5Z{;?>|k{eni=mn@R)Vxe9?i8=%@tNYNKk3Pu3fg7w~BN$l&xB9H+5+q zzfmbZj$#TU$#?V%9noy01j;ud+bMXuq1O85_~wU1?RQjmdr%QSB*cI7%=@!6@6YRO zUQhg}&HLYk_=zoUj23Zx^KC+Wr;cwrkcD5>%3oTb9R*`wEOO18dE2q(!W01E5W=d8KLea=cnRNmu_^l_4+1cCXo zor-eSoQ%cUW?{5`a-~sVla7|n(qnU=Xox(oquZcwxJgcBTL28nmf;4}s+)kD`4eS1 zK-7$#LQd+b0vX{Zi#L-hOM9}JNDf-|4(0HWB~9y!TIS7byYX(8@y zTg$cutVOxoLM*jhtSQ!FN8bwFNWL{)X@@YdYK5mr={8cz?u2Zc93(msGvEm)~`_HofgGu=5Uwj_JK!t4dZNkJ-RG}#eY(j#^v zPi;u3cOIcf5PDcTheb#UPtzE$*g1?9_~9nLSESiQicR!EZjh*y9#D%s`ldx(ZEn_d ztKbmH6In3og_{= zNg>!`U$ls&L}gNJm6T@qOTet%2{9Iu|Io6bt5n}^L}$O^HA%+LXPL zVkfq^CtAd^p<7byfYAd5dy$2-nw-~R+0aL~lTM0Sw)0nzwQLyl^Olzldy_pb8}=bv zU6W$hbzU~~)tv2`6n`OSe=Evai_3<;1FiVvjQOyi^x}b}-fTYXpFbb&8)hOHhl2TV zKY*zDFoT>_%KpfRe)fF0hdm$K-NIVE91w16?WfQK!-xTsoBD(0Aab-P)jBu~Y)zqi zNyQvQ$iHF=9oX^|x^GhKm)9E(kiFr6b?yzW$Y@{KFDdp<)(%XHeL02htxNx!6#Gz= zgTtaI9sj8*^dA&@@H$SR2Wj>OC&j^J?~pKiLD#bSTcCb3g&qnl=|scG(_SPrJWMFC zZztcrBM5v5fkzVfZJudx%)^@ZP+A2Qbp$yyiIZ-1$X|@-D#f$cQ0ols$p@!;{U}?ryO?RI+p;Aj66XVC13-DnE%ZAKJ>= z5p?vcgO*aZ^{K0dbz~Xb;?%Edo(w{A7RVw~dsI>krKzW{CHa7{Lgd9!q%{Mynn~Ty z=c_6`OnOdW_MpzJ*-iloF-$EyP9>kilR`PoX_`@WQfLVt_zs*Ev2@@&TH@1*67sX= z4W0oQJia)b{GW-u=KpOve^q*fWLRDp4rc;LpgjNa(6fk~FPfreOnEj@M@q}jLKa7Y zlH;AoFH9U<@W~PL4)ZyH1cPak}G1jo4N zk*Co~<<7HtF@|){CtWGGCNx%$0RJS&*kp+JW@3|pAebe{T>va-%)dRxlhF&=M4+%j z%*_Fa;%qLP9Z$~Yh0#37q~BqwmzteV$O)KxChNI}jpDKP#-wP z@ydarsDAB9OeNk@{{45nrF^cG2BRUyOP3J_)3+mMrny&V~GZc?1T z2E+bSOL2ZuTtF%A03MPRq(j55B%P2=0tPz!hFwLd3yFUxa=0B!Px4o)WX~uZpw2UDYkwzJHf#N#Bt&jrBcIrlox^l4-oJ`skb6_j-Bl^<62`MBk@n zn(X_QOw0PdFVj|iKay$dzU}4dPMf~l$+T_X?Pc1oZ+Dq))OUZGw(mPZrW^NtO{N|C zzAn>_eOpU@H|d*_>85@6lxe5FhsboZzGGy%dEfCe-J)++rk(pqt|j6kDOse?{G_;;zVI}}K=KR{ ztN#Tn-aZSGYF@GA!1O`WF<(h$Ir1VPIiChFfg%meOMtNeIKX37@g7$nX36q$7^Kju z<`sej)3O>(l^G3{SHmFIOmew4c=~c`|24oNc|F`{cg0uGM5p|MU+6mO4`i-=b zViLOMZbO+YzmYXAe%6_A{#xh_2rr~I-c;InE36G}nnMvKc13~eAeI&A5WzPC`q7^v zY{`D?u22UmD<^0+i+jjxjk9sN)o>xAZOXThRQ2;{niDglyiNI})5#VQL`(aGy6m$k zDNy1+>JlqYFHDL>N%dTgMp;Pjc?X2_wDz+h{w~VILJb^519%U`_%;cqs&)7_$wwf9 zPg1>&Z<8!Z4$N%C+le2e49O=*a!ZmXxCuTKvMgy`vyX&6LmjTJLbd(|srlyP(xg~M z89xPK%B-f*D_Qgzip0`n^;Jb$z+FA-i`CiB$=X$5t=OkiueIq|tXLmIEQpSF{Li5V zqH}O>_Bqrq$nsjW6Ogeq_6OSelCtI#kuHO?1@#TauK)rievL#{NFR}U{RTzw5#-mw zNB#>U@R4otUBerbHOrGVHyBU(Q8oMvlH3ipr`(pbt}VH>tKXUwx5;T$xxmeIfnPyH z+?uSur3h-C3q)b8A3k1h-={u6SEZWPSJ5>1oU_#^r*v9q|z&BB^Nci*rFMMz~e?LX|IxwNOC#bIqyqa*Ug>t-lVwCa?aHhdlL{5 z_a>|FDuSBloSU-EyL{&i)(X=9Q|SkiR&Al#CP^5y+X;k-qxy+tWec*hW&-$hp7i_9 z0I$9~89MinT+pd>rdh-!9*K1+fS6mA1eSEim5^?FO8MX2C{@QRa!(KBErFbq#g?FI z$-~u1D*X_pD+d%=_*Hs{lrDuL@laBFVHNWaCadpBhF7!sOen5EDClm=-rx>TKALHC zYw~nY678iQma3^{L13jq>)34oLJrlgP;$5}iX?ji8S$`f$yOLE)JI?ZE$Mauf~4DP zI*~xquA~zcpt%lxp$CYdFZ>mK;n8HxBc>ztRIToWB=?Bz`cEaT>*lWiWKuk3x&Grc zQg09uPbRCMD1w^j`a84DCyKa!RK8@-2lw+^sbwoqCoRkrl=*Nf_b5oMOkt{9DL<;b z3(2c8+J%Ez-q(9}1q7>ZzYeP24@98q(fD}hbIF=#lQqv6ZD&veMeVPW z1Cdm}kjy;;#?{1O#>7Fac~Omtrfe|E#LLOti|kmr=lHiW{Yo-WI{JfM@gbeq^b#r<8H5&9_#h^U@-U+R+v;PBSwXY|| zYsnUxNWVe!Lkv1pY@|4p=x-*41UM`Jh$)8D9W()e*Gb`U0#Fb7l}a)&1Z9IuYF|!@ zR|s+hF0}>~3DeS%tdPpu9q6^s6L=_bqXPMLFz*NufqAz_PkPH3b|lI`zfL8iR5Ds6 zkM0}L2{;&vYUf-$@w;61hrN5V_KTYO7 z1V?I7ysN)(VXaq*T4sKhBam#pfvtyd3Qa}jsq|;k0VlEbfPOGsmiycOqr)I+uz<~Y zfD`7)E$fK6fYzTJ##3M|;F-;TBk-!<4fm)fl!-4|(8N~hFQq(Fi2OlP;#)8Gs_$e3 zJS!nMYlZG2O%1cGproed<7p6TS{OnJB_Ry^#{dF{hhHScm-L2X!w6%f0g2%Ev*Q4P z5eOfIn-a2t^^I8gpBx%l81=}?i{$5oa}=N zT3z4oZK*laT~DS+0k$Hmm^MnthCx&V3Iwuag!4miPY*+KRR!;o8Zd`6rxGNr0W}6w zjW{LyTKbAwZ^%Ay8W6D8B(3YtFi+@wApM`D_`wy4(T?4>*zX&Qd+HRALLP)~QL=ci=Nk48g_Q4HahsN@Qj zT&a?!Dp`gk_oJ=7SXu6;qSwu|*(U^^g0j!SHwyQdmBMMutP~DwLiN@Wh&hcZDHE|W zFnJ9aq35VA#xFF=wI~vJq2br0#gWB9o>6X45-mqk{hN(qakW|=tYllEcW~a%K7prZ zIkd24ygZ1tPaylY5GHiolGomiXejqv-~{DqPp&J~B3(*w6D9D_l3#(&AtPFq$%*4m<`ZS1 z0~E@fwk+s3J3XcS+b_|_468w<842GbwEBD`kjaxrler6I!28`uER_$0$}h!-e;G(6 zFtiHFbLxPnE4E5^D6=YB0@u-R+Gl5PfT^hPo0eHSl`du0wKc9w-pbRR z%S0DBpsFchbIua~1`*M@ta^(gsF2h?pnsliZhRZIYkYPz1dpzYcnP3q+u|{?J>wQQF%mgS_t|$(7qmt17dun=5UrGEqgP zwa0Cz-+zaJ+t*f5aqoeU*s83$vIu&f;@(%yf1r{N$wg(LM*qcCK1zx=7u!pVUm>O{x0 zW>`}ls~lBzKC0p+(J7i*lcqM=r#7i5wZ@{FLW)_w2JU24At|=tm?Be3ZOPnjgq$Ab2q&Sm{i!-^X2rJOrOU6nI zuh;2yDs`^$^|Tc246C0K*3i{%WO%-TuPV~26TP;Ww2<{yG!&7t-fThXen4k$9d)BC z+>v7&n?{X2CUR;#lI4x>SR}g;l{q)&MsIiP>n57Y2tNIU%0;NW!;QsDVoxfGVo#{F zHK7A#EF)~<|Q|dlpvjpl-F}~dZ9{7FHm@;|5SLT=PSI@ za}|AemP+GiE4cVs3NAiV!Nt!^mT^FgpOI`u`lY98dZ%c5Gc+I5K?m~0vbx=qHQY%W z?nK@0ajL!2V|Dw}bo*0v`%`rLO}hO?-Tq|VeuJhvQPZ8E+pkx2V&k>^WA*hIeLY%V zk5c%tI)xt_sqshX`r#@q9j4QxbUIX}@ge&9aFxam)9Il)Jw(fYu;%k1&F5g%j(dQD zi|?=H&1iY|)AH`CZ(e0A3CZl>vW(sVb~bT`p-J8FJ9XgzJD>9o^y+A6qM8$~D9TI(sHuRWc* zIxSK7v8ck2ISRk@_k`?srN1R)zbpMUA^V;8b3*oK_a{~F{;2BR|EhZT2UQ>cE}{C* zw+Y#QVqc>i{lxuJ*MFh#Ja)9I^-1kLjX$a7ctY_Je?*nL4{7-y)bc-| z<-b>#-=oX#R^^G+3eUS!)qAT{y|+@;dpXsPw?eh!-lpl?s_ERK;Nmyy_HWen%XR$? zy8UZ)`8B$HnQs4T-Tqa&{VR3*SLpVa==K-u_Al3TF4J@_)$K1(bmEt2J}%O5^EKQ& z&Bq10{(N0OTi2hb`8h}PGfVSxw&v$7&Cg8D&zYK^(=?q^HJwv5KQk1a(&;LVpRC~G zCn>o2i3+at1l`_oDs_+5^p4T=rYSggs;1MZ?LJwxADe`0%tx^XeLX?@(KrPk8>8T3 zqg8$BNJYPNgrZ+MT+=^N(?3GGHp5zIIXcN^3PgeKbF5RbRTZ;-|E? z=BJmY(^J#wq3L&5e3tH@>2=d-jpnzjPPf8A5W>Yv|RJK zrRKAX=CiZra|_L9CrxitO>YxTucI#SpvyPbp@I2`-gljCsgCr^&U@gF=n4wwE%)t7#+>Px>< z^`+l>a{Mj*##7_(mzvHOn$G7M?lX=5smA|AmB&6-^kW}+YTW!#Uw@#}_f>i6dm8^; zjsK3ue_O-7rSad??Z2Vhe_g@FUsZ6WuV^|iYdSA!{$A8_yrAWHPSbf-(|Ja>_q1;3 zDNXN5P45X!?{Q7<5moO#q|*3<3NHSDf{Wj;`MOWF8^2ezTY8tKw_4M?Q@6WH(TT0p z?dSCM3YC`Lq0`%SdK>YuuDli37*9%X)^u;ubZ^vrE?4le8+3ZTrhlEjzE-8B*XVSa zPM2!>SL2%WuhjIf(DavR`im8OY>`eED*C0DtLyk>I=vJr=Izo2>bmq2mBudC=|!5a z`TBaEhMTL~ouk{mP`7)&E}yN-&(r1SYP?x0b!VzHex`ztpP}I6rz`mQY1%%gYWqyr zbhDc7$qFuZlA;qkQS*6%f{Pum;9|#VxM{k4sxF_R%bPU*(VCwIm6lG_?M=|_)hqbY z@!DU5kHL>onbwnx7H6ez>k5rt633^22rcVY>WK&Cem4pMy0&2Wfr=Ykmf4 zeh$?99H9BxPt)C3(;cYk{$2C)H(kGvuHReN@2Si8(B%Vkd4J7MKb`i~X{}1*JFB#` zx8`pr&EJlizh0WZo|?ZMbUWR2J2kqUuA0B?b^Ug_Ug-L2-R{;ptxNCOV+V{UG(k@z zx*9RA36^RF#Iyn&&2U6B{JX0*yuYcPee73P4#*`xxpJZ?`O%dVMah5NGH#GdesJZ0 zAN}4{8|Uv_wQ>Gd(TRSePYS+53jU&BA_e2lYyMfvD{f>|{glQrq0^?9i=GX<=|(0^ z!O?(!_?N;n#7^{MH&Q;teZ?Rt8vzIA0WSQaa{T#)H}IB9;E7H6Q!{C z-ADuVXxhUO%j+#1vBX-J;(uKJ_&4}(Uzxl~iQ(eMYvv3EyIhsoHL4{-tDI>opla|9 zq^H|)TYIe&`0;;`w{rn4ny<<{2PSVQQeJf;d#&2`MwcOFcU`Kkohy^( zylhFb*g5xAtSNZTy+TvHLsPv?U*D>!-|SPrF^Pk;5lsW@CXQ}G2lLO;r?AgB%T+Co zbcapGiJf079mKhzC}+16=1iVJKdg8tc}Vm0piUn^N)6nnukTf|W(W?@2a0dA_TdKvJZqHOo)w^hwS7<38(;CNabeLo>b#Yh_1$ zq$q1o6mBtIQu3yvUh;-cU)SktDviE^6B#Pd2H{F4`mQgV9`K^k50q@p2FLf4;eid<9~Ra&PmOVA{DbE3 zKbphuz@a+K{-!90-xsC`Y8}he33LafkiVprzE0@W(`gJTC&UtU?fl~FW{zdj-;(;2-UsGg1tC=H6c@gcw*_ko4scbvk*#zi6@DY-MX6O5 zq1Gyrly@TVo#T@_b}W4(v8w)sGyi_Y4J!wBAAH#Mhz%VXQ9EQxBW`UCnKWi>{n$xE zpyKgO4U>jUXsE};-_SUusbP5Cq=v~&bt8w=PntNoNAI3Jg3P4J4dd!YG&K&H+SoK@ zebX6sW(&qN&PqVOKL{N?27X%EDZ{&gEMw!UiA zXjvA;-x6nYf`G6`PzN2yX1x2E2{_HH@GGe*|?P( zVO{sGkqGP||JnLx0kz#VpR;5;r7Nv-!cpTV=E3!gwCiW=BI{`qiP_pBO) z-{w?|_0NaX`e)Sw-1E#9gVQ!3+}3Ef^ES){|9pDd4y^eSzumVFV3;Eu6k0=f9a~>F zxwdjZ?U4N^H;kSGORu|NOta2kDlGS z4>@?ikl|w|4jIw2+sOL*%G5?6T+?*yq`Hw~>mxOzA|QE?98dOFGt+h2_*94u;jbnDqIJp}u>QP{zB8xg7bYvYdH`}B^~jBIF()EqW8QuB{UFZ?+q zQj-~t-|(K1ntk^G*s+nCVUtIU*=P4&DA}vwk2Jit1KELkAT!)G3?GN4Mw;Sae5G|={%M-<07-J>OILO(dp`61p4*=O-s3lK z*`fW;f0m@N)d&c`pu@c{5BcKq;d>qN`6pAV9{joem+?QTP*81}Tvyj9nf>gHyJqI@ zd~DX|*{j>0cG8Sp+9%yVPqrS507><{ElQvKc3k!R8OsiGx9H#uZ-2l#P?epD_WyR& z?2DfJ{^(cl=|9r>eCYn~MkDjwt+}a=#un%+fn$ zX`6$2N-&Ci4`nlv89430zwF(pem;fFofxtsh<`e!U9@DL8(rl_?{lMNksC@!A2*a+ z1#HwK*?jjlRwaa`= zjps!=xq}bge@_dp3~-nGaFYPYwQgDD=+gejHr0WCsw^^5=4Ezapst~f0H$tf1K2uJ zvgO!`cwA@f$P}L{88&f5U8<>}AvJ2)~-9@GG4ZaQ&v{ewp}O3iL|+*eV6`ww%Npsw9Q0^mS&>E@I&fUD!ffH z@{Vaa;eCj7F@i0UJ4xCmZs(XXcSJsii6y*;vesGB-M^z7Vb4MxShcW7)h1AY(LR0ry8eKiy#|k73 z;K@=JCXVE@HNJX;n>zx{sTZsGHfJcvNPYE4yS{6F{eUcawtUU-~bJj0@7|s)rn=P=+}v1KzRo%tOjYK_lQsFKSxg3h zxni$5!RPR@7+u7%=+W8f$W>1yI@z&53S)htV+Mg>&WWUH;#Qo(LfB9iwo_tcPYsca zY%>F$Nvk0ET-j*=QfO=w@n%k->awS!7|BeMILcC?=FR$g2y_}TvF6VLxO@TmY-DOr za>WUnCDLwJmOfe1o<*V!Mofzo`1ZqQoI{|AQW0%8)dHQ1GR13px}QeUTfG5$Czm zsh2Zom1aI!ud8?!NPo-+~!4O#2i=Z`z7WtbgPec zbEBmAa3gDZlYJTWxjITg|H804U$XfMiitBK(2QP9_z`tpC8p9s1EDI@7fICDh>CG4 zGzGklLUFOIe}na*q5NoTT(`d%@+Ke$C&VSL9Dgy^am?y-u`3o(+_y*vEb8@>G?Wz1 z`f$qIq(GItgN(RHspMVcYcF-hd{+ssIIT=yCfR#WlU0&S%|sPMz5?DSB)m()nBnvT z6o$2Oxg`4`f%CQU5emgZS^qKX*Gem&01{eR6xPZ@S1hJhJ|&%E#{LYIT4rssC9?6) ziDV=(J>v@&=5x%Oq2daO^cCyZisP>ViSIyN8Rqy3S6oGozagD9*zsFZ;D=qmLq;rd zrA@zQ{&Hp0{~%v`wJVejf4~(-$bJC3LxzVch4U$1F{MU{_ ze$agFAWPO7GDgS-xriw-T>|%J`Srf*U2y|hkK8-&uZHRrdWWO!J*UBT>tu^FEYYo|+ka-H< z7-jI4TSD&9=Vn*jN_BNWt=9i-Qh<(Y-Pk5Rs@DJQB)I8X<97n2xLxUgGv;rD{>4os z!ly;#;%*CMYVUBx+184^pNuGi$!UdTxHCYwwNZ<|<~spSWNJlGV1=w=@igE4bYZ)4 zeYmAzrJO}MSEyD~xN1ISugagYD+m@W0t!vpm82`D?5&W)H?h#h9aKUUFR^#aZcT_g zU2$?DC9IZ8s0Ij?p!Rp`NeSDqUAYC^*03U2beAhuTdd%#&UZ^DwnHV@<>PM!We#G@ z@rfZNa}9D*$ZjmU#}$gy4y4g+MRZ@jdb<;>W%c$TU8&xl$PJDOv;hI2&XcI*UMwsT zP5!aYP`NIuOyBRXC5Ee#K8>!p-xZQnZ(wm=@Hh7*Ni$LI%qpBFnXwpQ2itL>i5+}4 z%{r`3O(x6m-n9zfyGG%A%M`x5RMWp& zrHQK)T;fUvm$*W~c}rBiw^-9zr0FcwbaXtJ_+^@&jtk>0(D0XN_=`3CMH)`Wi*e`Z zYsQNK-=#WUO#D23eU3_FXY2G#gzadMfjbx?<1`JWisbJ(h46sw%!;xwCL+Y!|>`(-RNdd zNlz&HlF%p<+@=}MQ2okL{u9^ZAc%Y}B&e8+r%{~fNRVpw!qJiHg(Lq#>=d4waS$NM zJj<`2cXy&=3cPew2a4(qBkSRA1W2l%FsyNW=-r;-ehik-)8S(QTaZ^oOllT_WpuN5 zl$_`YaM0}W@_HaQ0JqfX2@L#<`WM0PMD?9up z^xs75q<_s+=J{QiX!Oc_Pe6&1x;#)oMy;wiX zeJ`HZJ`}F_|M+=rJ~%wh?p4aB)IQ)-DJM`!g zdSH7^&ujPEu~+Y2DgJBudF?Gu51!Zl;nc|gwdb`*A_&ylJg@z7=Sbw|yrv`?h+C(C6;h9GJpATm}ue}Q<>pOWL!um%zDD;2zd2K#D_`mzS zw&d>5Jg+@I0TTqzYaa#2+3>u!c}$;=n6LlmwY4X;b5`e`XmwQAIa@ye)j`wdzkT3E z8=lw3^V*}#GuZJgp26Oni>XNargeEXeC#oGBc&BjUh;9L*il=I>hx&GJI0-Jf6r*- z5!2YlY;2iqEE;*&ly+h1HM(?jPd`Xr#nKyeX{{;UjHNkUI?j}C&eD~-bZNoT8%^of zgk7a!Z#AXXqv+Ad3R4<-Z2db^8iL&^q4^EL?r%!1$Kl&7iknB=`(u>bXX4nVp?HA1 zlrv-Y0WkD*3K{j7`*o2q?MkCC$|yJ521{>*9jqJKG;BCtr@@o)B^=MQR|Dl4qPUn2 z+S=%)xRY>84tAYGU1z>q@`xLK z*NtxOMQgq2I4`=?i{9u(Z}p-pyy$mcbf-jg|3tLSkWd?YG9aNAXDc-G9GjW@cl@~; z4E|+II|r>fUgYQa9{UU$JSdXA2|)4z_9z}gZ~h#AG&0q#+6~(m2;XnF9=q*kDWPA# zKK=Ue#r#+-%TSD2yve@^j(d78;g8( z7H`e))qgU%4sQ_rw>c-FmkK<*(KTpr=DhJuca)qUmQ^*487}t=S8}>gLm&g&{kkOh*I>03~Z=N;_{U@ym&Fy#b(zz3P0D0 zVhf0S8~Az1?{DQXP&gfQc_Y&H_z}Jwsezwl<-6;A0x-B`iz`wfM$&>h%F3s7UScdH z27lzk&S$gsRX-c&E!LP;;uiiPR=$&sF`F10<43-Bv7nBz@@buyd_7H!jqoD|Q(lwD zF;;$CotGFl62d?M($8nlv}^XZalT@WktAl}47T#LMo0WWGn##u7)FxqEhxk+_FLRh z=Otf{5W`5)+JYKs<*RIrr8d7dS9nUv!r8;d`G_?}5?lHq7Di_qV?Hq`8#O%0f;z#< z@2c}sl9z~K{BctYs@}?XwJ}!M{I;^7va{@(fi}*6Sz{zAv2YHw^5nv|$r551n`~u4 zO}6qqbzVyH05ObB$}FhiRvy6=q(vph6*j+73o1LquIX>%yvG_N3AF6{$6;1}a~tDA zVi=nYu%M2!^0hX`zllL@(2CRnuj#4dto(L5FD1E^5C+N~BeG}NHGi{lzGID%q}0Mc z*vfB$d_VlyI^m5)dRZ`2t$c5tms~wT3}cbD7St#!Uu|PtM-2Yho;?cTc|5CTFB|7G z))+a^u8)7DmEY3FSU?P8kr5WuNml+ZHpXkjFc#Uuf|_XMyV)3b+WfY$pt9%MHT&5( zzp&;g{AhO@>HrI$`t*CrDTFe7*|W*f7Df-9mo~YN7)D#Rrwp?&Dr}6!HYbh+g~v6m ztKDs!ckEVdJ05CbY-VHplNiRk?Ahd43!{&X@hmZ@4Qh)iujw~qt-R2ADf`WYFiK=i{bY~@b)uE;Yh%1Z4C9aXY%;;ZsIf6t z+WgwGXV0-~_O)?-VvVthJ)77((gL)Lw8{O%FgCGglSY)Yj!?aHUfSd#mKvMbvxz-k z7)lc3Dqk2NoVzAht%vB(Gu z>SQawo6bv&H;7>@VysIZ8!U_+Y>c~Xer?&a=h-zG8|OFH9EBewm)hnvTiIVjF;7X! zJM)c54Od1&mQS+ayX(A^<6crE1-4+%C2ZBSma;JxvDDPq`4)C2Zxhb6V$UT-cP8f( z!}ylz3zVej&g2H_`7$`vc`4)C2UlZO)V$UUmEqq$TAGh8m zhLObdQS#MfVeF{$lCMXJVI;A~(~%ZNm5s5C82pj0%~cCKlaC2+B(bG0x-+?m7?h2^ zG6<<@vFOg^WkMK#^B!;nxJ)RcbnOsQ>{%Di6+?l*jcq0k4?Bf^Rnam-Ev57sG6y2FTPYh~%5fXdRq>A6l!5- z^0_SssQ7v)x-+?y7{(&@TvBvr@;Wh$MeMnx=+0!dEy-H$OnxQKQTWmBHvR!9<2C)1 z`t*B=T=N*d?AhdK3!{h5OAX&oI>zd@rwp?&Dr^kd6HV(}b(?$(JCk?qR%|;K-I-iK z4AbB3*`(;s(OTvXyznFg6)rK^<@9P5+S?FA~GpggW3gJ$1a5H>)0r zaR(s`lr4J;JCh#>Z~BStk^iu0(Ifid$JPmNEMhdz@@W?Q&N?r-`WG>bMeNyRw1u&a zjj@~<{E@D$-4=ExUlQKPfp&fTp;q3Ew34sOiD4{ad&kKZ#%?++K%zJ>i99l)37F5~>xs$$yrNpkh^iqxOL&E!vzcGR z0g#=FHM=A2;@9*;&a^}4@8s8TVMX;2hZ9R@zb1to)xa96dUL-9Vmdq&WsRC zJf!T)Gu@Vl90&4{7b6edAdrVslaXf_@_{@@;mXKEsRMZ^osp*p@_{_vab@J;P!`C; zWwI~Ny_CV1$HgsM6mXA7GekjvLPoXEQZYQE<<5`Bh@wAo{}2VqC|HT2A+BAcSYyz@ z(Y7w0O^B3iY(kL@N0helDS5lt#q$Y~k}jsEv8iEl-N=*zP?5?S;WL|ik&-G#KASLX z;;|_m!K`6&5EZTQ*a^cM>Iqs4(9H}vJ|L>W8&i$=YNHz&hx*M;J-&Kqs3HC%;=Tf4 z>6!p;1i;pYf^4CtCN*JfW8>I~qf_`?U`@lQ8YuvX-3r(u5!ehvD*)0gf}5%Qt~kDq z;1<~_Q2^gm?vKhf#gN+&1CFoC*fFRmRym<5bI6Jm;qP z!f2$tj}AhnuTh8>Znup@x-Z^n4x(xS1YyX!&R`rBi4XwH*l3chPmu&(WZk`q0O?eE zq$}$1`sX&h{AqXmsXYpp+lrC+D{_d;HsC_jINs$Qg6oBzq+Q+z*M}QQUS;UAZB=@- zE5?Avb_D*-C%nBt5SxIi3jQMLnZPeyt?CrsSUo4z{q#L%fd~A-Yw+Xv@^!Z`(O!c~ zGR}?y(a!?PRX{zTsI!SWo2d0*r*{~$RiUx4<7mHqJ(0eeYu|R79 zVtny0-mTuvqSXOl-@_!}E|SGNC&&Pzp9Mix;5}z)D_y<2Rjp#-sdup@OhNT*lcspN+^88WoV%NG>eH49ufgU6g2nw;DfXLt^)T0{uX0nK}Nf3ys`m7=p!sA6& zMjQ#6E-+Ne@FTgieA7l?0u>`G2tL8MBNhl_9(<<;@Sflf=Fc)3i3QQTtI7Z+)d)%w zFvFH~%uq8JWEs7r`W!cRHu%wVM9M-@(H6Sv!85|>3EEGxGN{RUGI9>fWb6XQB&nY5 zmvKzXGCE21EZ1UI4NK7fLeJ-ep-ZaIwV~7q$EHn-m4F$f!U-`BiA7QA5K+r6sE`xp zE-Hpq6`&A&2~05fhy||{Dx;jK*ieikf_P7Zs?T$CvrTX@w@d~igg|zg42OXzFjpxt z`&`K&M`(fpNUSCTvv!8fE?}R{%FrYW3CuVoGI|Unksv-5f+Y=NcqH9+|0yMv2#Fx~K1PWyNZ!Cz9ps4KOt(u$igcX|SZ3%%tW**tY}wY-1o! z2-S1t)z8wg5XS})pb+rJW275Kuy@Rb{JEu}U|wl2KLA1S7fRQ7kFjC5Y>SC@O$r=oTal%3|>o7`C-uN`6v0iDCjwSLQLte&gd~t?NMZ^gwy20*EZBSRy{^62 zXKx6WXMa`{d;fpWIdkvK-Q5Hv`u@NF{~12)+&gpHoO9+(x%bY{XTwN%CzX8Bq|n2r z9aIFHHal@1BW&L9M27~6Q>iDicdywB2zh1G`}vIq$mA&Kr|yq$0oQmybUpH6PJ<&K z;WRYzQBK1nAB&I21~(9aK5KKH^eh)LEf;bv_mog8e=_boO-N&bRKZPX8$y4E^0uR^ zXPJ=OfVOJyuJJ~l=M>pzzwc7Q&lfl#C3 zgX{|QePP1O?VU`&!#gXDBa9q}dN13d#uHdRchwFx0U%=H9dX4`5?go&oOjILVHEl@ z43EvI;L7QC7ZZVms_a6zA9!vieU-11Lj6Bf_5UF5d_?u94RoB3a~V>1#33=6{)DT& z8vs)$=Ld8J*`0`en&m=Y^vH#lF4u)DXDNBl7qns7XR3Ce#+}cpc6*ROUqYZ0jeg~8 zknFyj?zVq6j4Fc>Auc`8d~{aVp|iqVx0Ak|lQN!)9nS*~1V!vuew5L5rN4nZ*?p7c zd_$G`nkw~`s??WpXBky$PgE*%GF3=Aywdcyak32eovtaSP|d%MD>$xxY5F^c;~N)l zFM>nWDNsS*-_hfqHSql(peA98|d{5Z* zboB$m;IBq->{F8dE$;k|+>qrTphT^n1jiV#mlqsk7J_5cf+vJ!R9qgioQT!);22Qk zevdmrtK!$V^BV=nAC;&55O;neeKh#hI5jsEjqWJo9RPW*gI&*fYTdan>Cs00WYior zJG`jd;U$y^w&fJiR+{_ynbmg9Ea)+6Bu0If!)O)7sE_3o5~G=ZMwR&(t-`g6c#N8e z(P|!}h*=}-DTiu9ef<=p)huUqV$|YiBsdA24Y;PAOR(#hLJJTH zZPY}RN|`0;b-4xy65@K+Bxiu-j$L^0Uurq)BX?j{+u8`aUipE?AYgajwi3=D3p0R? zsDU}kZUZf6!ydP-xRX-k*0-Dutcn4aQ)(fK7pdI!EGJ2-KFF`?7O48EWC}YU>oJ3? z{?Q$ndT@8#HzeC*mMoF=R0^=1UOoZ`Jc4szc|O*ga!|d1G!XMqhf7sYN1rJLO`Kr%g{1-9foG z6ti-7FQfSj>CnMCexqj$9LTqVXTQUf&FH_ss)rw9Ymchd$W2}l%q=!?f zmSZeuEaKX>S#fQL9>ukB%Z+OV&NvG@dhbBNZ9CPXx3!$@dmPs+XKO`ntmSM&)m(^b zV)y7REoT%095PPR8ZwXUfc;5ng(c|;Y^l>pJv(wVg2A%&31~Mw#0-Kcpc)sO0R7A`7wu^bWqY~1DG@M0X-vM4=? zYk3a9oXPNjJym~~r#4D6p%5?kl%%Iv&R)RSC(CE5d*n0Img_UUoN3nN0;ifBr%Gvc zAIq8AW1q2|N=0rj%h}ti*wb>RP=~v#%EjewWV&-nSG7I#2+OHcWNR&FI*~mOWOE#V zS~?jD3yk$_sPhRbCphk#9UL$46U!GIF9b-%NaB1Eu6Td=i*e!9TdC8`z|@6nx{?L? zI0NbF(SiFm@x27}FxR6BgtLNLxWF5&UP@eNvOWni--46nG%0P(w47#=`7)B3M*WxL zqGEr`nPheC=BpN^TUmQo5UVyg?VRPhdDwOH11x7QFb>Xg^UfZ*`C%*I=7*7+caobQ zqAGu|7bhPIu`NoBobBtnlwB;O2?5+h8`^j~vmaYmLSoZTZwIA;YM;T&>=v&j+8RJA+9a?bh_9N{!YZlUFzZdIIO zIj52%oTze7u$%>?!W&3e=k?eT&R1m5vz!Zv?2RCs?Fctfo;ZS9*YqAO9I74RW)kRP z&k^Eo4@}P%;?m(-&LxW7#g=m^vAYFG=!f9}`_t{MxXl}FWoaj5lr3+3SDL<@gUfA1 zGAA@&nH`#M_jAq{n(qLJgyuVO#qOKIg>$*(Ty3#_Ff15>+NQ6ey4>Zb*hRqRCojI4 zS>`lameX^uimNS$3EoXyW6mx_{2scFR%~H8+*jQ1=OxnXCw$bb*DXq4XUVYpAwWCV znImWsj==bVG%nOEk^2rc#6WL%J*)I#;+CV*8?#mVNIs!h6z^fnqW}?^9>Wz+1)j!* zbG<2?%&ZL4=b4@T%g;-O?FNd_$TvHC#*e9IXYT6(ozDUSDt`{iUo$&1{cJ7h zpRGMlm5|xm&1|94=minEF znA`8X1_bPY84LO=~Fzq_&K-ju216$(?a!&YWMT3W_amXIm_$ zj2v6snQeV!}(sx<< z`362=4Fo8QRt?`LoV(Gx>KgQdg7NHJ*7D`01f#SNrC5j1PY8@M3QWM1CjvQ`5y51! z*cl9Uq)~>$ANUa#%1Xu=Wm^ayKTBskM9F(pM{~F3+)EYyfGVuDJBU$ev}|M!^fF7* z_Yu;E`H=D=NOiq4!P|?6t8jdUWZndXdZId&~9%c{w0=JkY7*xl@5bEUDtO?3Wt-34~2Gmx&Sao^a zs(6Hi{gNbm+;X0Pa8GBAD4&HvR(>`4IbbhuHTgMOaCw#nd;d~OeA;rJ>G6m%?mVf; zJz+UdQ8m9pH7Ca^9=4oEEVjrpts#BHW%>no@}~2=HHywJ@yfD$aMKHH$FGUV!g%J? z_`Gcv>Vs#$LG~o)B?kEx*Wmx1u*+|8kl?6_<;jbz!B~Q3p4on&piFyWn4)sC zZ_@ym4Yu&kN-=r6fA{2 zxvvx~r3cAh(8H+Dl-54AoX<&Xw6`}ZfcmPp+;UV%-NYdCAma^F zsppaxKJ_rh0*G`eHm=widf~$Pq?>q!L(RTo6Z8fo*z`e?myLe9zY0KvO(CwB&1$%C zzUqd}sDkt|X48-8>mIg0s(~Y5zsVl-txjONJJq$-4_ns&h={Q!u2_tpE2F?(USAot5z->G4x9lIecFR?;0D#WvyYM|V*odg}ES_Go( zDM_OK9Z5U@SCgFHHjU{^aqS;*$pmhB&$(!3^{qwD;?{y%d!FZ9>k9*NDKqH98QtD- zRlA}ONtz-7SGAqK_9SQZEHCQcBQIKO1-xi2@}mCaMQbPxu5LSP{s~^Rnj+WNcKT5@ zH$XKp;_7WXeQY+&K&>IOxvHfW-{|TeY%_-taz|GiB72gvE`w}@Yw#K*qz#8LtgAX( z{iN#uwb50XR4Cg=R&aDxY*(yDirpAgoMPK4f&Z+Zci3k`twr z!PmE)4SMW9mNP(+E3utYs^%uBCPr85+Rl15KTjM?_1*{~_H1-DNb%XocFKs)5aL6l zD;#kWaQ zy{$Byz`E~1M*u`R(9LkgwM*l|8D<-ZW6ciKY#qiRZ*xDd74LJm$cJe3xoNKPND`_X ze*8~cqNE|7?hi`RTiVVjK#j@r_HBCP?b|Nb+Y`>VdB!I>vUk?y)qeknHI#{7nF+JgX9gl%)4$HSI_gPl>BFQ}ab-JaDHk zi@!8tqrNQVqxxxcvyOhTs}C z+;1-2Ob@OJSCb=9Sn2|N&$Ly04Y#C%k(ZFA+Ix?DhSS24-*eh;WQONa>x`^oxOGQP zv&TCZ#w*T?JLkvg6Zg*ji7|`XiYp_QQIN`dbO7)+KTw2&ssAg6b^_t&G5jeuf2Z1k zJbb!~>y`f;yYm1L!Kb^G_;k0{mK_Z`=MuA8+xVEa!8Y#KfqakB2lVd8wB^3yQWR%> z(O+*n4P=G`L6}r3AKOl+tb>r{)SKiDe0lCrNY5R#I0kzRqwv{3eCi0x03dhtec(^6 z>tKJKga|hq1Qq^Rzw;1)0P;{JWPmlzLUtkxn#Q&7%>h?P0?B|oIC>#q1+aPIxCB@0c9+VP>p+fP{?6^7wjE;Z9Chc_0S0|nJH76d4 z<8*5|Fpdjxk`@)x!Em$UkytoVWA`J~M5fuRVcWoPwAx+|)d)wXs+>>~M*omKvh3U9o^8>jGg zkaBxlDYv$fG`_XK#m5RD}EuxFR17S6u;jsu4n8wi~S|`t0j8>#S*>$Xo+9_AaK#|1upWP zC4RU}rC&)JUn*(r3rVA&EBwzC{-+B66NUGYlt(_4^2i5L9(_;Yy{quvk^IElf@i-a zsr9D7S#JoOwM5|JizPq)y5z?fsr=UjFZQyk=Sx!0$P36vJF}ltbf1+p{*0pYFGc5R zp%Z&b@?%d*e(VXA|G3~q9})V|hm{^56!_=^0w29!;G_2`_ zi`#$Xc7c!FtkUaMdYz=PYgE0i7QV5|B|mda&9v2J!_ysEee3gHmGlJ8hmevB$VTFT=` zs{DB>{|L!1I84dcspLCU;Os*L&OTVlaggL&2THy*SLGj|ri~!6`wYNi?s^< z*#1h+W(C)z;ARS3yk3=0SLJo8yjIE!rb&6CT2gzez}Zy-XYZrr+FSCiO3AnOQu$Mq zyn8BncT;?JReUB3Tx^oikM1IAY@)!$b`rSQjsh2*pyU~++|YkS3iJH>xnfsb#a z_-(EDjaB($6rWMb@3s{AA|r8+E#*b3RV6pD!-4)FHrdjm2XSF6;t(yN*ap@Tr4bbv5>$;gOVQ&NPhJ9xb)+{#W^lV ze~oioj{FqoxE%R0&hb0)gTO_;kIOjWI~htvzm+upjij-!RsJ%;kA5Zi(Juu*zEr_| zq2NAOaGxo-PZgg}M4rgUN}i9DJRd4~K2UJ)2p#KfN#k!R`fmz+>(ofi!O#M5Zf>mA=q16>$?-rZ%)#ll>+-cWO+RzpG1e=PU{A+OQirU*dh{*(?#5S-9(U>Wca0xBdCEq3!6Z;q zQQ6Uk`DtZKeM4hIOC_4ke(lXIl{1?g;b_fmmF>;b>ROsx+v{p88(W%Y3>h(Wh`wlP zZQi%8roF9lR$F^VZ9{YA+{T7!m92G%D{Xa^vucJ69lUW%?Xawiv`3WBEI<|}7c<|tp0|DM$B^=newiUHU z6U84XGaTHRE`5I+*EBSiPM^VfSZ)B!+63zRW0)C@oJU8{hl914VEg|V2BC=l5X%7b z`Z|1L{4h-29L~X~!+_~E!6@cShG{#1uhBOH<_#Po@Bd>Mn2r9>Zv$rY9GOXm#3nc<_i3Ba+DxBZdtg#zj*T0jM6^#Y0C0T0o;FJLfF8W#^P~-|v8Tj+ylo2Rz zv%e8fsdb+nT4hCwFUT>!@x_PU1G395Qs{!Iis>shrl(R9Q20EQAafwJ1>wm{jGhCtcwfnoUBBT%-}4E&!qG*C8SEWi#3lvTIZ)NjAlFyw60{6`qC zXnfj5#V1#~=4tzaRjr$?!&X^cYin~W&WS+9DiG^twzLOUogZF&`_SO!@ZZ2tG}gX> z&fCrpjDq9z->o;|LjTTakm5uC4f%H?{vE`>v@0S?`c_8&NYu@v&iX)M@SsmV+F`Y1 zQNJhG7_jQTUo|}3cb}D|I=7>}p>boP8TsYsO!c1YEZpUh=YL&&{omj2TeH$MYnq#; zGtI=ZS8v$**E#PmJ9>{{!_GMV*}l~)O%r~_Bx@I4*1zDDoxa_A;QaTWzInZVeK%WK zlCB5Tpz_bmNo{ca$FINs`ILK?E}i)ByM1QI0;+ubriS(^jF6%f^g8>aL7$Su#d+id zrS*l8;DT7N&jKI#Pz^r<@K+LiD~7Nwcrm8F5VNR2bV)S0EE;??7JM%r>hnp|Wj3j< zeQZNbI~I(qTQS^HOlN_}RYc^qHSn`OVpQjK!TQ2*ct$MvVJx@+B<}SD*rg69pNy-k zYw^$r0R3u0zXS`xosIC@&MN}-g+W4ZieV)>*k_q10i*j+uOZao1Mu?@P}c`y=-ycH z8epyCF@@aQ)m7KlwR)Iy!1P+eT&EO2At-ONdc4Hgr_jThh{IEGhKh$V7Z}$O#t!S_ zXLn$1i8==Qtf?_t8)jlith90v;IAk6t5f)S4)6y6KG+Pwe)Os{u^N$(R?)?LgmVMo zY~$ePP*|dK2~-gdEs6%8jK}&!JYJJKnl!6JfOaFZDg#Cpy3Wz{h0#DCEKn*h8Qt8` zL}O-Q(+T*S2!4}I@KcCxwDT9RLG^FsDZ-?B1eFPsMh9rKLHu=A1L0;u7`7>X_P_vO z_;v(-3kK7T9c}ehElOD~LJbgZA%v}m<7WX7=57bWERJ#g7kTyfYMunb$%OFPX88FI z2%V?c5DBp>$bMiy8jHZ0TI0b3X6E`l$Ipa*Ici(|1qchRJzy0&Us z$8@lw$y=avf1uq)Xm7RSX9l`ooS3(rGy(W9>fPrW%zI{5HK4hAYTX4`w-eS~v+?sC zVOZ-Jy|Y2@iNmt?&t)Vm1vyR-0f&T9Bs7zS#rF&;iR9y}zD`5Xv@ z?}q^AYZ`5h^x%nft7zO!G*Z{#C$u_#4vGkkh(RMlG%nFJS{tc>h`y)>_YjE}AHdIZ z6sCTr8bq_i=yRpUukVVu@0ChkSqwS5ub>W zM4&hncrso}y-mZ6j@D`ln^o=A(@3sZAQG9=iFxjkAlxgwFdjTBj&+1sL7;zpdq(ak z2s|7^)0z%C1%cz^G=yrcYip~T-qBP8_EUgZ5V$cqV{TQwgtkEE_MF!m?HCWQ2?RR|M)mF{Kxmr?+ zsXe{xZw2PZr=x8kl+-pOvN0x?g(2cYs68o>IUU6`ca3Xj6<%YJZv~EY$v^~}7#fs9 zpcIVPVELuGy_!ii10@uAG!~d!h0)Z^HUxVZCNvPE*v{io7AXiE8?A1{`CzWrdol9` z(dkrqWeIwO963-lEiI>twSZsp(t8$A_~*pXJju5N6Y(d40# zi5>!4q|s+ZI<3ruA<_>s>64>#K~tXdLi6jPpdfHSbXIdiZ3}eYNe!VOkZ|jd9IAam z;E`BIBl$`QN1v5$IrD%j^+b5omP5AO(ime5tr|6|d{lYhaB|&PCp0u3_(ACJFx_To z6{fXeMm<6tz=C5t!R7=8D+pZZ38=)g0`ru+WSJZ;fyd9}xGGv|mwklmdXYz}1+?fP zb3vdjI{JY2I@B~-5O|PUqFf%8$0H+6u|Q304F>V^Ls+~5i5N(n3DTj!Az)08nyct2 zHLeA`6O}!YYEckqVJ^(%3FVYP7nfWmPHx{&1HsLfu>hEn#qhD2bu(+QNacFPKFEIz zJR>t=f$CaJjC=l`m@YTI^Hiy|IJJy zL6C(Z^c-|Uv?xO$vobq7Ne29y&;+RpP^vJDOg=BL6CuGYl1x=3%;ns`7%M9f|N96# z@}s~1{?@?X8u(iSe{0}x4g9Tvzcui;23AS~f8YqaeWE*ss`0-@Qk+*6LKcp;3RNO0 zlw+VaU70iLI-iB?c$0fJ-sFBMUiM^uSQ4Rko1aILS`d?+c{js!BJ&dM zj*Gp2+A}Z4u|aGSFH@^i>nM|6kj5!#aC`_2&V5KNxj4G>3d%} zyemcTOY*TKpCHM+!BytBz>CU1iktVy%sI2~J*G=rcc;|A(2#8}bakl%W1&Ldkdd43C%BzvS<3 zz66v(D7nG>F|l#07sYxgYS{W^87%YJ~25N@8Y|s^L<8D_$ikPZMTGDCo->z z7Pe~ty(s;8JoOq^2is!F**$o;6~KuUnb%#YKuH?sVt`}}CCYNxkV2s2l=r%V#>r8V zi^pIhZvqz;OXk{jU&o<9LcmUNqJ-563fccQ4Q=>K_F0OLU@4Y9=piE5 zu?^q-X@AZ6)B;~*80R0#*=YZUd%K^C;N%UWBj+iyd#_32d}qoc-)3Y4&HFl|Kj2gz zQJ^nr9!n}w0JM<5p`r)%1`surZ>-Eaq*u54|L}tlv&WN65mfGCD(m<`1_K0pfw5)X zkHgmWgUF|jtRaKFAkz0)-Zp&e`SIw>D3I0~(%(!nG4Ip4q#tjh;CY@I_jbH3_5+S* zz-++;-6vRyA5V4=Gz1eugyI)$fFEy<>pfKeZVH8Bb#(96a2p6#k7jXpNz%Rnsl@~$VY6Y}l zis1M~=zIW8A7WfA`-Z^x`N%(d@ypP8=eYt!hnvE-IzGlip4*oJCH219$h)>_B+I6n zK6&3CtkK4PSuJs`_v7=iEf->y=>nVhL3?q<^VXB(z~-?f2*jgHA`w?FLqGr#dZ?d{ zcr))>NBY6xz!9^-i>IOZB2jWyv3Nn3#Zn)GcsfkS;!sC1%r8a+)sX`wJI}^)xf=~P zB`EFY{Q-p?ejbgHsPv=uMY(*;(@C@y8EOm%PHIV129c#Sh!g@c0HlxYMgW2+7-4=h zWN{~z#sv=XF%^5MI1n0~7{)B~oJ&H_=#Eg7#KM9!x|ETQtH>>~z>fC7xEpuDM*6`@H#nTWhvhMZZ&Rr) z0he0Vm5zCk&AsO+z+sS$>mCfUw*?W*96pI|Q2S3!xM6 zhDiY9U?2ma9rR@vq4et5c!#8&lv{z_r~<3|`Sd5)-ANd&H5w^gY^7#kW`?lRIe{8g z!g9l%s0+>Ouw)Jnnnej>VhPSXk?6b!vBY6Y*{Yy=c+GwG7*a`K zp31NR+}fPIH)U)3MvO9YbtgoexyzUBm_-n5i8wCxp*m}ABGp$D%tb}Bmu^7=8C)fh zLq8WC1TKeK;y~Y&&mazKS*cacwm@zwUg*Nt6V1LR z3`MK#Gl1zuP{Wmkj7aVh+Sd;vR8-5&>N)o#o(t42v6HkdVUcrXGuTEz;NU02#=8BG zVZsB_Np`K7M5>PoDAuFs?@HE0Fsqm_eqteS)Z9#LiE)DkEvEp(vh>elCho@fK z$TfQOOdo2bTmwC_Rf_}I)`7RB>TRIPu$s7dTiLbx1vAD2LfpXK)DwsHELG=SBbaI1Ddd!to#PeX*04c-;04v>QFyv^W={4C^6jyNS245l}=D8}AU z6a{DdnTx4~vTN))eh{%VDcqa!96)Tl^}e|zM7W|z9XNKNpQPfd^{Bnc-QMmXKZb-0 zLqFO_VR0Qp=#_B;O2-f*Q!{gGe25=Q*Vv0Xhx#F=X8ZCS&hV7v67KY))dMQ)i1EV+ zLib9l&G$v8YMk4BxF1Nxj#a54xSWpgbCSMTIudsvG!Gyoq3p82z5S8M!dM2^Js8Uz z3nCcH+=~Unlsk$!4teml6C^niNhW0uSjsHpK6k+4D^5ad{)M%2UwJ9Yvv$82WI1IV zgBE}@)mcV31E~d^ge(s4r{Dr7@fm{9kQJMSYf1ZY1}hDUE}{R_#7_0shm?J%jIF#8 z`$9j+Ab^PF(THSG=yX7&9Fv=&2XB~l2GMc6F%}6Vvp&x?&-6nS0s`Z3jY5^m?u^d% zWaovL!c^!zLMJ~haVzApHuSXuVc_Wh4 zFbl2Km`o1lrU|+5G{KerCIDuJxnp+>L^q|zb2Fh|W7bJMGs>1ZPuAC~-CU zfX7>rjcVe$2i3d_L{QCj5O_vdWy9T?-i_?ca5LIeSjN2}ChNW^U2ZuQyc8f&g3lAY zhvY8r2G8%kp=5gVY!depiOstqL6SV4%#47jcO}u{WhwMNplPRIVeUs3w1w*)XzMW$ zfwl^vt$$i&BdxM6T!lT3lFSyS!bV%heXhc`vYgRIZTaBACqTs6%F2uc9TlOHIF%4S z^CXd%?5?RwU^B;@PZ7Z}R_31|s5;GLdMpuqng~jE*91H7k?DhfM*1%zI+kUZZjfbv z2D#8Lu6v;0mq7&jT@(7<)+*b^D%;xC?<**Q*sn^m2uWsZQ`-|P<33m0}~OBv(-~ze~b3 zo1sr|bgX-iAhxvxZ4HI?K4osBGTkR&A0Tsb*xA{Vs+Lc*Y zp7`b$AOhd~5go$rR@rV=*{-f{E=376|D_~fAxWuo6J7m(jl9gRroZlE8TYyVy0?W> zB(=ZpNtXQvL~sgYYDyQVp1;y@0GZuftKxxX6;4B8YTg6QpNUqLrJ?ZbuG+Z8lRez- z?$VG_?-oz?rdl{}lAQJzP|6bYS7h-3<~QPkV<`8sQcuP+Q*;aRRwLDTsc$bj7n#V= zNbB|F;LFD@LNp({m=_%I@-*o;h(ts(NqH-lL@HTcV`cWT2$49tI><{tnVx1j0M}-b zp)2BN3HuKLPz}T23xlQ>sddd_EENzyl;1xPbbr53-yLKsUFH2;l&-Z5k#(46HdG2O zQQ^W_uG_?rhjTSqmvOqDX42{OX;CVhOxLl@v`xRkQiBSZ%YgRqH^Dk(`S)A4SFZMG zZ{9bOgD=JL)$W`rkwxM7?kP~n$)Zq@Md2iO2|B+8BPIp)eB4jrAh=LhHHewmvKU5( z60nBpSOT0uYU;ytF7Z28ZFD+;*q1{&w@!StMllB0J?Q_|0ujWR2>QQ$t+EEItllb{ zVU8Hu^Y3G&QpeR4<&YN8D!W z#_O3lGlN{*^#t1Y-URb}DN}EPC9}Xhb7vX^Ol*oToJ?wB)6BjmC45+71bVL10A#@k zxbA@w%0UE1uwjJ#t+EzZ_Z7&7+GrzcB($wG657oe$tWbL4lA=imJ>?km$V({)wOUU zq_eiJuT2qy+Vujg)2Pjd%^Zq@BlUXV1HmOf#9r zVX{D_9eTS4^AFS71IhH^#Eh&f|LUX1yfR=#t=Y#f|pr#m2fv5^KCs@+rbR1)JjiyvQ9)AeDNxXd)VIiApJG#VXj$kwSv9u`v%v{G{|+AQ~Y zQT9kVNH{q1P`(e1?6k%^?9DTPU>K6tO5~9Rx!5Yn@)ON^Ow1}x5twI5i zYPf(PwF-n$UdWUDG)Y-ld1h(dpnS3)M3f;Qg-WBR`1y&-{UE3215wYWNPFjUR9xtX zQiAK67(NZBkjkD09Bu%olf6G3XMA3^p$$zq$ljT+d5! zfs?3HFqGzOaPpeVf=Q3r)IzPM4Wy$I9*2!KtflP6ouDOg(FliucKZMxD*zK zG~7VI`4<6i089>mc!xVny4ernSL%jE>8n_MxB8*<=#!)m6{W9csM`oiD`qe^^%Z|S z;f?}s2boER*hZ5ya=YrkNTMP>_khpjxTD9!I*&tdr3v2IV}h0@mLZL43sMs^$H+xE zD4o3bt{(GL6^Mb@-G3&rd;Uyf_x_p0?)x)|-A}}zy9bdP_WEO|wtmBy14({oTOw2q3rxK8lNq zYb{4y`7x3L(md@au+o~$ZZcjBBw>Q|!?RaIaakC8IzzxbUYGf9*C;Y*FnTU#Lq8Ex zd8lhl;;jZ`jKfCfZrEB5W@(q0g^a09^Dok{A;O=fTC(xQbhaTcV&shB$;F=euducf zq`SNVJo{e}ps;HJp8Kx|(7$T|o+kldiWiao8BXy3Mx=V_FH#~6NM(Se9Z0vEm;D;c z3KQ9FKAFCWyXIH^B3bpMGFw*qgzVM-3RknCiJpk}Yv9c%Z7srubCWp&&C;0;t?8R- ze(^dGkSs>h{V>sRT&)M5+v>5B5!PgGn?3NPNX4(cxZ}ztB=60py!66V)=NfjkZ_ud z?%1|=JGM6gfi<*isYY+nHNB(zHZCe|v7DQ-K}GP%;YSg%r9{J~Ph z=AOs$zG`_7xFGQX5<{HMJY$0LJ51ua?G;b9Z?~K~NU#q{pxb0o&0T2t2zeEETF&j= zQ;C(NGeqJ)ngl+AmF13)iNsx&lUWXlqV(NF;uB4R7L|F$$WT_JPtRC7zSmOLNV*tHf#G=BMVVV&qD8T=`-0|I zeyZ9dyrIrA66r?uzhJegGvN%>9T9=RR|St7duT=LIB}_gN<{d@rH7t??%!8F6kQoBmAK z^dkDNME)w%jYQq<2zcwF^nvv$K9yZDA@Zx%6FbokMHDM%5 z&;-A0j+%~yYf@)P`Z4B8n@1X$8q~<7u1N-0Md`;GE9}S0s-Y2DpD<-Lh(AoeT$+A@ z6dVCDBvGQ7?Mc1~x*<|FDLHvhhejg+XP6giPG2{zU^I?F7Uu~ob&F~@wbX7zHc-I( zd9=((`;RWqU=~$Mi)DzdGfnkANeZ!nRPh*HB}k4ZafCUp3+Ni^H^`Z_)bxaj_cprJ zoEFbDNS472mo$L1Yk4H->5v|j^zv8E?Xc9MJ*lWSASOpE9<>~a@yV`rXh@M&Z!J_&`e|-nef@fJ z6^p>-27=Z65IXK}?~Vle0fM9A>Lk?D^0;daTvzI9R4hW35Y3f{UQDVxH)Mc67QF^Q7Uz}aM6Xf+ zEl=U=Q>Ap&Sgv|sW%Z_r^7A~9^R^<{0C^QJk-i4vYBCMg9b7oCN^IMZu3xr*Ww6V# zi{Uv2klQx0pA>SWLOh@-v=ONHAZ$L*uZ+-PwH${BQ3ayTi&lmUDCpn>+7~Q`t5=3n zL%ggy7{2wISye-`%C}x4U2P0vNH!sw|3`dlFl2EcyRLgtdJ&s_h`;8pVT_kg4PnossL8%4U@b!q#Lw02Mi<`Ns_$9SpW3%(kO;*%%JrSV{Pfj%97A< ztatOvlX*je*1M#jQ6kh4!z1+CGL#d&u*L2C?vmZ$KsRH;7@wBBR& zZcUWm^arhNkXP|<($}`Q;-Ix1E}ZuyXl+l|?^wVx*k#$p@EilkZ5!PMtsOwU2SMvi zf6y976^J@-TNy4;LF+Bc;p&Y?sUcog9Sq-k->j+Lg#GHnryu zL^F!gAF&_q<|o^=DgMLYyZgblNyx$>bFp7Xl+yIaB-B znnvoiL%cJwl<71Rl&<1HK*^Uxzq^gB1rV$x{Z7OF$l}Gz*|>0);tlqSFD>T_s>vLp zr@4~Kd|baWUb6_=`hAl~De>TMQ}`iTICGKvDhj~7>m0D+v`G;!ZhXbnI>0Z+AAXl& zF4d3>axm5KE6e%Pw241Fs250)nP^?2;v5p|ImXX5e`AKFoF30zz z+Pv+4b0n$Md*uhd^|c9{r?xN?jSpmzA$1 z?h!PzaUXE?m^2-tfc%h(nD1GkM{Bk zf6sCpl#uxr-usGdwLp%Ija|OCvNOX)>F+G(dsgT1grp@D-4mv7W26%R#SQO7TsYt5 zP{cc4KjviOEt?-K=SOCCYH*eGsuLu4bUfo#m!M}!MHx_*8ui@B@1s?`S9v41>i;6@>&x(DydzXBq7SAGfJmG5V(tpi_09+a^N zNv5A|Y!A4WZQRqu{!!}K-R%L>{cUG04&3t6`x>Ot#USGJw^M6&gQ~~S?sRI2NbrUv zZ%Xo(ByUUdZ%N)kl3CM+c1S}TCev%%`gUvo?e_lLz5KT`{I~o2Z+V1CS^VY+m=Zgq zp6?-xef~pSH~{NfQxuof1ElmnOtqAvKy5&DFC8t|NoSv}5FLzhj^JV15tac@efue7 zp(C*EJATHGbN*qokRL(FZX`5DPw91gAfZ8Lg(X~9B>YeJ5{^RE)TlCD)B_0(Ix8$; zkx2M)_Y$TJD;M`bLW9lGgx z?yn5u1vHKoO96*~hU*>#v>!nP0c|M)+WK}`sTzfg7kew;b zy4U5o5pN^g8N?BR&i~U9VFQYM5oB>=i{ZlA$WA%7!ONiK>B$11@2fL<10v1uIf)RS zSq@7oF})o1iCKb33^Xf2EA?vEv*m9Ouj`%@JHW}@9=-sKG6SJ1FZvJV&@cN2vjTci zy@#5zNTn5;SMA>Us@>`CU7vB7iC0lnUD$d#s_K2RBtpIMS&!7n`>dzX4RsAAJ1p4bmFgFYD>lZ=7^h$}KC*v!i1yh98AVO+G z(>c0Uz3d;WRqx;S`42Mg=dZhT#+eP_WI5Z4uK`drmMnL8mR#d)~ZTN-Qlh-@) z6&qb*zG7o+AjRoXwzCz7nEs?O-`?HgbLiUD>s)IAg0PG>xHhsl2(5z)XO!&=FNW0G zn~6XOAGzSkp6FfLA7vXg2UD*h<`$_Ixh_fU`-)cE&}8VX-)L5b7QJ@vW0(&>v0bkl zw%T8*hH7VG&DO9^ezy4l6x*V1*!DuOkg2GC2~=}6jGnDmf05!;3{HmaXnhhpHEP`& zNGf`gi3ALeiCxR{@>Y8srj-QWGwAXq%qGw320I-H^C|d zZCW@UMKbx~0yF18uH_`v`M$27fGS)_Ga1zkwj!}LyfLC8@%jT@e~p4g^T`}VNBfav z!NIq4r^w2}cpMRWG$Xx80U*75`xsE>P`foQDt5J<$)+B?_H zk4B9jqKoG|wSK6nEQ?{(Ii7I**^VnGXV*zISo8H(y8|Md0-&xE98ca1bk3N!ZRO z--Sz!@)btn&(hQ*ap@J0BMJ61B^U)}YLN?ykP~x`C#XgfYEw@nSKX%*%uEwz1=USj z?+jtXO0D=ah*p!Gso~ByGu>Tjl}EO`rIGhZ1q^g1fj8%X!hrH`mZr8#BKam&myeNvgIhMOV>SD%+743+56@-jL)?B$-;jhPBG%C68v? zJ(VI^KHJWQR;RRhY8ITPd^ltUDHfZ0_e2-9VTpMsBCkYQA0_^@RBcKW~>}}lq zEy1BjkYaKb21hwuggoR&0A%W@`AW_K>Koq`pi2VnGTo4#56y(AHWT%c0kAr1ZK1$c^cB;zG><2yKwHTH@ z(@5b$pAN$(y&xx3FH^EZZH{(WmMN65Lf>q(+0LQ1!_|m`tf;E%cvqZ0%r;=KPi99& zHR-@2nNX$`s{^5ivH^u*1TcCqoNoaU3?mj`7%|TsL+p<{NYN@unQpeeuc~Fup zGV9LQHT5h3orA<-3#=2#WzX_KvmCTmTKak5Ia3|=WcTs%b8;5ee{^6f+>-sC#XcECXK8{L6N+rMLL z>oZuCd4fmFCczQ-p;mMxqv2vcE}S!L=QMeB=Qz4OHNU7CW^5=#tDWSOF;8ef`b_3} z0&(@t#B|j0t1R=`u$tcaT$_yph}4KyuDurJY0gN82Dl zdI%L#6mZ)+$#5>pGsj49IGU)5oC7k(jUGVyPI5XAsQ66cTpM*@SD^ZrpJO}cQ9HkY z7^8BmJlD4_qD)_HjDcrYwYeBb&IMeXO9;Q4+FXkAm8{K`Kt*jX^w;JB+qsBpb2TwW zTj$!i`w3h_DD-a6wYYH3G>t^79FNiS@P$e8WW5kZcWAqp*cB%d-3(z~LRWVahofvP ztjQ@St@J>in_o8$uHD(!{>k4BH};`^Ad~?ogv3s+67J6j zf)LnY;OS{974ZHTILqx)Ht7RY@5@Zx>8f-|LN=3t)*ke8mkFtXW=4a{+{WS!U0t_) zXgO4bY*wZA@Y<>=d_IQlL8@}rP`0-r`byT`n?O@b?Q(b$GQM`Apc1|0E6R563*P?rA^!6{eA4;e284UmyhsFD84 zN%~rL&wm3mb)CsJZ{ya|@;HbVrFa+VcYu!Szt=7Q>(H!AO42tn!;gsJ4JJb^RE8lb zbTIM%5Y-z9nN>t<5vA#yNZlU`5ii@t_yqaRO}76)Ql`KIw{GGza|S&x`0}0@pOOUH zrS(DDBB==HDdRIh%d{026}Q;Vjb=49G8@HZ*e+`d7k3D+JN;l=U@< z%2hRB4b|qW1rsPu-$5$cdU%!H9xr(3#VH#a3Pe|EHgrj+9KWsQf9DiZ11lnR$TBJ|O+1?L5V5ALS<|k{NZ;_<|bt z%{{mBV=GNC48yH|s``eag zI5Uj3GPYctWy{54%k5oT?m)JD8A~J;58KWo(us^io?$FKG-Us9Bg%M!@*-iRD7}Qu zHv!psnqrVYlGHA$J^6pGDMk(58rIF*6yIU<;rI~gU7UAhF>6OCnc%~20eX#{kjLHQ zL|iya@;A?}m0g;CkNTdS^P3NW3d_=en{WKM$q_>h%QN4{S*`D5njo>BcTpA$8Wx;H z77RHUMD$>>xk?Op7KUt}+GU@(L$;~NhIy+csUaZeD{in2xXygyjnn+YCpBaHnj!ZE zq<`!rXnO3l-wM$B#?E|djGw+?(v3jm=pyR)oLq4x^7zZpCR{i`>q zl|k{k$GzYa=xnEzPv*%pYSD-Iy6a0vxFXIY5q&ZVG0Z(#V))gM%<@P8g7Z;GNP?r0 zrhYQ(l7$!Mof}g>n;=GYwUOi*0r3kDrPEmr73jBE`5kSu=*V~FidBo2)NaT?5 z-d>eAYBldpkBqlEMV`VV-po(*MBc5%FwhN-$d=E0M>TbDT;S19wNpS)i+vaO?bLfF zbOz{k4YH=JXYxTSbSnqjGK=BaEWGzwGh8>9emfH@NgWdR=V$W;0C8YwKV*BH59Z27 zpus)K-=%P=rKU->2FZe^h0e{g5MFyI;wQWu8jpql7|?2Zr7feqsStE&$?zm`z?1!m z8qT2B>Aj0bLKUZfF(vl*6Y%d}*uPK7N7uI+c`6{BUm19zA6Wd_b0L!UG(W`OVVI6f z;5TeS{CbgUrhjD^J_{z89Cv;*jW6!PmLk96#+NMr)pmZTPWWuU(ejw}9HJSk2qv6g z2;n^3QZzh2AEM!q+DqMqj|==5u3U%(Ziv3n50T?RE6_WuwoPG7HKL1_Lsa*ehV&~x zI>`UrMz`{;(E&A_D8;2*mrzsF1%tL)=hDn{1@f$O zX|MnWZ0hN@yEYOt$Qs4uYB}p%2|n~ht#f^DJBb7o9wCL_M9Pm;d}TY!WJ%;^zrFO5 zh`~+^P255yT^G^dzzrq05M^&dgk_Y11cky|k)6lVvW%iNpn3k!SvqRycX^gxl`XB7 zQDEs+6a4VxHYk~FrIt~6)_FVfcp2pmTsQ@0bo39>(tXKO?#yqezguL|ZIO{bU?m`qh0nf*J$=ZpswGwJWkjIb>^FA)gQv~EB zxn(|&>&#jS_YFP&I9RQhlrZEAfb_4I2$~9jAphbD&>E1)tet?9lA~g!V*rzW35c8_ z>m}=uE53|8o)o--3kPUj2?;8tiHc&vd6hs*5%+Mtgsw{xsdXhRx&i79WOqpl-1QQTq8S*Vn|iAU z`ZZOf*jz8slyqGos?4bU>m?d=g$Wo;wV?j>lDA+2Hsrfx$o0({&*5qqG^Tp>A~PEW zwb_t*U4bBZVdg!*t%Vj_#r2sF00EEskO0?Bcr%3b2Dw7fe8%AKpL3S@F?7v^YS=&= z{vn@$K0Eyg2o4!P;lddxao{() z?!rj1q6*OW9qmpOq!l#C)8glFqF4vwUQ{ z#Sh3Q)6UEwZ)TG!OBm~C2D)$kjN!eRj=W>IlIv#%3%!2Eb#v((>u0|F?By`u`k4=M zrPt5aGY#t>nwd)Pe*LT$yvTqS=QA?=J{1fXDrfBN#}hE}sgMiN2N2H2?D?zsfyD{g z(zJ|`*@yyUae4^D7W!fT?nk>@@Y4SIXZEA3!UViKXZ@a<~LwHx}~g-SNr)P@^qi8`ymX68Ls?qO@dgDhK1>2U9Sje{pi3a^F&>uXYj^~ zK)zy%NLUfjMQKz`?N(sqYI-ZOA|TY%fH;SWk)bP)XGK8E6o5=wD*|zYicw6BHD^Vj z+*}b@C*hQn@rRLF*Mh>ahE|bqe0`somp-mdZ_e#^J-`9H2+5?>7N*> zQ$zee+z}DYfUK}-9j#C z{lC`?;FTp%5)bzV;KCVcdZ%c{8-CCdaw+Lp>rVPc-zw(%eu(9@t}*`B1r{liV+@9! z6=M^QG@uRrG z4RjY=XLjvs$(FvjDNavi$Vq_oFWCy3Ub3CM0<@|Vnca*f+iE7gD-bzm$&&3J0? zc@f;D$9>6s`(iE#?EUDvmgqF%ir3qlDa+T2M0~X-*p4=~A3I440D;(w1RtxIKA44| z)-Gpqhz-gFPB*gbX`oT!>-DG=@oPevnR-3a0M1&EG)g=&-h_Z#B!3ax=#30hkPqve z>U}-~-J2BB`+N-VjTC#d9%-=9>ycbHm%gzc>C5kSJ<p^}9F|*e? zX$o{OATXtEqR?~*LGQ`SgDqVz4{9CiZd;}%xHj&aMgM@+4rZ&Vmw#ZjgJnW_ z1e8q1P!mcXkIzFMPbiPXg)`fXbpD8*K7_13Kfj%1Lix9yctWYwu)NkaFROLUqX{MJ z`6y*7HKAlv9ZjYRIk@h@gz{uD;FXwA&QFvb=}st5K{m|0kV>87xJjOl>&%f|Od&Bl zJAt9j0F;0FC@6aRc;<5GoXB*}BB=Ss6mkK%+u6wF@F6qEqbctkUorVqRbI5r0WwBhVXfM{EGkt0v98hlsd@-Hp95CzYaYRNDZ#M7jQLLb`NiqctcDz zN|uqTL`Ux74cM$6-YD^?cwM0O&2B zx#|*V)_~5_!(Zx$5Dk0Pq8|P-f;fhI^^?2q)pcF9k)(gnCAt?jdi8w8q)qhdx+uRp zXnHHss|z)^SJ$*vudXw61@iRj8q5eRAWA1gOpX~M8^z>aIlcNBX52YC;haIe`pMLu zE{DR=s~?wej+b8j3croI=+&*^;O93vRBu&(Utz6vs&~ISnYhXSBKTk zmtOs9D4DFRdUcMG*C3C3^=onAoY{4APG3M)zb?O>q*wpjPTZ?&H7u`nU6$3lE~8$Z z^?bcDmFm^mR5y^RLJqD~uO8ZrqUTM>o)8Yc5-$n_gS~^n;7jp9TYGC=^~|cahPict z`N2RKhff6q?ZM!S@xZLQ*0zS`rojBL%I;hPZ^i|KFT?|lb+hUkeelmSshI|FKLGa* z#loS8wO$|`42QxyeN=(?Uu7^}LyZpHz=sxFQPX4cIdpQD1;n*$`7jm{ zMtgm8tuObre0qGf3q1xy|3(R^H^?UHT!(BCdOsd$hMgL#A);4Qj4f+}p?4roYjq2; z6qNRO=-v3t1FBrR9v%zCB7x5FAoN~5*gLHM#lqnM7G5+AhQlQmoCawzc6tql!l9&9 zz(y>xdeMD&ZDrK8RN7yqYpQe&q-2!U)qOv8zna_!ds(iL5>}wLp{9L&UDJ&A`oR2< za=MOS(3TSTVs$ImQ@pe@$nI!an6QRsD`&s5d|jJ&6hnt!zC7Lw$i+ zH>cfzO|ni`wF1?%svF??2Gu?+fRP17M(96$e-l;hGNk0=gH*K#qS_($%~Y4-JGs)5 zi9mHzMP(?cNJ}2vC6!@TptTM)@w@=|n=7d*R9dd+r9ESeumbgU)$muZ?N_j}hj+mT zM8_&(V^lg?rCTZDqr58r(+W)ECgKrqC+!ADT7j0jrrL(483x}DF503?zTruV&o1Jz zp`FEJLlc$9?xe~msC2xNXM3-*+ggEH)r}qg0Jx1Sq!ARi?m~)SXdFcEFtr>E?EqlI zfymj|cy+=*T#J-iMvandn!2w>O0F_hMcX>dgxPf}y>v!1Ru$ng9+!P_bwV*G)NRvy!t($=T@HeP1guvwBWdO?`C( z+NGh_1~j*Zn!2h+)%J~|dckR|p6d_7GpxXj=H}XbDAT*F;mq6`!f{Vj0-qph_;{-y z876X^+((WT$BG;yjukmt94m5^Dxa^)k5uLJRQVCA{BTA0FqL*%t8wT&RHcVV8amMG z%Z8t8t;*>E0w0pz?ncu_C{! z^cP9PKdbwn)cubt{XwPQtMofbL*F2!X8*NHm#OqCq}1%cM2b;Tc&VhJFVy|#l14sJ z>BlPnKaz$%QuiOK@()z{K2q?Dy(jmvcjZ3%jw=5*ychf;Z!7P8OT0I{M9M>pB@Mr> z;1{X%HKauMRk@G7BKOgkRryPb?u&}<3ySWuQXYCn((u0&{L?CZ3MtWjQto3<$bIy2 zRsI+TASjPKssVy<@(A+4r&Dar}z}Be$s@1O%&Rpf}T_p2)2-La0OE z;N^lahCRW^!)X6?=)}ze;;4$B%PtN^p64#u=w?{PxW;)S7w63`acKM{b&`=7>K+V# z3kq%R=p{9m&RwbFiZC=`5KbJwgysK-QCGNFB0;!FrR%EnACiXFMoN}lOWpUEG`NQC z4srY0T@6*&q>}3P4(Qk$sIke|aOkAAQp86o;zLzB2r0SOMsgqAz+<*PNOC7(45nyK z77Ui!f!ew@9^I;dEOWJBXhXZp>BK-FWshfqAqPydb4hMUyql76SCvjy=_HlzB580U zB$lD@jv&VKP-E;r!46F8m~K>o2jao;q_4b#{+;cd=uhGVr+|(0PI~~?ASj&?1U^g& zb|{Xkpon;g+=mZV>4C_HeZzBYnHn8n%hYHN!DA{k8*o%UOVQ~79L;yz0Y_<@z=c{> zd5fgMYEJ=GcA%!CwQ6Q{dyRhvv`;>fgQ4kA4h%_yAj5Bhp=qE)gDh`!j*voC@G@fn+eWpB-pvt(#@^?=p{U)(AfMI;CjOUxT3<0X0a-v}q>tvCh!M z^9eO(l#*H-Lqe{tH+z+WdQfke*#IXsWS?QnI8mV(oEz=H?3vYV`x)Tee9($x;m94L z>F{kTy+zWw%5QE(JTz2%92Ds`La`L)&3H`&^J@=^<0C~&iJ1uam$89O5CqX+_y#-B z&}7=MBpAMqecb3ZN+{GKynd`I{hm_BJL-Okq_M>+|7CUmqPl-drB6y4eO#rFA?1OB z+=m~55z!384~r2)4@!RUJ}6U`iSDuUbijA#*YE@6xO1uyv|9}y#o+mVDVWyST(h5A zR&y0sqFhpUG}PTlXN6zrpnpOJseL7ltg7w{B#kCienh1ql^>Ke_PaP->^E_k*stO+ z(O;A#eo*({$$j)&m42i0zn1&(GNrSxL}$UzJzag8PgkGh*VR&lsq7I+F!Y5T zsIP9Tuab2JS4SAEvs=+%f%O!O{Um|Lh*hzl(HS+M2b)J|_#Y_do|}+j!B{vEsHrhx z73KQWJXzEg+EJ--g1X;UrCY1~v64o|sC1;t-&~~?lE%ta`7m`qMBNWga8D84B*8sJ zbmIi~6p;;44%du23T_}$G?&N*DqUaYm#TCCQgY=Ixepg7#Fdi?jz__D60QrcoygIa(={5Hs2Iv`%(d6dTzj#dnzL<@-MB6jJ%lchG;+SWKU31^87lu|Nn;CC z{)sC81WCikD?J{k^mw$V$NBm6cw~M(9+O8mS_8r8N!?ecS0KUb(1Ad~A*-(*eapVP z@ztZpU3&dp;|EWkvJqZ+57bmtcAy2cRkqYOG&ZzUVr0EvdviNr@A4$4KYCiItSb%3^hy`kcB~^{D&Q?dsR+ZuPOaS#giV&5e6JZj?D% zjf3N>XDz9U7nbf^n@hgxH9G>=9WTNlk=c; z2Cu}^IFy%uDKV$8sC9mU$TQ*7EZ;~{za(f1ibS3npJusFm>&VY2pTL?GGUpEH1+ez zn<{8C}9L>&FdYE34la{N{50h%F>lix){*hUyH7X6xGA1c+#zh_80Rm z8Iq4qS3ZkOHc9GB?HQ7fPQL*x8ipvJ{UZ!Sxb)HKH-V*pLz~aGz6_myBUri~0$uC#$EG(eey zCtOWVNlePRvv<~*!s4u)l*HVkqImT>wBanDHZd<3drQuI2`ujrlgbcnQt6{lDuczO zk~u7EcuB9kA=;$E8N->Jn3Cwq$|=oBO-am=oc+r>C3Q`coVg`sl5=FCvNeVTgjMlXeig4Su?>ovCB|W zS}JDBbj*qqCYDRr%`qR}oFdZ)NlL*`iI&`(mPu=H6?j=c?E66J! z1&UGS*<*_EbJQHf+0LDUX=sUxi&rptNs(itu*#yy5eRZFxZ&5PMrQ@xQqo0-Vl~g* zS{@r^24!%>d2r58;c`l8;nY#(g%k4dTiIk5%sZgcGpzJ+Bt90S0q1}ylN5niK88AF zlPa?D1Nk9^|0X1NM^t*2mA=G<`(MaPMJ4&XRgS>KEuzy$-Y8#7X3##zN?+h9 zcaO%j=zdWe5M?%6&p9kM;7L+ChVC69l$%!uTEMgUo9JI zy}(*)SZk%BR;V;Fs3M~TyQ@-ss8kYEF|fE?k}6D+NofskUhP{Yi^VNLN$xnw-3i<* zQm8a3sMoaeynIPgL#1MIEiR`8P1kN5Sn?);6>bvt1x*(B(@Dw{Vu$RAzY(_$4St5$ zWbXup`1tv86N#Ny=A0$I{8a8TV#?eT5yV%vo}5N(arW>>#JSa#ONi|=HU|@T&RF*V zQE_hljQB+J-3y7iQCpf5z25eH22{Db&m&s`4_@2@(3Bk{{KA50()-Bfj+`1{$1 zW)bgPTGWX6+g0OpiPJBR`GNS=zPw)(GqdFDiPc5c9AZxQ$Zv@k!fo@3e^86N5$}sC z%pjiWIr=cMbW*_z;=wcKn~43ZEVmMWm>ph89KR`KCGp!;n>rJVmagwbJhE^531W|n zJKiLIQgkeZSdn$AFL8hPk(0!`yB~am_-0bIotQ3tIF#rfdh`#(nCt_)iJQ)Ej3c(% zyWvjaGf!>XPmEl-b1QM#R#O7eHaBP#aeZ~z?})9>hOQ$%GNYs;@w$w$cM;!cp8Ynl zyEA_?abeGslZnu5tkI@K0%bTay})VA3AI*<{yk9 z4s;%GO#H`;L-UAv8CBmA@5)|3nE2=Kn2T$S%3zIZ14&%}s}AKph?y06+nj9+?S zEpg+jqrWHK(0#+*#F^n66N%ljc5Wg5rfA!5iR!Gae))|AQ@h>h(hEW}wcC(DS@p*f!rAMTd>B=P2P6T*qBMvj|K4Ba1bhWNsz;KjtY zYork3x@F4!#6F87|4yuY+4cx=>^Zpw@y9*ZLgKw6#{7%;UO}FlI4P~D3Gp-Q_+sMZ zrd2-@KWcyIQR2wy$D@dU8uUQ{vE-EJBJtwayA}|8@7i($@$iDRqlurteB=o6fyD=3 zBJSOD%tgHY+^J0BHwD`d5(`G`c$N5pb<-`xThrDLARccYevFvWG~_MfKL?r9h@+=l zdJ^CHdh{vc9j6Lb5x-tgoJ^dytFRw&-iGY=h&Rs4-$7hnS<;4>c6#jX#HXf&{fTJq zAG)3Bi7~|!JKBTpAnxk6?OkF*=+5=TMI$%1CtAjB$RfUW>F6F}^8N#xh>tC+?m%q5 z=EHl4Yxm?nN3@^I`HJ}b%i}7DA&V!Nh_73NpC{gu7V#xe zCl;<5^KaszOXIVNefJl|5T~9FSx)?0W%yCz@L87IhxWM`F_A4a119zPzzDF(~c8HsWII(f5gt5g!gG?k=cqMNFKYzk#@QQ1)J; zsp;5ziBGmKX-Dj`D|93Ar3GQ{5SyL~8cCf0waKYO-s8>?F9LiS2&8}p0vZTtAfSPO z1_BxgXds}0fChev1~N@qa9ffxQ^WJ4o7oySinoULkwZhxkx{X-EJeH$-Mm-dh!~p` znQ0molxfPwA5f0h>cwOVucwxoCRrgD%?D~L1juaZwnQzLGFA7FSHxU6PwhrU_#JMv z_S4Tc*ozFiNx@mft5uw}fX{R@8gjpjd^lg>`YK$i4`{6wS^GJI6{k&cDvI9hL6mrG z%ADRaReI>bX*vvts^PHZp7=-)r39aV#1W?06~&_{$Yn8>$uC_BM<||n`oNwcMTFuB zMzJ_|%GSyisW7n9Ur>UI=$PP+k7%(ND1z1qZo=2sZew}0+?jGD`2u5yvyvN|b&?45 zFOF?XdbQW9K-qqX8`$qCHWMraMQxTIxp znvp|YcJ^S1R@>78bK(ldIggLkXSt!|VOQ)e1#3A*&%T`%T8R0}g86HOjWgmfWa6f^ zRvc}}bU40x;@P&)L>%+(Ac@I=>#NYjJzxS&T!bbP6lYtnCbE!?ChlXYy}efzh{~GY zL2)=0Jqyz0PkRMd)PfrCN~Cb3P}9>^sK8gK#an{baT061YtXGgCF#-arMpydN# zoCf1HC~aZnJNoWXD)UN_=Wr?ZE}9BK?hQJHe}PH|)x#j3i!W{!waX;*78fLH>jVt`A^inUipqdFP$4x@MS#>JZ z$M#`R)#w=y*e%rQY}W0l_>Uu@ca9mKT;6WNfkATIqS%u)J;vY`P~=Dbc;mID2YLS* zx#>6aYCfy=P=3Bw3;Y;C$eyhJIC6hNNWHh(pa%Iuw$`(bkc*KG$NKI{jTR)e>rIM7 zi1@VDh9`-4)jP>7L1yhyxRh*64vfgFm?>Ta6Fe$wFjMqVoV^uiFYlwWoN`D!Ul~ue zg->-KJ{ve(KHAfpvWaK8m-i||Okw?~rI$3paD5emy`~9vE1uzjigSSC?C%w9RUN?w z`UD%`701)xd!-4MLBU?v1jDs1nD(~58rg_gV1_3@T>(Wnfu;&9f#6PYqoN3GqG+D! zv3eMQNJaBdk5GhhtSL+n2M`J-nx6@bqjd*C&HV)qif~f%cQes^%h3dO#<91qJEO;k z>t2gyyWUzGy|va_YjT_}sx0I1g2{Qty0VO84PcBw`%T^NCLY`D;n)?4hi`v{!NeYx z;;;r!)Oeen8gFw4#YPKuxgFZjTv-z8V<^jQ!A`SWsM}O~g8Bc)4WJ*&cgk%7H-9p)ffaawo zQ^;O(YM?1TeDvWL)X#Ur`qU$9?|NkIRgbJ-l;LAEupUMO>S5HsK1SD;#iek5b?SO`qZ;FGiM#MWwBn>mp?@+O6Vg1#EYqCO zKM5K?D^8jc`X@o-XT?b~LjNRa{H!=>Lg=3ajh_`K%?JGx9(P)CcJZ^<{5dPmw4^kb zD$-9|aXxuNjTPrabOAR+q=s5?HiOEq#ESChM`z8mu^Jn7NjAvWDcNGgxt! zfN zTpDaS8)4{Nu`OrAZ6q&mcX@9^jU;I*`ro#@^eQ$7W|Fsl*S2r>gaZakQqIU#-Vk%NdRjE;F_m8)cE-hH)d#H1)R9tE7T%oVw{HjSUyF&Jot3 zg?#g|Q8MfWiw%~B6TFs&kO7Xz`9+!!Ho_R8jtUM>fJ3M>Cn&oJPIIF~Y!S&FhJsM( zv7r3YygYAS6!I)(Rxgu*@GXR$CI6#?Q!EM>2~P8Z3X9A0N{h3L=${9NZ^@k?xXp*T zB7I^Q@CunNL}o?MfB{@?zB30Se@Ign$1GNt!~&8FHqS0A*0Mz?Z0s#mU=zWvmxpOAwu8lTo40aX zy->4DsoZAdRx-F*|k=`(y^(6JJRsIi{2QeM=?qdTb)%_=OL@JQXisyFnBdx z*>zoAx?_%1?m5gMh^u%{l^CzMoT+*aiLr(26*f<$7=*Z9Zo_^ChRiVxnZ6Jd*lWO=(* zWXM;M&-MRzz)t*J*B13%(o2$C``Ip=_F8KNCKaps#~?U&ie&k)R}|5tVXL9aTVQBV zlkw2yWvsl6j9B+S>1(pu%h|t4>{?x0i~1%ljKnInC71SRAy~u;go&7mh5gz=A{Zj# z8TDC&iKqz@u~L0iU4;dI1_S>eF8Fix**}Q|cE7L+Xj2ek!c(<<{{H>-`xBh>>tPI>UPZb7-@?g|XH8*ZWt2 zBog{CrfYetN|Jlw!5UhNM=Zn(mrLWZCf-h0Ijgf-o^ z4}U14`M~cMzPBwtamg(ac~(g;_buNua)MjM-y*S5@R14e1*C`zKEnEg8O&sjg^Vsh z1G~uxWgtbYu2aX?2*VgW#3~W7_>eIML>Pk$*jK>*zAlotrCNauX0hIDtaqEC-em$A zTqa5ZyB2Uugc1TNpn-q}0vZTtAfSPO1_BxgXrN&l_^-Gn+8VOR-WRKac~})RDNb2& zO1jx~zf8G*raZ_Vq2 zrO;I%6J#D)@%a~`O6_CcaRfRm522XxNE0jIH&k?TqJHj_A4cc%;Fn1LCVV5aP9WO_{2cv6uDI1;~;R^gJGvzULbVFaT zoO*PV3okKaryFT1%hMRt-{XAtxDY;Bj_VBlaj(U1vR1BWN!Z?|f? zr4N$6qf+E(MDhuA$uX+$a(CUo%fo|e)sq`okIU8djlo6#*7gK9J+uWaQi0%S&f_P%<%$0#Tp?4TXH>v%XHCGa9#puyuBECSG7 zT=yEL7ddDc>em+#L%bOZ=kBMG4cBkoS6sZ2HbPCz!|o+0vTLsBJ)@1rB<`gwiB~+$ zeQ&bH7jE}6EN-QETJs%S^Cq|GFXQfKwKB}9<$7b9L-2DtOL((uZ}QqZypK+7?8{~` zL?GMqdJ{egj4%FliLd)}KyVOknl#CL%w7O9O-x^Ntz2yt-8ElS(O>A@%RuUAtJI-R zsF(UhQYR>$R$h7BrxA<3mCK<(J)$js_wrs&YKM_p`*qRIM{W3V;C_kJ?Q}_MTJZir z5I1)PXfXP&&U62DFu~|sjnU^+oE;Qrd++F5jS`GXgFmj*=l0rxT^9bhaM{qYG@d*ZZdR;K#&P)+C!8%j04VqxMHkypM zHzIqm+1yO`|7@!Je>Ty-$7PBnyrt9?jkve^Z&L>>w z6RP{6hUn$NI@fbazv@_R96U_99@n*n6s>g>$cLvI>_| zubU_Wmj(&fT;Z)+<2ovwN5wfs+9^es`_#^B1Z^6-X?eq>gbWG5(t&VLp6yC*} z4>P=r(NTZLTDTXBF8RCGHrI1&JJ)JH$0Aqnm~3hdH`zRcA2Ryis!so5^U~4h>*}mW zjt=$80mow@oxdDl*4f7_r5YB~aaKk^