; Listing generated by Microsoft (R) Optimizing Compiler Version 16.00.30319.01 

	TITLE	D:\_KAZE_new-stuff\_KAZE_Simplicius_Simplicissimus_Septupleton_r2-_strstr_SHORT-SHOWDOWN_r7\Simplicius_Simplicissimus_Septupleton.c
	.686P
	.XMM
	include listing.inc
	.model	flat

INCLUDELIB LIBCMT
INCLUDELIB OLDNAMES

PUBLIC	_TotalRoughSearchTime
PUBLIC	_TotalRoughSearchTime2
PUBLIC	_Railgunhits
_DATA	SEGMENT
COMM	_clocks2:DWORD
COMM	_Patternlen:DWORD
COMM	_clocks4:DWORD
COMM	_clocks1:DWORD
COMM	_clocks3:DWORD
_DATA	ENDS
_BSS	SEGMENT
_TotalRoughSearchTime DQ 01H DUP (?)
_TotalRoughSearchTime2 DQ 01H DUP (?)
_Railgunhits DD	01H DUP (?)
_BSS	ENDS
_DATA	SEGMENT
$SG5244	DB	'rb', 00H
	ORG $+1
$SG5245	DB	'Leprechaun: Can''t open file %s ', 0aH, 00H
	ORG $+3
$SG5250	DB	'Allocated memory for words in MB: %lu', 0aH, 00H
	ORG $+1
$SG5252	DB	'Leprechaun: Can''t read file %s ', 0aH, 00H
	ORG $+3
$SG5263	DB	'Leprechaun: Needed memory allocation denied!', 0aH, 00H
	ORG $+2
$SG5265	DB	'Allocated memory for pointers-to-words in MB: %lu', 0aH, 00H
	ORG $+1
$SG5928	DB	'an', 00H, 00H
$SG5929	DB	'an', 00H, 00H
$SG5930	DB	'to', 00H, 00H
$SG5931	DB	'to', 00H, 00H
$SG5932	DB	'TDK', 00H, 00H
	ORG $+3
$SG5933	DB	'TDK', 00H, 00H
	ORG $+3
$SG5934	DB	'the', 00H, 00H
	ORG $+3
$SG5935	DB	'the', 00H, 00H
	ORG $+3
$SG5936	DB	'fast', 00H, 00H
	ORG $+2
$SG5937	DB	'fast', 00H, 00H
	ORG $+2
$SG5938	DB	'easy', 00H, 00H
	ORG $+2
$SG5939	DB	'easy', 00H, 00H
	ORG $+2
$SG5940	DB	'grmbl', 00H, 00H
	ORG $+1
$SG5941	DB	'grmbl', 00H, 00H
	ORG $+1
$SG5942	DB	'email', 00H, 00H
	ORG $+1
$SG5943	DB	'email', 00H, 00H
	ORG $+1
$SG5944	DB	'pasting', 00H, 00H
	ORG $+3
$SG5945	DB	'pasting', 00H, 00H
	ORG $+3
$SG5946	DB	'amazing', 00H, 00H
	ORG $+3
$SG5947	DB	'amazing', 00H, 00H
	ORG $+3
$SG5948	DB	'underdog', 00H, 00H
	ORG $+2
$SG5949	DB	'underdog', 00H, 00H
	ORG $+2
$SG5950	DB	'superdog', 00H, 00H
	ORG $+2
$SG5951	DB	'superdog', 00H, 00H
	ORG $+2
$SG5952	DB	'participants', 00H, 00H
	ORG $+2
$SG5953	DB	'participants', 00H, 00H
	ORG $+2
$SG5954	DB	'skillessness', 00H, 00H
	ORG $+2
$SG5955	DB	'skillessness', 00H, 00H
	ORG $+2
$SG5956	DB	'I should have known', 00H, 00H
	ORG $+3
$SG5957	DB	'I should have known', 00H, 00H
	ORG $+3
$SG5958	DB	'human consciousness', 00H, 00H
	ORG $+3
$SG5959	DB	'human consciousness', 00H, 00H
	ORG $+3
$SG5965	DB	'BB---.txt', 00H
	ORG $+2
$SG6007	DB	'       $LL74@main:', 0aH, 00H
$SG5985	DB	'Simplicius_Simplicissimus_Septupleton rev.2-, written by'
	DB	' Kaze.', 0aH, 00H
$SG5986	DB	'Note1: This is the precursor of Simplicius Simplicissimu'
	DB	's - a superfast-low-performance TEXT decompressor.', 0aH, 00H
$SG6008	DB	'       a1 00 00 00 00   mov     eax, DWORD PTR _Patternl'
	DB	'en', 0aH, 00H
$SG5987	DB	'Note2: The niftiness lies in readiness for multi-threadi'
	DB	'ng and mostly in boosting the search by having the BBs.', 0aH
	DB	00H
	ORG $+3
$SG6009	DB	'       03 c2            add     eax, edx', 0aH, 00H
	ORG $+2
$SG5988	DB	'       The decompressor would upload (at burst speed) th'
	DB	'e BB data and then read-and-decode one-by-one the', 0aH, 00H
	ORG $+1
$SG6010	DB	'       8b 04 30         mov     eax, DWORD PTR [eax+esi]'
	DB	0aH, 00H
	ORG $+2
$SG5989	DB	'       triads (BB pool/array indexes), that is a simple '
	DB	'copying. The pool houses up to 256*256*256 BBs/elements.', 0aH
	DB	00H
	ORG $+2
$SG6011	DB	'       25 ff ff ff 00   and     eax, 16777215', 0aH, 00H
	ORG $+1
$SG6012	DB	'       0f af c7         imul    eax, edi', 0aH, 00H
	ORG $+2
$SG5990	DB	'Note3: Compiler used: Intel(R) C++ Compiler XE for appli'
	DB	'cations running on IA-32, Version 12.0.4.196 Build 20110427.', 0aH
	DB	00H
	ORG $+2
$SG5991	DB	'Note4: Compile line: icl /Ox /TcBuilding-Blocks_DUMPER.c'
	DB	' /FaBuilding-Blocks_DUMPER /w /FAcs', 0aH, 00H
	ORG $+3
$SG5992	DB	'Note5: Maximum size of input text file is arbitrary - 38'
	DB	'4MB, in fact 384MB+4*384MB must be less than 19??MB.', 0aH, 00H
	ORG $+2
$SG5993	DB	'Note6: The file format is given by typing the compressed'
	DB	' file e.g. D:\>type OSHO.TXT.SS.', 0aH, 00H
	ORG $+2
$SG6013	DB	'       8b 1c 30         mov     ebx, DWORD PTR [eax+esi]'
	DB	0aH, 00H
	ORG $+2
$SG5994	DB	'       The header is 270 bytes long followed by BBs and '
	DB	'triads/indexes and the eventual remainder/literals.', 0aH, 00H
	ORG $+3
$SG5995	DB	'Note7: My benchmark text file OSHO.TXT 206,908,949 bytes'
	DB	' where OSHO.TXT.SS 116,871,584 bytes for order 6:', 0aH, 00H
	ORG $+1
$SG6015	DB	'       8b 44 30 04      mov     eax, DWORD PTR [eax+esi+'
	DB	'4]', 0aH, 00H
$SG5996	DB	'       Decompressing OSHO.TXT.SS to RAM without Dumping '
	DB	'to DRIVE time: 1704 clocks or 118579 KB/s, an awful result.', 0aH
	DB	00H
	ORG $+3
$SG5997	DB	'       For order 4 enforced: 156,174,067 OSHO.TXT.SS is '
	DB	'being decompressed at 192804 KB/s.', 0aH, 00H
$SG6018	DB	'       03 cf            add     ecx, edi', 0aH, 00H
	ORG $+2
$SG5998	DB	'       For order 7 enforced: 122,297,608 OSHO.TXT.SS is '
	DB	'being decompressed at 85618 KB/s.', 0aH, 00H
	ORG $+1
$SG6016	DB	'       89 41 04         mov     DWORD PTR [ecx+4], eax', 0aH
	DB	00H
$SG6019	DB	'       ff 4c 24 1c      dec     DWORD PTR tv977[esp+376]'
	DB	0aH, 00H
	ORG $+2
$SG5999	DB	'       For order 8 enforced: 149,243,106 OSHO.TXT.SS is '
	DB	'being decompressed at 115396 KB/s.', 0aH, 00H
$SG6020	DB	'       75 d7            jne     SHORT $LL74@main', 0aH, 00H
	ORG $+2
$SG6000	DB	'       Obviously the fastest cache size is crucial, for '
	DB	'OSHO.TXT 12MB BB pool vs 1MB L2 cache disbalance is the', 0aH
	DB	00H
	ORG $+3
$SG6014	DB	'       89 19            mov     DWORD PTR [ecx], ebx', 0aH
	DB	00H
	ORG $+2
$SG6017	DB	'       83 c2 03         add     edx, 3', 0aH, 00H
$SG6028	DB	'Example1: Building-Blocks_DUMPER The_Little_Match_Girl.t'
	DB	'xt', 0aH, 00H
$SG6001	DB	'       cause for this badly inferior performance compare'
	DB	'd to LZ L1 (32KB) cache-friendly variants.', 0aH, 00H
$SG6033	DB	'rb', 00H
	ORG $+1
$SG6002	DB	'       The test machine is Toshiba Satellite with Intel '
	DB	'Merom 2166MHz, with rough ''memcpy'' performance: 1646 MB/s.', 0aH
	DB	00H
$SG6039	DB	'Building-Blocks_DUMPER: Needed memory allocation denied!'
	DB	0aH, 00H
	ORG $+2
$SG6003	DB	'Note8: Compile line: cl /Ox /TcBuilding-Blocks_DUMPER.c '
	DB	'/FaBuilding-Blocks_DUMPER /w /FAcs', 0aH, 00H
$SG6040	DB	'OK', 0aH, 00H
$SG6004	DB	'Note9: Major (but still inferior) decompressing tweak si'
	DB	'nce r.1+++, this time Microsoft v16 excels:', 0aH, 00H
	ORG $+3
$SG6005	DB	'       For order 7 enforced: 122,297,608 OSHO.TXT.SS is '
	DB	'being decompressed at 170083 KB/s.', 0aH, 00H
$SG6045	DB	0aH, 'Simplicius Simplicissimus is decompressing %s ...', 0aH
	DB	00H
$SG6006	DB	'NoteA: Simplicius_Simplicissimus stands up for his name,'
	DB	' the decompressing fragment is 13 instructions small:', 0aH, 00H
	ORG $+1
$SG6021	DB	'NoteB: For more fast decompressing idea(s) you may conta'
	DB	'ct me at sanmayce@sanmayce.com freely.', 0aH, 00H
$SG6022	DB	'NoteC: Got it? The B note has two meanings: 1] for faste'
	DB	'r 2] for additional/other fast.', 0aH, 00H
	ORG $+3
$SG6025	DB	'NoteF: A stupid bug (one triad was missing) was crushed '
	DB	'also.', 0aH, 00H
	ORG $+1
$SG6048	DB	'wb', 00H
	ORG $+1
$SG6023	DB	'NoteD: Got it? The C note has two meanings: 1] for quick'
	DB	'er/tighter 2] for additional/other quick/tight.', 0aH, 00H
	ORG $+3
$SG6029	DB	'Example2: Building-Blocks_DUMPER The_Little_Match_Girl.t'
	DB	'xt.SS', 0aH, 00H
	ORG $+1
$SG6054	DB	'Building-Blocks_DUMPER: Needed memory allocation denied!'
	DB	0aH, 00H
	ORG $+2
$SG6024	DB	'NoteE: Since r.2- a new Quicksort function is in use due'
	DB	' to the bugginess of the old.', 0aH, 00H
	ORG $+1
$SG6027	DB	0aH, 'Usage: Building-Blocks_DUMPER textfilename', 0aH, 00H
	ORG $+3
$SG6030	DB	'Note: When the extension is not .SS then compression is '
	DB	'commenced otherwise decompression.', 0aH, 00H
$SG6034	DB	'Building-Blocks_DUMPER: Can''t open file %s ', 0aH, 00H
	ORG $+3
$SG6035	DB	0aH, 'Allocating 384MB ... ', 00H
	ORG $+1
$SG6049	DB	'Building-Blocks_DUMPER: Can''t open file %s ', 0aH, 00H
	ORG $+3
$SG6055	DB	'OK', 0aH, 00H
$SG6050	DB	'Allocating 256MB for BBs pool + 384MB for RAM-to-RAM dec'
	DB	'ompression ... ', 00H
$SG6059	DB	'BBs order: %lu', 0aH, 'Original file size: %lu', 0aH, 'B'
	DB	'Bs pool size: %lu', 0aH, 00H
	ORG $+1
$SG6111	DB	'Total time: %lu clocks', 0aH, 00H
$SG6117	DB	'Simplicius says for ''memcpy'' performance: %lu MB/s', 0aH
	DB	00H
$SG6106	DB	0aH, 'Decompression to RAM without Dumping to DRIVE time:'
	DB	' %lu clocks', 0aH, 00H
	ORG $+3
$SG6120	DB	'Simplicius says for Decompression Ratio: %lu%%', 0aH, 00H
$SG6123	DB	0aH, 'Enforcing BB order 7 ...', 0aH, 00H
	ORG $+1
$SG6109	DB	'Decompression to RAM without Dumping to DRIVE performanc'
	DB	'e: %lu KB/s or %lu MB/s', 0aH, 00H
	ORG $+3
$SG6124	DB	'Size of incoming file or Strnglen: %d', 0aH, 00H
	ORG $+1
$SG6133	DB	'Building-Blocks_DUMPER: Needed memory allocation denied!'
	DB	0aH, 00H
	ORG $+2
$SG6112	DB	0aH, 'Benchmarking ''memcpy'' by copying 197MB (OSHO.TXT '
	DB	'size) ten times ...', 0aH, 00H
	ORG $+1
$SG6122	DB	'Building-Blocks_DUMPER: File cannot be loaded, it exceed'
	DB	's 384MB limit.', 0aH, 00H
$SG6128	DB	0aH, 'Sorting %lu Pointers to Building-Blocks %lu chars i'
	DB	'n size ...', 0aH, 00H
$SG6135	DB	'Allocated memory for pointers-to-words in MB: %lu', 0aH, 00H
	ORG $+1
$SG6141	DB	'wb+', 00H
$SG6142	DB	'Building-Blocks_DUMPER: Can''t create file %s', 0aH, 00H
	ORG $+2
$SG6143	DB	'Writing Sorted Building-Blocks to %s ...', 0aH, 00H
	ORG $+2
$SG6151	DB	'%c', 00H
	ORG $+1
$SG6152	DB	0aH, 00H
	ORG $+2
$SG6157	DB	'%c', 00H
	ORG $+1
$SG6166	DB	'%c', 00H
	ORG $+1
$SG6171	DB	'%c', 00H
	ORG $+1
$SG6172	DB	'Patternlen:%d|%d-%d+1|linecounterRL:%d|%d', 0aH, 00H
	ORG $+1
$SG6179	DB	0aH, 'Maximum compression (or minimum expansion) for orde'
	DB	'r: %lu', 0aH, 00H
$SG6174	DB	0aH, 'Building-Blocks_DUMPER: Overflow! BBs exceed the 16'
	DB	',777,216 limit.', 0aH, 00H
	ORG $+3
$SG6175	DB	'Gain(reduced-size) or Strnglen-(Patternlen*linecounterRL'
	DB	'+3*(Strnglen/Patternlen)+(Strnglen%%Patternlen)): %d', 0aH, 00H
	ORG $+2
$SG6184	DB	'Building-Blocks_DUMPER: Can''t allocate memory.', 0aH, 00H
$SG6185	DB	'.SS', 00H
$SG6186	DB	0aH, 'Creating %s ...', 0aH, 00H
	ORG $+2
$SG6189	DB	'wb', 00H
	ORG $+1
$SG6190	DB	'Building-Blocks_DUMPER: Can''t open file %s ', 0aH, 00H
	ORG $+3
$SG6191	DB	'[Simplicius_Simplicissimus_revision_1]', 0aH, 00H
$SG6195	DB	'rb', 00H
	ORG $+1
$SG6192	DB	'The file format after the ASCII code 026: ', 0aH, '1 byt'
	DB	'e for BB_Order, ', 0aH, '4bytes for Original_Size, ', 0aH, '4'
	DB	'bytes for BB length, ', 0aH, 'BB itself, ', 0aH, '3*(Original'
	DB	'_Size/BB_Order) bytes of indexes followed by the (Original_Si'
	DB	'ze%%BB_Order) bytes of literals.%c', 00H
	ORG $+2
$SG6196	DB	'Building-Blocks_DUMPER: Can''t upload file %s', 0aH, 00H
	ORG $+2
$SG6200	DB	'Building-Blocks_DUMPER: Needed memory allocation denied!'
	DB	0aH, 00H
	ORG $+2
$SG6202	DB	'Building-Blocks_DUMPER: File cannot be loaded, it exceed'
	DB	's 768MB limit.', 0aH, 00H
$SG6258	DB	0aH, 'Building-Blocks_DUMPER .SS dumping time: %lu clocks'
	DB	0aH, 00H
	ORG $+2
$SG6260	DB	'Building-Blocks_DUMPER total time: %lu clocks', 0aH, 00H
_DATA	ENDS
PUBLIC	_scmp
; Function compile flags: /Ogtpy
; File d:\_kaze_new-stuff\_kaze_simplicius_simplicissimus_septupleton_r2-_strstr_short-showdown_r7\simplicius_simplicissimus_septupleton.c
_TEXT	SEGMENT
_s1$ = 8						; size = 4
_s2$ = 12						; size = 4
_scmp	PROC

; 463  :     while( *s1 != '\0' && *s1 == *s2 )

  00000	8b 4c 24 04	 mov	 ecx, DWORD PTR _s1$[esp-4]
  00004	8a 01		 mov	 al, BYTE PTR [ecx]
  00006	8b 54 24 08	 mov	 edx, DWORD PTR _s2$[esp-4]
  0000a	84 c0		 test	 al, al
  0000c	74 0f		 je	 SHORT $LN1@scmp
  0000e	8b ff		 npad	 2
$LL2@scmp:
  00010	3a 02		 cmp	 al, BYTE PTR [edx]
  00012	75 09		 jne	 SHORT $LN1@scmp
  00014	8a 41 01	 mov	 al, BYTE PTR [ecx+1]

; 464  :     {
; 465  :         s1++;

  00017	41		 inc	 ecx

; 466  :         s2++;

  00018	42		 inc	 edx
  00019	84 c0		 test	 al, al
  0001b	75 f3		 jne	 SHORT $LL2@scmp
$LN1@scmp:

; 467  :     }
; 468  :     return( *s1-*s2 );

  0001d	0f b6 01	 movzx	 eax, BYTE PTR [ecx]
  00020	0f b6 0a	 movzx	 ecx, BYTE PTR [edx]
  00023	2b c1		 sub	 eax, ecx

; 469  : }

  00025	c3		 ret	 0
_scmp	ENDP
_TEXT	ENDS
PUBLIC	_memcmpKAZE
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_buf1$ = 8						; size = 4
_buf2$ = 12						; size = 4
_count$ = 16						; size = 4
_memcmpKAZE PROC

; 486  : {

  00030	56		 push	 esi

; 487  :         if (!count)

  00031	8b 74 24 10	 mov	 esi, DWORD PTR _count$[esp]
  00035	85 f6		 test	 esi, esi
  00037	75 04		 jne	 SHORT $LN6@memcmpKAZE

; 488  :                 return(0);

  00039	33 c0		 xor	 eax, eax
  0003b	5e		 pop	 esi

; 496  : }

  0003c	c3		 ret	 0
$LN6@memcmpKAZE:

; 489  : 
; 490  :         while ( --count && *(char *)buf1 == *(char *)buf2 ) {

  0003d	4e		 dec	 esi
  0003e	8b 4c 24 0c	 mov	 ecx, DWORD PTR _buf2$[esp]
  00042	8b 44 24 08	 mov	 eax, DWORD PTR _buf1$[esp]
  00046	74 0b		 je	 SHORT $LN1@memcmpKAZE
$LL2@memcmpKAZE:
  00048	8a 10		 mov	 dl, BYTE PTR [eax]
  0004a	3a 11		 cmp	 dl, BYTE PTR [ecx]
  0004c	75 05		 jne	 SHORT $LN1@memcmpKAZE

; 491  :                 buf1 = (char *)buf1 + 1;

  0004e	40		 inc	 eax

; 492  :                 buf2 = (char *)buf2 + 1;

  0004f	41		 inc	 ecx
  00050	4e		 dec	 esi
  00051	75 f5		 jne	 SHORT $LL2@memcmpKAZE
$LN1@memcmpKAZE:

; 493  :         }
; 494  : 
; 495  :         return( *((unsigned char *)buf1) - *((unsigned char *)buf2) );

  00053	0f b6 00	 movzx	 eax, BYTE PTR [eax]
  00056	0f b6 09	 movzx	 ecx, BYTE PTR [ecx]
  00059	2b c1		 sub	 eax, ecx
  0005b	5e		 pop	 esi

; 496  : }

  0005c	c3		 ret	 0
_memcmpKAZE ENDP
_TEXT	ENDS
PUBLIC	_memcpyKAZE
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_dst$ = 8						; size = 4
_src$ = 12						; size = 4
_count$ = 16						; size = 4
_memcpyKAZE PROC

; 504  :         void * ret = dst;
; 505  : 
; 506  :         /*
; 507  :          * copy from lower addresses to higher addresses
; 508  :          */
; 509  :         while (count--) {

  00060	8b 54 24 0c	 mov	 edx, DWORD PTR _count$[esp-4]
  00064	85 d2		 test	 edx, edx
  00066	74 1c		 je	 SHORT $LN8@memcpyKAZE
  00068	8b 4c 24 08	 mov	 ecx, DWORD PTR _src$[esp-4]
  0006c	56		 push	 esi
  0006d	57		 push	 edi
  0006e	8b 7c 24 0c	 mov	 edi, DWORD PTR _dst$[esp+4]
  00072	8b f7		 mov	 esi, edi
  00074	2b f1		 sub	 esi, ecx
$LL2@memcpyKAZE:

; 510  :                 *(char *)dst = *(char *)src;

  00076	8a 01		 mov	 al, BYTE PTR [ecx]
  00078	88 04 0e	 mov	 BYTE PTR [esi+ecx], al

; 511  :                 dst = (char *)dst + 1;
; 512  :                 src = (char *)src + 1;

  0007b	41		 inc	 ecx
  0007c	4a		 dec	 edx
  0007d	75 f7		 jne	 SHORT $LL2@memcpyKAZE

; 513  :         }
; 514  :         return(ret);

  0007f	8b c7		 mov	 eax, edi
  00081	5f		 pop	 edi
  00082	5e		 pop	 esi

; 515  : }

  00083	c3		 ret	 0
$LN8@memcpyKAZE:

; 513  :         }
; 514  :         return(ret);

  00084	8b 44 24 04	 mov	 eax, DWORD PTR _dst$[esp-4]

; 515  : }

  00088	c3		 ret	 0
_memcpyKAZE ENDP
; Function compile flags: /Ogtpy
$T6290 = -8						; size = 4
_i$ = -4						; size = 4
_n$ = 8							; size = 4
_b$ = 12						; size = 4
_FIXEDLength$ = 16					; size = 4
_simplesortFIXEDLength PROC
; _a$ = edi

; 518  : {

  00090	83 ec 08	 sub	 esp, 8

; 519  :    int i, j;
; 520  :    string tmp;
; 521  : 
; 522  :    for (i = 1; i < n; i++)

  00093	b8 01 00 00 00	 mov	 eax, 1
  00098	89 44 24 04	 mov	 DWORD PTR _i$[esp+8], eax
  0009c	39 44 24 0c	 cmp	 DWORD PTR _n$[esp+4], eax
  000a0	7e 66		 jle	 SHORT $LN4@simplesort
  000a2	53		 push	 ebx
  000a3	55		 push	 ebp
  000a4	56		 push	 esi
$LL25@simplesort:

; 523  :       for (j = i; j > 0 && memcmpKAZE(a[j-1]+b, a[j]+b,FIXEDLength) > 0; j--)

  000a5	85 c0		 test	 eax, eax
  000a7	7e 4d		 jle	 SHORT $LN5@simplesort
  000a9	8d a4 24 00 00
	00 00		 npad	 7
$LL21@simplesort:
  000b0	8b 4c 24 1c	 mov	 ecx, DWORD PTR _b$[esp+16]
  000b4	8b 2c 87	 mov	 ebp, DWORD PTR [edi+eax*4]
  000b7	8b 54 87 fc	 mov	 edx, DWORD PTR [edi+eax*4-4]
  000bb	8b 5c 24 20	 mov	 ebx, DWORD PTR _FIXEDLength$[esp+16]
  000bf	8d 34 29	 lea	 esi, DWORD PTR [ecx+ebp]
  000c2	03 ca		 add	 ecx, edx
  000c4	85 db		 test	 ebx, ebx
  000c6	74 2e		 je	 SHORT $LN5@simplesort
  000c8	4b		 dec	 ebx
  000c9	89 5c 24 0c	 mov	 DWORD PTR $T6290[esp+20], ebx
  000cd	74 0f		 je	 SHORT $LN9@simplesort
  000cf	90		 npad	 1
$LL10@simplesort:
  000d0	8a 19		 mov	 bl, BYTE PTR [ecx]
  000d2	3a 1e		 cmp	 bl, BYTE PTR [esi]
  000d4	75 08		 jne	 SHORT $LN9@simplesort
  000d6	41		 inc	 ecx
  000d7	46		 inc	 esi
  000d8	ff 4c 24 0c	 dec	 DWORD PTR $T6290[esp+20]
  000dc	75 f2		 jne	 SHORT $LL10@simplesort
$LN9@simplesort:
  000de	0f b6 09	 movzx	 ecx, BYTE PTR [ecx]
  000e1	0f b6 36	 movzx	 esi, BYTE PTR [esi]
  000e4	2b ce		 sub	 ecx, esi
  000e6	85 c9		 test	 ecx, ecx
  000e8	7e 0c		 jle	 SHORT $LN5@simplesort

; 524  :          { tmp = a[j]; a[j] = a[j-1]; a[j-1] = tmp; }

  000ea	89 14 87	 mov	 DWORD PTR [edi+eax*4], edx
  000ed	89 6c 87 fc	 mov	 DWORD PTR [edi+eax*4-4], ebp
  000f1	48		 dec	 eax
  000f2	85 c0		 test	 eax, eax
  000f4	7f ba		 jg	 SHORT $LL21@simplesort
$LN5@simplesort:

; 519  :    int i, j;
; 520  :    string tmp;
; 521  : 
; 522  :    for (i = 1; i < n; i++)

  000f6	8b 44 24 10	 mov	 eax, DWORD PTR _i$[esp+20]
  000fa	40		 inc	 eax
  000fb	89 44 24 10	 mov	 DWORD PTR _i$[esp+20], eax
  000ff	3b 44 24 18	 cmp	 eax, DWORD PTR _n$[esp+16]
  00103	7c a0		 jl	 SHORT $LL25@simplesort
  00105	5e		 pop	 esi
  00106	5d		 pop	 ebp
  00107	5b		 pop	 ebx
$LN4@simplesort:

; 525  : }

  00108	83 c4 08	 add	 esp, 8
  0010b	c3		 ret	 0
_simplesortFIXEDLength ENDP
_TEXT	ENDS
PUBLIC	_vecswap2
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_a$ = 8							; size = 4
_b$ = 12						; size = 4
_n$ = 16						; size = 4
_vecswap2 PROC

; 566  : {   while (n-- > 0) {

  00110	8b 54 24 0c	 mov	 edx, DWORD PTR _n$[esp-4]
  00114	85 d2		 test	 edx, edx
  00116	7e 20		 jle	 SHORT $LN6@vecswap2
  00118	8b 4c 24 04	 mov	 ecx, DWORD PTR _a$[esp-4]
  0011c	8b 44 24 08	 mov	 eax, DWORD PTR _b$[esp-4]
  00120	56		 push	 esi
  00121	2b c8		 sub	 ecx, eax
  00123	57		 push	 edi
$LL2@vecswap2:

; 567  :         unsigned char *t = *a;
; 568  :         *a++ = *b;

  00124	8b 38		 mov	 edi, DWORD PTR [eax]
  00126	8b 34 01	 mov	 esi, DWORD PTR [ecx+eax]
  00129	89 3c 01	 mov	 DWORD PTR [ecx+eax], edi
  0012c	4a		 dec	 edx

; 569  :         *b++ = t;

  0012d	89 30		 mov	 DWORD PTR [eax], esi
  0012f	83 c0 04	 add	 eax, 4
  00132	85 d2		 test	 edx, edx
  00134	7f ee		 jg	 SHORT $LL2@vecswap2
  00136	5f		 pop	 edi
  00137	5e		 pop	 esi
$LN6@vecswap2:

; 570  :     }
; 571  : }

  00138	c3		 ret	 0
_vecswap2 ENDP
_TEXT	ENDS
PUBLIC	_med3func
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_a$ = 8							; size = 4
_b$ = 12						; size = 4
_c$ = 16						; size = 4
_depth$ = 20						; size = 4
_med3func PROC

; 578  :     if ((va=ptr2char(a)) == (vb=ptr2char(b)))

  00140	8b 44 24 04	 mov	 eax, DWORD PTR _a$[esp-4]
  00144	8b 4c 24 10	 mov	 ecx, DWORD PTR _depth$[esp-4]
  00148	8b 10		 mov	 edx, DWORD PTR [eax]
  0014a	0f b6 14 0a	 movzx	 edx, BYTE PTR [edx+ecx]
  0014e	53		 push	 ebx
  0014f	8b 5c 24 0c	 mov	 ebx, DWORD PTR _b$[esp]
  00153	56		 push	 esi
  00154	8b 33		 mov	 esi, DWORD PTR [ebx]
  00156	0f b6 34 0e	 movzx	 esi, BYTE PTR [esi+ecx]
  0015a	3b d6		 cmp	 edx, esi

; 579  :         return a;

  0015c	74 38		 je	 SHORT $LN4@med3func

; 580  :     if ((vc=ptr2char(c)) == va || vc == vb)

  0015e	55		 push	 ebp
  0015f	57		 push	 edi
  00160	8b 7c 24 1c	 mov	 edi, DWORD PTR _c$[esp+12]
  00164	8b 2f		 mov	 ebp, DWORD PTR [edi]
  00166	0f b6 0c 29	 movzx	 ecx, BYTE PTR [ecx+ebp]
  0016a	3b ca		 cmp	 ecx, edx
  0016c	74 24		 je	 SHORT $LN1@med3func
  0016e	3b ce		 cmp	 ecx, esi
  00170	74 20		 je	 SHORT $LN1@med3func

; 582  :     return va < vb ?
; 583  :           (vb < vc ? b : (va < vc ? c : a ) )
; 584  :         : (vb > vc ? b : (va < vc ? a : c ) );

  00172	3b d6		 cmp	 edx, esi
  00174	7d 0d		 jge	 SHORT $LN14@med3func
  00176	3b f1		 cmp	 esi, ecx
  00178	7c 0d		 jl	 SHORT $LN17@med3func
  0017a	3b d1		 cmp	 edx, ecx
  0017c	7c 14		 jl	 SHORT $LN1@med3func
  0017e	5f		 pop	 edi
  0017f	5d		 pop	 ebp
  00180	5e		 pop	 esi
  00181	5b		 pop	 ebx

; 585  : }

  00182	c3		 ret	 0
$LN14@med3func:

; 582  :     return va < vb ?
; 583  :           (vb < vc ? b : (va < vc ? c : a ) )
; 584  :         : (vb > vc ? b : (va < vc ? a : c ) );

  00183	3b f1		 cmp	 esi, ecx
  00185	7e 07		 jle	 SHORT $LN12@med3func
$LN17@med3func:
  00187	5f		 pop	 edi
  00188	5d		 pop	 ebp
  00189	5e		 pop	 esi
  0018a	8b c3		 mov	 eax, ebx
  0018c	5b		 pop	 ebx

; 585  : }

  0018d	c3		 ret	 0
$LN12@med3func:

; 582  :     return va < vb ?
; 583  :           (vb < vc ? b : (va < vc ? c : a ) )
; 584  :         : (vb > vc ? b : (va < vc ? a : c ) );

  0018e	3b d1		 cmp	 edx, ecx
  00190	7c 02		 jl	 SHORT $LN16@med3func
$LN1@med3func:

; 581  :         return c;       

  00192	8b c7		 mov	 eax, edi
$LN16@med3func:
  00194	5f		 pop	 edi
  00195	5d		 pop	 ebp
$LN4@med3func:
  00196	5e		 pop	 esi
  00197	5b		 pop	 ebx

; 585  : }

  00198	c3		 ret	 0
_med3func ENDP
_TEXT	ENDS
PUBLIC	_inssort
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_pi$ = -4						; size = 4
_a$ = 8							; size = 4
_n$ = 12						; size = 4
_d$ = 16						; size = 4
_inssort PROC

; 589  : {   unsigned char **pi, **pj, *s, *t;

  001a0	51		 push	 ecx

; 590  :     for (pi = a + 1; --n > 0; pi++)

  001a1	8b 44 24 0c	 mov	 eax, DWORD PTR _n$[esp]
  001a5	56		 push	 esi
  001a6	8b 74 24 0c	 mov	 esi, DWORD PTR _a$[esp+4]
  001aa	48		 dec	 eax
  001ab	83 c6 04	 add	 esi, 4
  001ae	89 74 24 04	 mov	 DWORD PTR _pi$[esp+8], esi
  001b2	89 44 24 10	 mov	 DWORD PTR _n$[esp+4], eax
  001b6	85 c0		 test	 eax, eax
  001b8	7e 62		 jle	 SHORT $LN8@inssort
  001ba	53		 push	 ebx
  001bb	55		 push	 ebp
  001bc	8b 6c 24 1c	 mov	 ebp, DWORD PTR _d$[esp+12]
  001c0	57		 push	 edi
$LL21@inssort:

; 591  :         for (pj = pi; pj > a; pj--) {

  001c1	3b 74 24 18	 cmp	 esi, DWORD PTR _a$[esp+16]
  001c5	76 3e		 jbe	 SHORT $LN9@inssort
$LL7@inssort:

; 592  :             /* Inline strcmp: break if *(pj-1) <= *pj */
; 593  :             for (s=*(pj-1)+d, t=*pj+d; *s==*t && *s!=0; s++, t++)

  001c7	8b 7e fc	 mov	 edi, DWORD PTR [esi-4]
  001ca	8b 1e		 mov	 ebx, DWORD PTR [esi]
  001cc	8a 04 2f	 mov	 al, BYTE PTR [edi+ebp]
  001cf	8d 0c 2f	 lea	 ecx, DWORD PTR [edi+ebp]
  001d2	3a 04 2b	 cmp	 al, BYTE PTR [ebx+ebp]
  001d5	8d 14 2b	 lea	 edx, DWORD PTR [ebx+ebp]
  001d8	75 13		 jne	 SHORT $LN2@inssort
  001da	8d 9b 00 00 00
	00		 npad	 6
$LL4@inssort:
  001e0	84 c0		 test	 al, al
  001e2	74 09		 je	 SHORT $LN2@inssort
  001e4	8a 41 01	 mov	 al, BYTE PTR [ecx+1]
  001e7	41		 inc	 ecx
  001e8	42		 inc	 edx
  001e9	3a 02		 cmp	 al, BYTE PTR [edx]
  001eb	74 f3		 je	 SHORT $LL4@inssort
$LN2@inssort:

; 594  :                 ;
; 595  :             if (*s <= *t)

  001ed	8a 01		 mov	 al, BYTE PTR [ecx]
  001ef	3a 02		 cmp	 al, BYTE PTR [edx]
  001f1	76 0e		 jbe	 SHORT $LN20@inssort

; 596  :                 break;
; 597  :             swap2(pj, pj-1);

  001f3	89 3e		 mov	 DWORD PTR [esi], edi
  001f5	89 5e fc	 mov	 DWORD PTR [esi-4], ebx
  001f8	83 c6 fc	 add	 esi, -4			; fffffffcH
  001fb	3b 74 24 18	 cmp	 esi, DWORD PTR _a$[esp+16]
  001ff	77 c6		 ja	 SHORT $LL7@inssort
$LN20@inssort:

; 591  :         for (pj = pi; pj > a; pj--) {

  00201	8b 74 24 10	 mov	 esi, DWORD PTR _pi$[esp+20]
$LN9@inssort:

; 590  :     for (pi = a + 1; --n > 0; pi++)

  00205	8b 44 24 1c	 mov	 eax, DWORD PTR _n$[esp+16]
  00209	48		 dec	 eax
  0020a	83 c6 04	 add	 esi, 4
  0020d	89 74 24 10	 mov	 DWORD PTR _pi$[esp+20], esi
  00211	89 44 24 1c	 mov	 DWORD PTR _n$[esp+16], eax
  00215	85 c0		 test	 eax, eax
  00217	7f a8		 jg	 SHORT $LL21@inssort
  00219	5f		 pop	 edi
  0021a	5d		 pop	 ebp
  0021b	5b		 pop	 ebx
$LN8@inssort:
  0021c	5e		 pop	 esi

; 598  :     }
; 599  : }

  0021d	59		 pop	 ecx
  0021e	c3		 ret	 0
_inssort ENDP
_TEXT	ENDS
PUBLIC	_mkqsort
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_pd$ = -16						; size = 4
_pl$ = -16						; size = 4
tv357 = -12						; size = 4
tv432 = -8						; size = 4
tv536 = -4						; size = 4
tv430 = -4						; size = 4
_a$ = 8							; size = 4
_n$ = 12						; size = 4
_depth$ = 16						; size = 4
_mkqsort PROC

; 602  : {   int d, r, partval;

  00220	83 ec 10	 sub	 esp, 16			; 00000010H
  00223	53		 push	 ebx

; 603  :     unsigned char **pa, **pb, **pc, **pd, **pl, **pm, **pn, *t;
; 604  : 											//printf("depth:%d\n",depth); // Silent exit when millions of equal 7bytes chunks: shitty recusrive approach !!!!!!!!!!
; 605  : /*
; 606  : The next dpeths are for file hs_ref_GRCh37.p5_chrX.fa:
; 607  : ...
; 608  : depth:8
; 609  : depth:9
; 610  : depth:9
; 611  : depth:10
; 612  : depth:10
; 613  : depth:11
; 614  : depth:10
; 615  : depth:9
; 616  : depth:10
; 617  : depth:10
; 618  : depth:11
; 619  : depth:11
; 620  : depth:12
; 621  : depth:10
; 622  : depth:10
; 623  : depth:11
; 624  : depth:10
; 625  : depth:9
; 626  : depth:10
; 627  : depth:10
; 628  : depth:10
; 629  : depth:11
; 630  : depth:10
; 631  : depth:11
; 632  : depth:11
; 633  : depth:11
; 634  : depth:11
; 635  : depth:12
; 636  : depth:12
; 637  : depth:12
; 638  : depth:12
; 639  : depth:13
; 640  : depth:13
; 641  : depth:14
; 642  : depth:14
; 643  : depth:15
; 644  : depth:15
; 645  : depth:16
; 646  : depth:16
; 647  : depth:17
; 648  : depth:1
; 649  : depth:1
; 650  : depth:2
; 651  : depth:3
; 652  : depth:4
; 653  : depth:5
; 654  : depth:6
; 655  : depth:7
; 656  : depth:8
; 657  : depth:9
; 658  : depth:10
; 659  : depth:11
; 660  : depth:12
; 661  : depth:13
; 662  : depth:14
; 663  : depth:15
; 664  : depth:16
; 665  : depth:17
; 666  : depth:18
; 667  : depth:19
; 668  : depth:20
; 669  : depth:21
; 670  : depth:22
; 671  : depth:23
; 672  : depth:24
; 673  : depth:25
; 674  : depth:26
; 675  : depth:27
; 676  : depth:28
; 677  : depth:29
; 678  : depth:30
; 679  : depth:31
; 680  : depth:32
; 681  : depth:33
; 682  : depth:34
; 683  : depth:35
; 684  : depth:36
; 685  : depth:37
; 686  : depth:38
; 687  : depth:39
; 688  : depth:40
; 689  : ...
; 690  : depth:903
; 691  : depth:904
; 692  : depth:905
; 693  : depth:906
; 694  : depth:907
; 695  : depth:907
; 696  : ...
; 697  : depth:2572
; 698  : depth:2573
; 699  : depth:2574
; 700  : depth:2575
; 701  : ...
; 702  : depth:3380
; 703  : depth:3381
; 704  : depth:3382
; 705  : depth:3383
; 706  : depth:3470
; 707  : depth:3471
; 708  : depth:3472
; 709  : depth:3473
; 710  : ...
; 711  : depth:21310
; 712  : depth:21311
; 713  : depth:21312
; 714  : ...
; 715  : depth:21416
; 716  : depth:21417
; 717  : depth:21418
; 718  : 
; 719  : and self-exit at this depth! That is the program terminates itself as if no error occurred!
; 720  : */
; 721  : 
; 722  :     if (n < 20) {

  00224	8b 5c 24 1c	 mov	 ebx, DWORD PTR _n$[esp+16]
  00228	55		 push	 ebp
  00229	56		 push	 esi
  0022a	57		 push	 edi
  0022b	83 fb 14	 cmp	 ebx, 20			; 00000014H
  0022e	0f 8c 2c 02 00
	00		 jl	 $LN54@mkqsort
$LL44@mkqsort:

; 725  :         return;
; 726  :     }
; 727  :     pl = a;

  00234	8b 4c 24 24	 mov	 ecx, DWORD PTR _a$[esp+28]

; 728  :     pm = a + (n/2);

  00238	8b c3		 mov	 eax, ebx
  0023a	99		 cdq
  0023b	2b c2		 sub	 eax, edx
  0023d	d1 f8		 sar	 eax, 1
  0023f	8d 34 81	 lea	 esi, DWORD PTR [ecx+eax*4]

; 729  :     pn = a + (n-1);

  00242	8d 04 99	 lea	 eax, DWORD PTR [ecx+ebx*4]
  00245	8b f9		 mov	 edi, ecx
  00247	89 7c 24 10	 mov	 DWORD PTR _pl$[esp+32], edi
  0024b	89 44 24 14	 mov	 DWORD PTR tv357[esp+32], eax
  0024f	8d 68 fc	 lea	 ebp, DWORD PTR [eax-4]

; 730  :     if (n > 30) { /* On big arrays, pseudomedian of 9 */

  00252	83 fb 1e	 cmp	 ebx, 30			; 0000001eH
  00255	7e 64		 jle	 SHORT $LN13@mkqsort

; 731  :         d = (n/8);

  00257	8b c3		 mov	 eax, ebx
  00259	99		 cdq
  0025a	83 e2 07	 and	 edx, 7
  0025d	03 c2		 add	 eax, edx
  0025f	c1 f8 03	 sar	 eax, 3

; 732  :         pl = med3(pl, pl+d, pl+2*d);

  00262	8d 3c c5 00 00
	00 00		 lea	 edi, DWORD PTR [eax*8]
  00269	8d 1c 85 00 00
	00 00		 lea	 ebx, DWORD PTR [eax*4]
  00270	8b 44 24 2c	 mov	 eax, DWORD PTR _depth$[esp+28]
  00274	50		 push	 eax
  00275	8d 14 0f	 lea	 edx, DWORD PTR [edi+ecx]
  00278	52		 push	 edx
  00279	8d 04 0b	 lea	 eax, DWORD PTR [ebx+ecx]
  0027c	50		 push	 eax
  0027d	51		 push	 ecx
  0027e	e8 00 00 00 00	 call	 _med3func

; 733  :         pm = med3(pm-d, pm, pm+d);

  00283	8b 4c 24 3c	 mov	 ecx, DWORD PTR _depth$[esp+44]
  00287	51		 push	 ecx
  00288	8d 14 33	 lea	 edx, DWORD PTR [ebx+esi]
  0028b	52		 push	 edx
  0028c	56		 push	 esi
  0028d	2b f3		 sub	 esi, ebx
  0028f	56		 push	 esi
  00290	89 44 24 30	 mov	 DWORD PTR _pl$[esp+64], eax
  00294	e8 00 00 00 00	 call	 _med3func
  00299	8b f0		 mov	 esi, eax

; 734  :         pn = med3(pn-2*d, pn-d, pn);

  0029b	8b 44 24 4c	 mov	 eax, DWORD PTR _depth$[esp+60]
  0029f	50		 push	 eax
  002a0	8b cd		 mov	 ecx, ebp
  002a2	55		 push	 ebp
  002a3	2b cb		 sub	 ecx, ebx
  002a5	51		 push	 ecx
  002a6	2b ef		 sub	 ebp, edi
  002a8	55		 push	 ebp
  002a9	e8 00 00 00 00	 call	 _med3func
  002ae	8b 4c 24 54	 mov	 ecx, DWORD PTR _a$[esp+76]
  002b2	8b 7c 24 40	 mov	 edi, DWORD PTR _pl$[esp+80]
  002b6	83 c4 30	 add	 esp, 48			; 00000030H
  002b9	8b e8		 mov	 ebp, eax
$LN13@mkqsort:

; 735  :     }
; 736  :     pm = med3(pl, pm, pn);

  002bb	8b 44 24 2c	 mov	 eax, DWORD PTR _depth$[esp+28]
  002bf	8b 17		 mov	 edx, DWORD PTR [edi]
  002c1	8b 1e		 mov	 ebx, DWORD PTR [esi]
  002c3	0f b6 14 02	 movzx	 edx, BYTE PTR [edx+eax]
  002c7	0f b6 1c 03	 movzx	 ebx, BYTE PTR [ebx+eax]
  002cb	3b d3		 cmp	 edx, ebx
  002cd	75 04		 jne	 SHORT $LN23@mkqsort
  002cf	8b f7		 mov	 esi, edi
  002d1	eb 2f		 jmp	 SHORT $LN72@mkqsort
$LN23@mkqsort:
  002d3	8b 7d 00	 mov	 edi, DWORD PTR [ebp]
  002d6	0f b6 04 07	 movzx	 eax, BYTE PTR [edi+eax]
  002da	3b c2		 cmp	 eax, edx
  002dc	74 22		 je	 SHORT $LN21@mkqsort
  002de	3b c3		 cmp	 eax, ebx
  002e0	74 1e		 je	 SHORT $LN21@mkqsort
  002e2	3b d3		 cmp	 edx, ebx
  002e4	7d 0e		 jge	 SHORT $LN34@mkqsort
  002e6	3b d8		 cmp	 ebx, eax
  002e8	7c 18		 jl	 SHORT $LN72@mkqsort
  002ea	3b d0		 cmp	 edx, eax
  002ec	7c 12		 jl	 SHORT $LN21@mkqsort
  002ee	8b 74 24 10	 mov	 esi, DWORD PTR _pl$[esp+32]
  002f2	eb 0e		 jmp	 SHORT $LN72@mkqsort
$LN34@mkqsort:
  002f4	3b d8		 cmp	 ebx, eax
  002f6	7f 0a		 jg	 SHORT $LN72@mkqsort
  002f8	8b 74 24 10	 mov	 esi, DWORD PTR _pl$[esp+32]
  002fc	3b d0		 cmp	 edx, eax
  002fe	7c 02		 jl	 SHORT $LN72@mkqsort
$LN21@mkqsort:
  00300	8b f5		 mov	 esi, ebp
$LN72@mkqsort:

; 737  :     swap2(a, pm);

  00302	8b 16		 mov	 edx, DWORD PTR [esi]
  00304	8b 01		 mov	 eax, DWORD PTR [ecx]

; 738  :     partval = ptr2char(a);
; 739  :     pa = pb = a + 1;
; 740  :     pc = pd = a + n-1;

  00306	8b 6c 24 14	 mov	 ebp, DWORD PTR tv357[esp+32]
  0030a	89 11		 mov	 DWORD PTR [ecx], edx
  0030c	8b 54 24 2c	 mov	 edx, DWORD PTR _depth$[esp+28]
  00310	89 06		 mov	 DWORD PTR [esi], eax
  00312	8b 01		 mov	 eax, DWORD PTR [ecx]
  00314	0f b6 3c 10	 movzx	 edi, BYTE PTR [eax+edx]
  00318	83 c5 fc	 add	 ebp, -4			; fffffffcH
  0031b	8d 41 04	 lea	 eax, DWORD PTR [ecx+4]
  0031e	8b d8		 mov	 ebx, eax
  00320	89 6c 24 10	 mov	 DWORD PTR _pd$[esp+32], ebp
  00324	8b d5		 mov	 edx, ebp
$LL12@mkqsort:

; 741  :     for (;;) {
; 742  :         while (pb <= pc && (r = ptr2char(pb)-partval) <= 0) {

  00326	3b c2		 cmp	 eax, edx
  00328	77 30		 ja	 SHORT $LN61@mkqsort
  0032a	8d 9b 00 00 00
	00		 npad	 6
$LL10@mkqsort:
  00330	8b 30		 mov	 esi, DWORD PTR [eax]
  00332	8b 4c 24 2c	 mov	 ecx, DWORD PTR _depth$[esp+28]
  00336	0f b6 0c 0e	 movzx	 ecx, BYTE PTR [esi+ecx]
  0033a	2b cf		 sub	 ecx, edi
  0033c	85 c9		 test	 ecx, ecx
  0033e	0f 8f 3c 01 00
	00		 jg	 $LN49@mkqsort

; 743  :             if (r == 0) { swap2(pa, pb); pa++; }

  00344	75 09		 jne	 SHORT $LN66@mkqsort
  00346	8b 0b		 mov	 ecx, DWORD PTR [ebx]
  00348	89 33		 mov	 DWORD PTR [ebx], esi
  0034a	89 08		 mov	 DWORD PTR [eax], ecx
  0034c	83 c3 04	 add	 ebx, 4
$LN66@mkqsort:

; 744  :             pb++;

  0034f	83 c0 04	 add	 eax, 4
  00352	3b c2		 cmp	 eax, edx
  00354	76 da		 jbe	 SHORT $LL10@mkqsort
$LN69@mkqsort:

; 752  :         pb++;
; 753  :         pc--;
; 754  :     }

  00356	8b 4c 24 24	 mov	 ecx, DWORD PTR _a$[esp+28]
$LN61@mkqsort:

; 755  :     pn = a + n;
; 756  :     r = min(pa-a, pb-pa);    vecswap2(a,  pb-r, r);

  0035a	8b e8		 mov	 ebp, eax
  0035c	2b eb		 sub	 ebp, ebx
  0035e	2b d9		 sub	 ebx, ecx
  00360	8b f3		 mov	 esi, ebx
  00362	c1 fe 02	 sar	 esi, 2
  00365	c1 fd 02	 sar	 ebp, 2
  00368	89 6c 24 1c	 mov	 DWORD PTR tv430[esp+32], ebp
  0036c	89 74 24 18	 mov	 DWORD PTR tv432[esp+32], esi
  00370	8b de		 mov	 ebx, esi
  00372	3b f5		 cmp	 esi, ebp
  00374	7c 02		 jl	 SHORT $LN18@mkqsort
  00376	8b dd		 mov	 ebx, ebp
$LN18@mkqsort:
  00378	8d 3c 9d 00 00
	00 00		 lea	 edi, DWORD PTR [ebx*4]
  0037f	8b c8		 mov	 ecx, eax
  00381	2b cf		 sub	 ecx, edi
  00383	85 db		 test	 ebx, ebx
  00385	7e 23		 jle	 SHORT $LN70@mkqsort
  00387	8b 74 24 24	 mov	 esi, DWORD PTR _a$[esp+28]
  0038b	2b f1		 sub	 esi, ecx
  0038d	8d 49 00	 npad	 3
$LL37@mkqsort:
  00390	8b 39		 mov	 edi, DWORD PTR [ecx]
  00392	8b 2c 0e	 mov	 ebp, DWORD PTR [esi+ecx]
  00395	89 3c 0e	 mov	 DWORD PTR [esi+ecx], edi
  00398	4b		 dec	 ebx
  00399	89 29		 mov	 DWORD PTR [ecx], ebp
  0039b	83 c1 04	 add	 ecx, 4
  0039e	85 db		 test	 ebx, ebx
  003a0	7f ee		 jg	 SHORT $LL37@mkqsort
  003a2	8b 74 24 18	 mov	 esi, DWORD PTR tv432[esp+32]
  003a6	8b 6c 24 1c	 mov	 ebp, DWORD PTR tv430[esp+32]
$LN70@mkqsort:

; 757  :     r = min(pd-pc, pn-pd-1); vecswap2(pb, pn-r, r);

  003aa	8b 7c 24 14	 mov	 edi, DWORD PTR tv357[esp+32]
  003ae	8b 5c 24 10	 mov	 ebx, DWORD PTR _pd$[esp+32]
  003b2	8b cf		 mov	 ecx, edi
  003b4	2b cb		 sub	 ecx, ebx
  003b6	2b da		 sub	 ebx, edx
  003b8	c1 f9 02	 sar	 ecx, 2
  003bb	c1 fb 02	 sar	 ebx, 2
  003be	49		 dec	 ecx
  003bf	8b d3		 mov	 edx, ebx
  003c1	3b d9		 cmp	 ebx, ecx
  003c3	7c 02		 jl	 SHORT $LN20@mkqsort
  003c5	8b d1		 mov	 edx, ecx
$LN20@mkqsort:
  003c7	8d 0c 95 00 00
	00 00		 lea	 ecx, DWORD PTR [edx*4]
  003ce	89 4c 24 1c	 mov	 DWORD PTR tv536[esp+32], ecx
  003d2	8b cf		 mov	 ecx, edi
  003d4	2b 4c 24 1c	 sub	 ecx, DWORD PTR tv536[esp+32]
  003d8	85 d2		 test	 edx, edx
  003da	7e 1a		 jle	 SHORT $LN73@mkqsort
  003dc	2b c1		 sub	 eax, ecx
  003de	8b ff		 npad	 2
$LL41@mkqsort:
  003e0	8b 39		 mov	 edi, DWORD PTR [ecx]
  003e2	8b 34 08	 mov	 esi, DWORD PTR [eax+ecx]
  003e5	89 3c 08	 mov	 DWORD PTR [eax+ecx], edi
  003e8	4a		 dec	 edx
  003e9	89 31		 mov	 DWORD PTR [ecx], esi
  003eb	83 c1 04	 add	 ecx, 4
  003ee	85 d2		 test	 edx, edx
  003f0	7f ee		 jg	 SHORT $LL41@mkqsort
  003f2	8b 74 24 18	 mov	 esi, DWORD PTR tv432[esp+32]
$LN73@mkqsort:
  003f6	8b 7c 24 2c	 mov	 edi, DWORD PTR _depth$[esp+28]

; 758  :     if ((r = pb-pa) > 1)

  003fa	83 fd 01	 cmp	 ebp, 1
  003fd	7e 0f		 jle	 SHORT $LN3@mkqsort

; 759  :         mkqsort(a, r, depth);

  003ff	8b 54 24 24	 mov	 edx, DWORD PTR _a$[esp+28]
  00403	57		 push	 edi
  00404	55		 push	 ebp
  00405	52		 push	 edx
  00406	e8 00 00 00 00	 call	 _mkqsort
  0040b	83 c4 0c	 add	 esp, 12			; 0000000cH
$LN3@mkqsort:

; 760  :     if (ptr2char(a + r) != 0)

  0040e	8b 44 24 24	 mov	 eax, DWORD PTR _a$[esp+28]
  00412	8b 0c a8	 mov	 ecx, DWORD PTR [eax+ebp*4]
  00415	80 3c 0f 00	 cmp	 BYTE PTR [edi+ecx], 0
  00419	8d 2c a8	 lea	 ebp, DWORD PTR [eax+ebp*4]
  0041c	74 1f		 je	 SHORT $LN2@mkqsort

; 761  :         mkqsort(a + r, pa-a + pn-pd-1, depth+1);

  0041e	8d 14 b5 00 00
	00 00		 lea	 edx, DWORD PTR [esi*4]
  00425	2b 54 24 10	 sub	 edx, DWORD PTR _pd$[esp+32]
  00429	47		 inc	 edi
  0042a	03 54 24 14	 add	 edx, DWORD PTR tv357[esp+32]
  0042e	57		 push	 edi
  0042f	c1 fa 02	 sar	 edx, 2
  00432	4a		 dec	 edx
  00433	52		 push	 edx
  00434	55		 push	 ebp
  00435	e8 00 00 00 00	 call	 _mkqsort
  0043a	83 c4 0c	 add	 esp, 12			; 0000000cH
$LN2@mkqsort:

; 762  :     if ((r = pd-pc) > 1)

  0043d	83 fb 01	 cmp	 ebx, 1
  00440	7e 36		 jle	 SHORT $LN1@mkqsort

; 763  :         mkqsort(a + n-r, r, depth);

  00442	8b 44 24 28	 mov	 eax, DWORD PTR _n$[esp+28]
  00446	8b 4c 24 24	 mov	 ecx, DWORD PTR _a$[esp+28]
  0044a	2b c3		 sub	 eax, ebx
  0044c	8d 14 81	 lea	 edx, DWORD PTR [ecx+eax*4]
  0044f	89 54 24 24	 mov	 DWORD PTR _a$[esp+28], edx
  00453	89 5c 24 28	 mov	 DWORD PTR _n$[esp+28], ebx
  00457	83 fb 14	 cmp	 ebx, 20			; 00000014H
  0045a	0f 8d d4 fd ff
	ff		 jge	 $LL44@mkqsort
$LN54@mkqsort:

; 723  :         //inssort(a, n, depth);
; 724  :           simplesortFIXEDLength(a, n, depth, Patternlen);

  00460	a1 00 00 00 00	 mov	 eax, DWORD PTR _Patternlen
  00465	8b 4c 24 2c	 mov	 ecx, DWORD PTR _depth$[esp+28]
  00469	8b 7c 24 24	 mov	 edi, DWORD PTR _a$[esp+28]
  0046d	50		 push	 eax
  0046e	51		 push	 ecx
  0046f	53		 push	 ebx
  00470	e8 00 00 00 00	 call	 _simplesortFIXEDLength
  00475	83 c4 0c	 add	 esp, 12			; 0000000cH
$LN1@mkqsort:
  00478	5f		 pop	 edi
  00479	5e		 pop	 esi
  0047a	5d		 pop	 ebp
  0047b	5b		 pop	 ebx

; 764  : }

  0047c	83 c4 10	 add	 esp, 16			; 00000010H
  0047f	c3		 ret	 0
$LN49@mkqsort:

; 745  :         }
; 746  :         while (pb <= pc && (r = ptr2char(pc)-partval) >= 0) {

  00480	3b c2		 cmp	 eax, edx
  00482	0f 87 ce fe ff
	ff		 ja	 $LN69@mkqsort
  00488	eb 06 8d 9b 00
	00 00 00	 npad	 8
$LL7@mkqsort:
  00490	8b 32		 mov	 esi, DWORD PTR [edx]
  00492	8b 4c 24 2c	 mov	 ecx, DWORD PTR _depth$[esp+28]
  00496	0f b6 0c 0e	 movzx	 ecx, BYTE PTR [esi+ecx]
  0049a	2b cf		 sub	 ecx, edi
  0049c	78 1f		 js	 SHORT $LN6@mkqsort

; 747  :             if (r == 0) { swap2(pc, pd); pd--; }

  0049e	85 c9		 test	 ecx, ecx
  004a0	75 0f		 jne	 SHORT $LN67@mkqsort
  004a2	8b 4d 00	 mov	 ecx, DWORD PTR [ebp]
  004a5	89 0a		 mov	 DWORD PTR [edx], ecx
  004a7	89 75 00	 mov	 DWORD PTR [ebp], esi
  004aa	83 ed 04	 sub	 ebp, 4
  004ad	89 6c 24 10	 mov	 DWORD PTR _pd$[esp+32], ebp
$LN67@mkqsort:

; 748  :             pc--;

  004b1	83 ea 04	 sub	 edx, 4
  004b4	3b c2		 cmp	 eax, edx
  004b6	76 d8		 jbe	 SHORT $LL7@mkqsort

; 745  :         }
; 746  :         while (pb <= pc && (r = ptr2char(pc)-partval) >= 0) {

  004b8	e9 99 fe ff ff	 jmp	 $LN69@mkqsort
$LN6@mkqsort:

; 749  :        }
; 750  :         if (pb > pc) break;

  004bd	3b c2		 cmp	 eax, edx
  004bf	0f 87 91 fe ff
	ff		 ja	 $LN69@mkqsort

; 751  :         swap2(pb, pc);

  004c5	8b 08		 mov	 ecx, DWORD PTR [eax]
  004c7	89 30		 mov	 DWORD PTR [eax], esi
  004c9	89 0a		 mov	 DWORD PTR [edx], ecx

; 752  :         pb++;
; 753  :         pc--;
; 754  :     }

  004cb	8b 4c 24 24	 mov	 ecx, DWORD PTR _a$[esp+28]
  004cf	83 c0 04	 add	 eax, 4
  004d2	83 ea 04	 sub	 edx, 4
  004d5	e9 4c fe ff ff	 jmp	 $LL12@mkqsort
_mkqsort ENDP
_TEXT	ENDS
PUBLIC	_mkqsort_main
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_a$ = 8							; size = 4
_n$ = 12						; size = 4
_mkqsort_main PROC

; 766  : void mkqsort_main(unsigned char **a, int n) { mkqsort(a, n, 0); }

  004e0	8b 44 24 08	 mov	 eax, DWORD PTR _n$[esp-4]
  004e4	8b 4c 24 04	 mov	 ecx, DWORD PTR _a$[esp-4]
  004e8	6a 00		 push	 0
  004ea	50		 push	 eax
  004eb	51		 push	 ecx
  004ec	e8 00 00 00 00	 call	 _mkqsort
  004f1	83 c4 0c	 add	 esp, 12			; 0000000cH
  004f4	c3		 ret	 0
_mkqsort_main ENDP
_TEXT	ENDS
PUBLIC	_x64toaKAZE
EXTRN	__aulldvrm:PROC
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
tv65 = -8						; size = 8
tv164 = 8						; size = 8
_val$ = 8						; size = 8
_buf$ = 16						; size = 4
_radix$ = 20						; size = 4
_is_neg$ = 24						; size = 4
_x64toaKAZE PROC

; 844  :             val = (unsigned long long)(-(long long)val);

  00500	8b 44 24 08	 mov	 eax, DWORD PTR _val$[esp]
  00504	83 ec 08	 sub	 esp, 8
  00507	83 7c 24 1c 00	 cmp	 DWORD PTR _is_neg$[esp+4], 0
  0050c	55		 push	 ebp
  0050d	56		 push	 esi
  0050e	8b 74 24 1c	 mov	 esi, DWORD PTR _buf$[esp+12]
  00512	57		 push	 edi
  00513	8b 7c 24 18	 mov	 edi, DWORD PTR _val$[esp+16]
  00517	74 0b		 je	 SHORT $LN9@x64toaKAZE

; 834  :         char *p;                /* pointer to traverse string */
; 835  :         char *firstdig;         /* pointer to first digit */
; 836  :         char temp;              /* temp char */
; 837  :         unsigned digval;        /* value of digit */
; 838  : 
; 839  :         p = buf;
; 840  : 
; 841  :         if ( is_neg )
; 842  :         {
; 843  :             *p++ = '-';         /* negative, so output '-' and negate */

  00519	c6 06 2d	 mov	 BYTE PTR [esi], 45	; 0000002dH
  0051c	46		 inc	 esi

; 844  :             val = (unsigned long long)(-(long long)val);

  0051d	f7 df		 neg	 edi
  0051f	83 d0 00	 adc	 eax, 0
  00522	f7 d8		 neg	 eax
$LN9@x64toaKAZE:

; 845  :         }
; 846  : 
; 847  :         firstdig = p;           /* save pointer to first digit */

  00524	8b ee		 mov	 ebp, esi

; 858  :         } while (val > 0);

  00526	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR tv164[esp+20], 0
  0052e	53		 push	 ebx
  0052f	90		 npad	 1
$LL8@x64toaKAZE:

; 848  : 
; 849  :         do {
; 850  :             digval = (unsigned) (val % radix);

  00530	8b 4c 24 20	 mov	 ecx, DWORD PTR tv164[esp+24]
  00534	51		 push	 ecx
  00535	8b 4c 24 2c	 mov	 ecx, DWORD PTR _radix$[esp+24]
  00539	51		 push	 ecx
  0053a	50		 push	 eax
  0053b	57		 push	 edi
  0053c	e8 00 00 00 00	 call	 __aulldvrm
  00541	8b f8		 mov	 edi, eax
  00543	89 5c 24 14	 mov	 DWORD PTR tv65[esp+28], ebx
  00547	8b c2		 mov	 eax, edx

; 851  :             val /= radix;       /* get next digit */
; 852  : 
; 853  :             /* convert to ascii and store */
; 854  :             if (digval > 9)

  00549	83 f9 09	 cmp	 ecx, 9
  0054c	76 05		 jbe	 SHORT $LN5@x64toaKAZE

; 855  :                 *p++ = (char) (digval - 10 + 'a');  /* a letter */

  0054e	80 c1 57	 add	 cl, 87			; 00000057H

; 856  :             else

  00551	eb 03		 jmp	 SHORT $LN17@x64toaKAZE
$LN5@x64toaKAZE:

; 857  :                 *p++ = (char) (digval + '0');       /* a digit */

  00553	80 c1 30	 add	 cl, 48			; 00000030H
$LN17@x64toaKAZE:
  00556	88 0e		 mov	 BYTE PTR [esi], cl
  00558	46		 inc	 esi

; 858  :         } while (val > 0);

  00559	85 c0		 test	 eax, eax
  0055b	77 d3		 ja	 SHORT $LL8@x64toaKAZE
  0055d	72 04		 jb	 SHORT $LN14@x64toaKAZE
  0055f	85 ff		 test	 edi, edi
  00561	75 cd		 jne	 SHORT $LL8@x64toaKAZE
$LN14@x64toaKAZE:

; 859  : 
; 860  :         /* We now have the digit of the number in the buffer, but in reverse
; 861  :            order.  Thus we reverse them now. */
; 862  : 
; 863  :         *p-- = '\0';            /* terminate string; p points to last digit */

  00563	c6 06 00	 mov	 BYTE PTR [esi], 0
  00566	4e		 dec	 esi
  00567	5b		 pop	 ebx
$LL3@x64toaKAZE:

; 864  : 
; 865  :         do {
; 866  :             temp = *p;
; 867  :             *p = *firstdig;

  00568	8a 55 00	 mov	 dl, BYTE PTR [ebp]
  0056b	8a 06		 mov	 al, BYTE PTR [esi]
  0056d	88 16		 mov	 BYTE PTR [esi], dl

; 868  :             *firstdig = temp;   /* swap *p and *firstdig */

  0056f	88 45 00	 mov	 BYTE PTR [ebp], al

; 869  :             --p;

  00572	4e		 dec	 esi

; 870  :             ++firstdig;         /* advance to next two digits */

  00573	45		 inc	 ebp

; 871  :         } while (firstdig < p); /* repeat until halfway */

  00574	3b ee		 cmp	 ebp, esi
  00576	72 f0		 jb	 SHORT $LL3@x64toaKAZE
  00578	5f		 pop	 edi
  00579	5e		 pop	 esi
  0057a	5d		 pop	 ebp

; 872  : }

  0057b	83 c4 08	 add	 esp, 8
  0057e	c3		 ret	 0
_x64toaKAZE ENDP
_TEXT	ENDS
PUBLIC	__i64toaKAZE
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_val$ = 8						; size = 8
_buf$ = 16						; size = 4
_radix$ = 20						; size = 4
__i64toaKAZE PROC

; 883  :         x64toaKAZE((unsigned long long)val, buf, radix, (radix == 10 && val < 0));

  00580	8b 4c 24 10	 mov	 ecx, DWORD PTR _radix$[esp-4]
  00584	8b 54 24 08	 mov	 edx, DWORD PTR _val$[esp]
  00588	56		 push	 esi
  00589	57		 push	 edi
  0058a	8b 7c 24 0c	 mov	 edi, DWORD PTR _val$[esp+4]
  0058e	83 f9 0a	 cmp	 ecx, 10			; 0000000aH
  00591	75 11		 jne	 SHORT $LN3@i64toaKAZE
  00593	85 d2		 test	 edx, edx
  00595	7f 0d		 jg	 SHORT $LN3@i64toaKAZE
  00597	7c 04		 jl	 SHORT $LN5@i64toaKAZE
  00599	85 ff		 test	 edi, edi
  0059b	73 07		 jae	 SHORT $LN3@i64toaKAZE
$LN5@i64toaKAZE:
  0059d	b8 01 00 00 00	 mov	 eax, 1
  005a2	eb 02		 jmp	 SHORT $LN4@i64toaKAZE
$LN3@i64toaKAZE:
  005a4	33 c0		 xor	 eax, eax
$LN4@i64toaKAZE:
  005a6	8b 74 24 14	 mov	 esi, DWORD PTR _buf$[esp+4]
  005aa	50		 push	 eax
  005ab	51		 push	 ecx
  005ac	56		 push	 esi
  005ad	52		 push	 edx
  005ae	57		 push	 edi
  005af	e8 00 00 00 00	 call	 _x64toaKAZE
  005b4	83 c4 14	 add	 esp, 20			; 00000014H
  005b7	5f		 pop	 edi

; 884  :         return buf;

  005b8	8b c6		 mov	 eax, esi
  005ba	5e		 pop	 esi

; 885  : }

  005bb	c3		 ret	 0
__i64toaKAZE ENDP
_TEXT	ENDS
PUBLIC	__ui64toaKAZE
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_val$ = 8						; size = 8
_buf$ = 16						; size = 4
_radix$ = 20						; size = 4
__ui64toaKAZE PROC

; 893  :         x64toaKAZE(val, buf, radix, 0);

  005c0	8b 44 24 10	 mov	 eax, DWORD PTR _radix$[esp-4]
  005c4	8b 4c 24 08	 mov	 ecx, DWORD PTR _val$[esp]
  005c8	8b 54 24 04	 mov	 edx, DWORD PTR _val$[esp-4]
  005cc	56		 push	 esi
  005cd	8b 74 24 10	 mov	 esi, DWORD PTR _buf$[esp]
  005d1	6a 00		 push	 0
  005d3	50		 push	 eax
  005d4	56		 push	 esi
  005d5	51		 push	 ecx
  005d6	52		 push	 edx
  005d7	e8 00 00 00 00	 call	 _x64toaKAZE
  005dc	83 c4 14	 add	 esp, 20			; 00000014H

; 894  :         return buf;

  005df	8b c6		 mov	 eax, esi
  005e1	5e		 pop	 esi

; 895  : }

  005e2	c3		 ret	 0
__ui64toaKAZE ENDP
_TEXT	ENDS
PUBLIC	__ui64toaKAZEzerocomma
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_val$ = 8						; size = 8
_buf$ = 16						; size = 4
_radix$ = 20						; size = 4
__ui64toaKAZEzerocomma PROC

; 903  :                         char *p;
; 904  :                         char temp;
; 905  :                         int txpman;
; 906  :                         int pxnman;
; 907  :         x64toaKAZE(val, buf, radix, 0);

  005f0	8b 44 24 10	 mov	 eax, DWORD PTR _radix$[esp-4]
  005f4	8b 4c 24 08	 mov	 ecx, DWORD PTR _val$[esp]
  005f8	8b 54 24 04	 mov	 edx, DWORD PTR _val$[esp-4]
  005fc	53		 push	 ebx
  005fd	55		 push	 ebp
  005fe	8b 6c 24 14	 mov	 ebp, DWORD PTR _buf$[esp+4]
  00602	56		 push	 esi
  00603	57		 push	 edi
  00604	6a 00		 push	 0
  00606	50		 push	 eax
  00607	55		 push	 ebp
  00608	51		 push	 ecx
  00609	52		 push	 edx
  0060a	e8 00 00 00 00	 call	 _x64toaKAZE
  0060f	83 c4 14	 add	 esp, 20			; 00000014H

; 908  :                         p = buf;

  00612	8b fd		 mov	 edi, ebp
$LL10@ui64toaKAZ:

; 909  :                         do {
; 910  :                         } while (*++p != '\0');

  00614	47		 inc	 edi
  00615	80 3f 00	 cmp	 BYTE PTR [edi], 0
  00618	75 fa		 jne	 SHORT $LL10@ui64toaKAZ

; 911  :                         p--; // p points to last digit

  0061a	4f		 dec	 edi

; 912  :                              // buf points to first digit
; 913  :                         buf[26] = 0;

  0061b	c6 45 1a 00	 mov	 BYTE PTR [ebp+26], 0

; 914  :                         txpman = 1;

  0061f	bb 01 00 00 00	 mov	 ebx, 1

; 915  :                         pxnman = 0;

  00624	33 c9		 xor	 ecx, ecx
  00626	8d 75 19	 lea	 esi, DWORD PTR [ebp+25]
  00629	8d a4 24 00 00
	00 00		 npad	 7
$LL7@ui64toaKAZ:

; 916  :                         do
; 917  :                         { if (buf <= p)
; 918  :                           { temp = *p;
; 919  :                             buf[26-txpman] = temp; pxnman++;

  00630	41		 inc	 ecx
  00631	3b ef		 cmp	 ebp, edi
  00633	77 07		 ja	 SHORT $LN4@ui64toaKAZ
  00635	8a 07		 mov	 al, BYTE PTR [edi]
  00637	88 06		 mov	 BYTE PTR [esi], al

; 920  :                             p--;

  00639	4f		 dec	 edi

; 921  :                             if (pxnman % 3 == 0)
; 922  :                             { txpman++;
; 923  :                               buf[26-txpman] = (char) (',');
; 924  :                             }
; 925  :                           }
; 926  :                           else

  0063a	eb 03		 jmp	 SHORT $LN18@ui64toaKAZ
$LN4@ui64toaKAZ:

; 927  :                           { buf[26-txpman] = (char) ('0'); pxnman++;

  0063c	c6 06 30	 mov	 BYTE PTR [esi], 48	; 00000030H
$LN18@ui64toaKAZ:

; 928  :                             if (pxnman % 3 == 0)

  0063f	b8 56 55 55 55	 mov	 eax, 1431655766		; 55555556H
  00644	f7 e9		 imul	 ecx
  00646	8b c2		 mov	 eax, edx
  00648	c1 e8 1f	 shr	 eax, 31			; 0000001fH
  0064b	03 c2		 add	 eax, edx
  0064d	8d 14 40	 lea	 edx, DWORD PTR [eax+eax*2]
  00650	8b c1		 mov	 eax, ecx
  00652	2b c2		 sub	 eax, edx
  00654	75 05		 jne	 SHORT $LN16@ui64toaKAZ

; 929  :                             { txpman++;

  00656	43		 inc	 ebx
  00657	4e		 dec	 esi

; 930  :                               buf[26-txpman] = (char) (',');

  00658	c6 06 2c	 mov	 BYTE PTR [esi], 44	; 0000002cH
$LN16@ui64toaKAZ:

; 931  :                             }
; 932  :                           }
; 933  :                           txpman++;

  0065b	43		 inc	 ebx
  0065c	4e		 dec	 esi

; 934  :                         } while (txpman <= 26);

  0065d	83 fb 1a	 cmp	 ebx, 26			; 0000001aH
  00660	7e ce		 jle	 SHORT $LL7@ui64toaKAZ

; 935  :         return buf;

  00662	5f		 pop	 edi
  00663	5e		 pop	 esi
  00664	8b c5		 mov	 eax, ebp
  00666	5d		 pop	 ebp
  00667	5b		 pop	 ebx

; 936  : }

  00668	c3		 ret	 0
__ui64toaKAZEzerocomma ENDP
_TEXT	ENDS
PUBLIC	__ui64toaKAZEcomma
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_val$ = 8						; size = 8
_buf$ = 16						; size = 4
_radix$ = 20						; size = 4
__ui64toaKAZEcomma PROC

; 944  :                         char *p;
; 945  :                         char temp;
; 946  :                         int txpman;
; 947  :                         int pxnman;
; 948  :         x64toaKAZE(val, buf, radix, 0);

  00670	8b 44 24 10	 mov	 eax, DWORD PTR _radix$[esp-4]
  00674	8b 4c 24 08	 mov	 ecx, DWORD PTR _val$[esp]
  00678	8b 54 24 04	 mov	 edx, DWORD PTR _val$[esp-4]
  0067c	53		 push	 ebx
  0067d	8b 5c 24 10	 mov	 ebx, DWORD PTR _buf$[esp]
  00681	55		 push	 ebp
  00682	57		 push	 edi
  00683	6a 00		 push	 0
  00685	50		 push	 eax
  00686	53		 push	 ebx
  00687	51		 push	 ecx
  00688	52		 push	 edx
  00689	e8 00 00 00 00	 call	 _x64toaKAZE
  0068e	83 c4 14	 add	 esp, 20			; 00000014H

; 949  :                         p = buf;

  00691	8b cb		 mov	 ecx, ebx
$LL6@ui64toaKAZ@2:

; 950  :                         do {
; 951  :                         } while (*++p != '\0');

  00693	41		 inc	 ecx
  00694	80 39 00	 cmp	 BYTE PTR [ecx], 0
  00697	75 fa		 jne	 SHORT $LL6@ui64toaKAZ@2

; 952  :                         p--; // p points to last digit

  00699	49		 dec	 ecx

; 953  :                              // buf points to first digit
; 954  :                         buf[26] = 0;
; 955  :                         txpman = 1;
; 956  :                         pxnman = 0;

  0069a	33 ff		 xor	 edi, edi
  0069c	c6 43 1a 00	 mov	 BYTE PTR [ebx+26], 0
  006a0	bd 01 00 00 00	 mov	 ebp, 1

; 957  :                         while (buf <= p)

  006a5	3b d9		 cmp	 ebx, ecx
  006a7	77 34		 ja	 SHORT $LN2@ui64toaKAZ@2

; 952  :                         p--; // p points to last digit

  006a9	56		 push	 esi
  006aa	8d 73 19	 lea	 esi, DWORD PTR [ebx+25]
  006ad	8d 49 00	 npad	 3
$LL3@ui64toaKAZ@2:

; 958  :                         { temp = *p;
; 959  :                           buf[26-txpman] = temp; pxnman++;

  006b0	8a 01		 mov	 al, BYTE PTR [ecx]
  006b2	88 06		 mov	 BYTE PTR [esi], al
  006b4	47		 inc	 edi

; 960  :                           p--;
; 961  :                           if (pxnman % 3 == 0 && buf <= p)

  006b5	b8 56 55 55 55	 mov	 eax, 1431655766		; 55555556H
  006ba	f7 ef		 imul	 edi
  006bc	8b c2		 mov	 eax, edx
  006be	c1 e8 1f	 shr	 eax, 31			; 0000001fH
  006c1	03 c2		 add	 eax, edx
  006c3	8d 14 40	 lea	 edx, DWORD PTR [eax+eax*2]
  006c6	8b c7		 mov	 eax, edi
  006c8	49		 dec	 ecx
  006c9	2b c2		 sub	 eax, edx
  006cb	75 09		 jne	 SHORT $LN13@ui64toaKAZ@2
  006cd	3b d9		 cmp	 ebx, ecx
  006cf	77 05		 ja	 SHORT $LN13@ui64toaKAZ@2

; 962  :                           { txpman++;

  006d1	45		 inc	 ebp
  006d2	4e		 dec	 esi

; 963  :                             buf[26-txpman] = (char) (',');

  006d3	c6 06 2c	 mov	 BYTE PTR [esi], 44	; 0000002cH
$LN13@ui64toaKAZ@2:

; 964  :                           }
; 965  :                           txpman++;

  006d6	45		 inc	 ebp
  006d7	4e		 dec	 esi
  006d8	3b cb		 cmp	 ecx, ebx
  006da	73 d4		 jae	 SHORT $LL3@ui64toaKAZ@2
  006dc	5e		 pop	 esi
$LN2@ui64toaKAZ@2:

; 966  :                         } 
; 967  :         return buf+26-(txpman-1);

  006dd	8b c3		 mov	 eax, ebx
  006df	5f		 pop	 edi
  006e0	2b c5		 sub	 eax, ebp
  006e2	5d		 pop	 ebp
  006e3	83 c0 1b	 add	 eax, 27			; 0000001bH
  006e6	5b		 pop	 ebx

; 968  : }

  006e7	c3		 ret	 0
__ui64toaKAZEcomma ENDP
_TEXT	ENDS
PUBLIC	_compVS2003
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_buf1$ = 8						; size = 4
_buf2$ = 12						; size = 4
_compVS2003 PROC

; 977  :         unsigned long * buf1Nested = buf1;
; 978  :         unsigned long * buf2Nested = buf2;
; 979  :         void * buf1Fetched;
; 980  :         void * buf2Fetched;
; 981  :  
; 982  :         buf1Fetched = *buf1Nested;
; 983  :         buf2Fetched = *buf2Nested;
; 984  : 
; 985  :         return( memcmpKAZE ( buf1Fetched, buf2Fetched, Patternlen ) );

  006f0	8b 44 24 08	 mov	 eax, DWORD PTR _buf2$[esp-4]
  006f4	8b 54 24 04	 mov	 edx, DWORD PTR _buf1$[esp-4]
  006f8	8b 08		 mov	 ecx, DWORD PTR [eax]
  006fa	8b 02		 mov	 eax, DWORD PTR [edx]
  006fc	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _Patternlen
  00702	85 d2		 test	 edx, edx
  00704	75 03		 jne	 SHORT $LN8@compVS2003
  00706	33 c0		 xor	 eax, eax

; 986  : 
; 987  : }

  00708	c3		 ret	 0
$LN8@compVS2003:
  00709	56		 push	 esi

; 977  :         unsigned long * buf1Nested = buf1;
; 978  :         unsigned long * buf2Nested = buf2;
; 979  :         void * buf1Fetched;
; 980  :         void * buf2Fetched;
; 981  :  
; 982  :         buf1Fetched = *buf1Nested;
; 983  :         buf2Fetched = *buf2Nested;
; 984  : 
; 985  :         return( memcmpKAZE ( buf1Fetched, buf2Fetched, Patternlen ) );

  0070a	8d 72 ff	 lea	 esi, DWORD PTR [edx-1]
  0070d	85 f6		 test	 esi, esi
  0070f	74 0b		 je	 SHORT $LN3@compVS2003
$LL4@compVS2003:
  00711	8a 10		 mov	 dl, BYTE PTR [eax]
  00713	3a 11		 cmp	 dl, BYTE PTR [ecx]
  00715	75 05		 jne	 SHORT $LN3@compVS2003
  00717	40		 inc	 eax
  00718	41		 inc	 ecx
  00719	4e		 dec	 esi
  0071a	75 f5		 jne	 SHORT $LL4@compVS2003
$LN3@compVS2003:
  0071c	0f b6 00	 movzx	 eax, BYTE PTR [eax]
  0071f	0f b6 09	 movzx	 ecx, BYTE PTR [ecx]
  00722	2b c1		 sub	 eax, ecx
  00724	5e		 pop	 esi

; 986  : 
; 987  : }

  00725	c3		 ret	 0
_compVS2003 ENDP
; Function compile flags: /Ogtpy
_swapVS2003 PROC
; _a$ = ecx
; _b$ = eax
; _width$ = edx

; 1017 : {

  00730	56		 push	 esi
  00731	8b f2		 mov	 esi, edx

; 1018 :     char tmp;
; 1019 : 
; 1020 :     if ( a != b )

  00733	3b c8		 cmp	 ecx, eax
  00735	74 18		 je	 SHORT $LN7@swapVS2003

; 1021 :         /* Do the swap one character at a time to avoid potential alignment
; 1022 :            problems. */
; 1023 :         while ( width-- ) {

  00737	85 f6		 test	 esi, esi
  00739	74 14		 je	 SHORT $LN7@swapVS2003
  0073b	2b c8		 sub	 ecx, eax
  0073d	53		 push	 ebx
  0073e	8b ff		 npad	 2
$LL2@swapVS2003:

; 1024 :             tmp = *a;
; 1025 :             *a++ = *b;

  00740	8a 18		 mov	 bl, BYTE PTR [eax]
  00742	8a 14 01	 mov	 dl, BYTE PTR [ecx+eax]
  00745	88 1c 01	 mov	 BYTE PTR [ecx+eax], bl

; 1026 :             *b++ = tmp;

  00748	88 10		 mov	 BYTE PTR [eax], dl
  0074a	40		 inc	 eax
  0074b	4e		 dec	 esi
  0074c	75 f2		 jne	 SHORT $LL2@swapVS2003
  0074e	5b		 pop	 ebx
$LN7@swapVS2003:
  0074f	5e		 pop	 esi

; 1027 :         }
; 1028 : }

  00750	c3		 ret	 0
_swapVS2003 ENDP
; Function compile flags: /Ogtpy
_lo$ = 8						; size = 4
tv129 = 12						; size = 4
_hi$ = 12						; size = 4
_width$ = 16						; size = 4
_compVS2003$ = 20					; size = 4
_shortsortVS2003 PROC

; 1064 :     char *p, *max;
; 1065 : 
; 1066 :     /* Note: in assertions below, i and j are alway inside original bound of
; 1067 :        array to sort. */
; 1068 : 
; 1069 :     while (hi > lo) {

  00760	8b 4c 24 04	 mov	 ecx, DWORD PTR _lo$[esp-4]
  00764	55		 push	 ebp
  00765	8b 6c 24 0c	 mov	 ebp, DWORD PTR _hi$[esp]
  00769	3b e9		 cmp	 ebp, ecx
  0076b	76 72		 jbe	 SHORT $LN5@shortsortV
  0076d	53		 push	 ebx
  0076e	8b 5c 24 14	 mov	 ebx, DWORD PTR _width$[esp+4]
  00772	56		 push	 esi

; 1070 :         /* A[i] <= A[j] for i <= j, j > hi */
; 1071 :         max = lo;
; 1072 :         for (p = lo+width; p <= hi; p += width) {

  00773	8d 04 19	 lea	 eax, DWORD PTR [ecx+ebx]
  00776	57		 push	 edi
  00777	89 44 24 18	 mov	 DWORD PTR tv129[esp+12], eax
  0077b	eb 03 8d 49 00	 npad	 5
$LL6@shortsortV:
  00780	8b 74 24 18	 mov	 esi, DWORD PTR tv129[esp+12]
  00784	8b f9		 mov	 edi, ecx
  00786	3b f5		 cmp	 esi, ebp
  00788	77 1f		 ja	 SHORT $LN2@shortsortV
  0078a	8d 9b 00 00 00
	00		 npad	 6
$LL4@shortsortV:

; 1073 :             /* A[i] <= A[max] for lo <= i < p */
; 1074 :             if (compVS2003(p, max) > 0) {

  00790	57		 push	 edi
  00791	56		 push	 esi
  00792	ff 54 24 28	 call	 DWORD PTR _compVS2003$[esp+20]
  00796	83 c4 08	 add	 esp, 8
  00799	85 c0		 test	 eax, eax
  0079b	7e 02		 jle	 SHORT $LN3@shortsortV

; 1075 :                 max = p;

  0079d	8b fe		 mov	 edi, esi
$LN3@shortsortV:

; 1070 :         /* A[i] <= A[j] for i <= j, j > hi */
; 1071 :         max = lo;
; 1072 :         for (p = lo+width; p <= hi; p += width) {

  0079f	03 f3		 add	 esi, ebx
  007a1	3b f5		 cmp	 esi, ebp
  007a3	76 eb		 jbe	 SHORT $LL4@shortsortV
  007a5	8b 4c 24 14	 mov	 ecx, DWORD PTR _lo$[esp+12]
$LN2@shortsortV:

; 1076 :             }
; 1077 :             /* A[i] <= A[max] for lo <= i <= p */
; 1078 :         }
; 1079 : 
; 1080 :         /* A[i] <= A[max] for lo <= i <= hi */
; 1081 : 
; 1082 :         swapVS2003(max, hi, width);

  007a9	8b f3		 mov	 esi, ebx
  007ab	8b c5		 mov	 eax, ebp
  007ad	3b fd		 cmp	 edi, ebp
  007af	74 25		 je	 SHORT $LN18@shortsortV
  007b1	85 db		 test	 ebx, ebx
  007b3	74 21		 je	 SHORT $LN18@shortsortV
  007b5	8b cf		 mov	 ecx, edi
  007b7	2b cd		 sub	 ecx, ebp
  007b9	8d a4 24 00 00
	00 00		 npad	 7
$LL10@shortsortV:
  007c0	8a 18		 mov	 bl, BYTE PTR [eax]
  007c2	8a 14 01	 mov	 dl, BYTE PTR [ecx+eax]
  007c5	88 1c 01	 mov	 BYTE PTR [ecx+eax], bl
  007c8	88 10		 mov	 BYTE PTR [eax], dl
  007ca	40		 inc	 eax
  007cb	4e		 dec	 esi
  007cc	75 f2		 jne	 SHORT $LL10@shortsortV
  007ce	8b 5c 24 1c	 mov	 ebx, DWORD PTR _width$[esp+12]
  007d2	8b 4c 24 14	 mov	 ecx, DWORD PTR _lo$[esp+12]
$LN18@shortsortV:

; 1083 : 
; 1084 :         /* A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi */
; 1085 : 
; 1086 :         hi -= width;

  007d6	2b eb		 sub	 ebp, ebx
  007d8	3b e9		 cmp	 ebp, ecx
  007da	77 a4		 ja	 SHORT $LL6@shortsortV
  007dc	5f		 pop	 edi
  007dd	5e		 pop	 esi
  007de	5b		 pop	 ebx
$LN5@shortsortV:
  007df	5d		 pop	 ebp

; 1087 : 
; 1088 :         /* A[i] <= A[j] for i <= j, j > hi, loop top condition established */
; 1089 :     }
; 1090 :     /* A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j,
; 1091 :        so array is sorted */
; 1092 : }

  007e0	c3		 ret	 0
_shortsortVS2003 ENDP
_TEXT	ENDS
PUBLIC	_qsortVS2003
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_hi$ = -256						; size = 4
_lo$ = -252						; size = 4
_tmp$6509 = -245					; size = 1
_stkptr$ = -244						; size = 4
_lostk$ = -240						; size = 120
_histk$ = -120						; size = 120
_base$ = 8						; size = 4
_num$ = 12						; size = 4
_width$ = 16						; size = 4
_compVS2003$ = 20					; size = 4
_qsortVS2003 PROC

; 1138 : {

  007f0	81 ec 00 01 00
	00		 sub	 esp, 256		; 00000100H
  007f6	56		 push	 esi

; 1139 :     /* Note: the number of stack entries required is no more than
; 1140 :        1 + log2(num), so 30 is sufficient for any array */
; 1141 :     char *lo, *hi;              /* ends of sub-array currently sorting */
; 1142 :     char *mid;                  /* points to middle of subarray */
; 1143 :     char *loguy, *higuy;        /* traveling pointers for partition step */
; 1144 :     size_t size;                /* size of the sub-array */
; 1145 :     char *lostk[STKSIZ], *histk[STKSIZ];
; 1146 :     int stkptr;                 /* stack for saving sub-array to be processed */
; 1147 : 
; 1148 :     if (num < 2 || width == 0)

  007f7	8b b4 24 0c 01
	00 00		 mov	 esi, DWORD PTR _num$[esp+256]
  007fe	83 fe 02	 cmp	 esi, 2
  00801	0f 82 60 02 00
	00		 jb	 $LN2@qsortVS200
  00807	55		 push	 ebp
  00808	8b ac 24 14 01
	00 00		 mov	 ebp, DWORD PTR _width$[esp+260]
  0080f	85 ed		 test	 ebp, ebp
  00811	0f 84 4f 02 00
	00		 je	 $LN125@qsortVS200

; 1149 :         return;                 /* nothing to do */
; 1150 : 
; 1151 :     stkptr = 0;                 /* initialize stack */
; 1152 : 
; 1153 :     lo = base;

  00817	8b 84 24 0c 01
	00 00		 mov	 eax, DWORD PTR _base$[esp+260]

; 1154 :     hi = (char *)base + width * (num-1);        /* initialize limits */

  0081e	4e		 dec	 esi
  0081f	0f af f5	 imul	 esi, ebp
  00822	03 f0		 add	 esi, eax
  00824	53		 push	 ebx
  00825	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _stkptr$[esp+268], 0
  0082d	89 44 24 10	 mov	 DWORD PTR _lo$[esp+268], eax
  00831	89 74 24 0c	 mov	 DWORD PTR _hi$[esp+268], esi
  00835	57		 push	 edi
$recurse$5432:

; 1155 : 
; 1156 :     /* this entry point is for pseudo-recursion calling: setting
; 1157 :        lo and hi and jumping to here is like recursion, but stkptr is
; 1158 :        preserved, locals aren't, so we preserve stuff on the stack */
; 1159 : recurse:
; 1160 : 
; 1161 :     size = (hi - lo) / width + 1;        /* number of el's to sort */

  00836	8b 4c 24 14	 mov	 ecx, DWORD PTR _lo$[esp+272]
  0083a	8b c6		 mov	 eax, esi
  0083c	2b c1		 sub	 eax, ecx
  0083e	33 d2		 xor	 edx, edx
  00840	f7 f5		 div	 ebp
  00842	40		 inc	 eax

; 1162 : 
; 1163 :     /* below a certain size, it is faster to use a O(n^2) sorting method */
; 1164 :     if (size <= CUTOFF) {

  00843	83 f8 08	 cmp	 eax, 8
  00846	77 39		 ja	 SHORT $LN41@qsortVS200

; 1165 :         shortsortVS2003(lo, hi, width, compVS2003);

  00848	8b 84 24 20 01
	00 00		 mov	 eax, DWORD PTR _compVS2003$[esp+268]
  0084f	50		 push	 eax
  00850	55		 push	 ebp
  00851	56		 push	 esi
  00852	51		 push	 ecx
  00853	e8 00 00 00 00	 call	 _shortsortVS2003
  00858	83 c4 10	 add	 esp, 16			; 00000010H
$LN116@qsortVS200:

; 1311 :             }
; 1312 :         }
; 1313 :     }
; 1314 : 
; 1315 :     /* We have sorted the array, except for any pending sorts on the stack.
; 1316 :        Check if there are any, and do them. */
; 1317 : 
; 1318 :     --stkptr;

  0085b	8b 44 24 1c	 mov	 eax, DWORD PTR _stkptr$[esp+272]
  0085f	48		 dec	 eax
  00860	89 44 24 1c	 mov	 DWORD PTR _stkptr$[esp+272], eax

; 1319 :     if (stkptr >= 0) {

  00864	0f 88 fa 01 00
	00		 js	 $LN126@qsortVS200

; 1320 :         lo = lostk[stkptr];

  0086a	8b 54 84 20	 mov	 edx, DWORD PTR _lostk$[esp+eax*4+272]

; 1321 :         hi = histk[stkptr];

  0086e	8b 84 84 98 00
	00 00		 mov	 eax, DWORD PTR _histk$[esp+eax*4+272]
  00875	89 54 24 14	 mov	 DWORD PTR _lo$[esp+272], edx
  00879	89 44 24 10	 mov	 DWORD PTR _hi$[esp+272], eax
  0087d	8b f0		 mov	 esi, eax
  0087f	eb b5		 jmp	 SHORT $recurse$5432
$LN41@qsortVS200:

; 1166 :     }
; 1167 :     else {
; 1168 :         /* First we pick a partitioning element.  The efficiency of the
; 1169 :            algorithm demands that we find one that is approximately the median
; 1170 :            of the values, but also that we select one fast.  We choose the
; 1171 :            median of the first, middle, and last elements, to avoid bad
; 1172 :            performance in the face of already sorted data, or data that is made
; 1173 :            up of multiple sorted runs appended together.  Testing shows that a
; 1174 :            median-of-three algorithm provides better performance than simply
; 1175 :            picking the middle element for the latter case. */
; 1176 : 
; 1177 :         mid = lo + (size / 2) * width;      /* find middle element */

  00881	d1 e8		 shr	 eax, 1
  00883	0f af c5	 imul	 eax, ebp
  00886	8d 1c 01	 lea	 ebx, DWORD PTR [ecx+eax]

; 1178 : 
; 1179 :         /* Sort the first, middle, last elements into order */
; 1180 :         if (compVS2003(lo, mid) > 0) {

  00889	53		 push	 ebx
  0088a	51		 push	 ecx
  0088b	ff 94 24 28 01
	00 00		 call	 DWORD PTR _compVS2003$[esp+276]
  00892	83 c4 08	 add	 esp, 8
  00895	85 c0		 test	 eax, eax
  00897	7e 29		 jle	 SHORT $LN117@qsortVS200

; 1181 :             swapVS2003(lo, mid, width);

  00899	8b fd		 mov	 edi, ebp
  0089b	8b c3		 mov	 eax, ebx
  0089d	39 5c 24 14	 cmp	 DWORD PTR _lo$[esp+272], ebx
  008a1	74 1f		 je	 SHORT $LN117@qsortVS200
  008a3	8b 74 24 14	 mov	 esi, DWORD PTR _lo$[esp+272]
  008a7	2b f3		 sub	 esi, ebx
  008a9	8d a4 24 00 00
	00 00		 npad	 7
$LL47@qsortVS200:
  008b0	8a 10		 mov	 dl, BYTE PTR [eax]
  008b2	8a 0c 06	 mov	 cl, BYTE PTR [esi+eax]
  008b5	88 14 06	 mov	 BYTE PTR [esi+eax], dl
  008b8	88 08		 mov	 BYTE PTR [eax], cl
  008ba	40		 inc	 eax
  008bb	4f		 dec	 edi
  008bc	75 f2		 jne	 SHORT $LL47@qsortVS200
  008be	8b 74 24 10	 mov	 esi, DWORD PTR _hi$[esp+272]
$LN117@qsortVS200:

; 1182 :         }
; 1183 :         if (compVS2003(lo, hi) > 0) {

  008c2	8b 44 24 14	 mov	 eax, DWORD PTR _lo$[esp+272]
  008c6	56		 push	 esi
  008c7	50		 push	 eax
  008c8	ff 94 24 28 01
	00 00		 call	 DWORD PTR _compVS2003$[esp+276]
  008cf	83 c4 08	 add	 esp, 8
  008d2	85 c0		 test	 eax, eax
  008d4	7e 24		 jle	 SHORT $LN118@qsortVS200

; 1184 :             swapVS2003(lo, hi, width);

  008d6	8b fd		 mov	 edi, ebp
  008d8	8b c6		 mov	 eax, esi
  008da	39 74 24 14	 cmp	 DWORD PTR _lo$[esp+272], esi
  008de	74 1a		 je	 SHORT $LN118@qsortVS200
  008e0	8b 74 24 14	 mov	 esi, DWORD PTR _lo$[esp+272]
  008e4	2b 74 24 10	 sub	 esi, DWORD PTR _hi$[esp+272]
$LL52@qsortVS200:
  008e8	8a 10		 mov	 dl, BYTE PTR [eax]
  008ea	8a 0c 06	 mov	 cl, BYTE PTR [esi+eax]
  008ed	88 14 06	 mov	 BYTE PTR [esi+eax], dl
  008f0	88 08		 mov	 BYTE PTR [eax], cl
  008f2	40		 inc	 eax
  008f3	4f		 dec	 edi
  008f4	75 f2		 jne	 SHORT $LL52@qsortVS200
  008f6	8b 74 24 10	 mov	 esi, DWORD PTR _hi$[esp+272]
$LN118@qsortVS200:

; 1185 :         }
; 1186 :         if (compVS2003(mid, hi) > 0) {

  008fa	56		 push	 esi
  008fb	53		 push	 ebx
  008fc	ff 94 24 28 01
	00 00		 call	 DWORD PTR _compVS2003$[esp+276]
  00903	83 c4 08	 add	 esp, 8
  00906	85 c0		 test	 eax, eax
  00908	7e 20		 jle	 SHORT $LN119@qsortVS200

; 1187 :             swapVS2003(mid, hi, width);

  0090a	8b fd		 mov	 edi, ebp
  0090c	8b c6		 mov	 eax, esi
  0090e	3b de		 cmp	 ebx, esi
  00910	74 18		 je	 SHORT $LN119@qsortVS200
  00912	8b f3		 mov	 esi, ebx
  00914	2b 74 24 10	 sub	 esi, DWORD PTR _hi$[esp+272]
$LL57@qsortVS200:
  00918	8a 10		 mov	 dl, BYTE PTR [eax]
  0091a	8a 0c 06	 mov	 cl, BYTE PTR [esi+eax]
  0091d	88 14 06	 mov	 BYTE PTR [esi+eax], dl
  00920	88 08		 mov	 BYTE PTR [eax], cl
  00922	40		 inc	 eax
  00923	4f		 dec	 edi
  00924	75 f2		 jne	 SHORT $LL57@qsortVS200
  00926	8b 74 24 10	 mov	 esi, DWORD PTR _hi$[esp+272]
$LN119@qsortVS200:

; 1188 :         }
; 1189 : 
; 1190 :         /* We now wish to partition the array into three pieces, one consisting
; 1191 :            of elements <= partition element, one of elements equal to the
; 1192 :            partition element, and one of elements > than it.  This is done
; 1193 :            below; comments indicate conditions established at every step. */
; 1194 : 
; 1195 :         loguy = lo;

  0092a	8b 7c 24 14	 mov	 edi, DWORD PTR _lo$[esp+272]
  0092e	8b ff		 npad	 2
$LL36@qsortVS200:

; 1196 :         higuy = hi;
; 1197 : 
; 1198 :         /* Note that higuy decreases and loguy increases on every iteration,
; 1199 :            so loop must terminate. */
; 1200 :         for (;;) {
; 1201 :             /* lo <= loguy < hi, lo < higuy <= hi,
; 1202 :                A[i] <= A[mid] for lo <= i <= loguy,
; 1203 :                A[i] > A[mid] for higuy <= i < hi,
; 1204 :                A[hi] >= A[mid] */
; 1205 : 
; 1206 :             /* The doubled loop is to avoid calling comp(mid,mid), since some
; 1207 :                existing comparison funcs don't work when passed the same
; 1208 :                value for both pointers. */
; 1209 : 
; 1210 :             if (mid > loguy) {

  00930	3b df		 cmp	 ebx, edi
  00932	76 1c		 jbe	 SHORT $LL28@qsortVS200
$LL33@qsortVS200:

; 1211 :                 do  {
; 1212 :                     loguy += width;

  00934	03 fd		 add	 edi, ebp

; 1213 :                 } while (loguy < mid && compVS2003(loguy, mid) <= 0);

  00936	3b fb		 cmp	 edi, ebx
  00938	73 16		 jae	 SHORT $LL28@qsortVS200
  0093a	53		 push	 ebx
  0093b	57		 push	 edi
  0093c	ff 94 24 28 01
	00 00		 call	 DWORD PTR _compVS2003$[esp+276]
  00943	83 c4 08	 add	 esp, 8
  00946	85 c0		 test	 eax, eax
  00948	7e ea		 jle	 SHORT $LL33@qsortVS200

; 1214 :             }
; 1215 :             if (mid <= loguy) {

  0094a	3b df		 cmp	 ebx, edi
  0094c	77 1a		 ja	 SHORT $LL24@qsortVS200
  0094e	8b ff		 npad	 2
$LL28@qsortVS200:

; 1216 :                 do  {
; 1217 :                     loguy += width;

  00950	03 fd		 add	 edi, ebp

; 1218 :                 } while (loguy <= hi && compVS2003(loguy, mid) <= 0);

  00952	3b 7c 24 10	 cmp	 edi, DWORD PTR _hi$[esp+272]
  00956	77 10		 ja	 SHORT $LL24@qsortVS200
  00958	53		 push	 ebx
  00959	57		 push	 edi
  0095a	ff 94 24 28 01
	00 00		 call	 DWORD PTR _compVS2003$[esp+276]
  00961	83 c4 08	 add	 esp, 8
  00964	85 c0		 test	 eax, eax
  00966	7e e8		 jle	 SHORT $LL28@qsortVS200
$LL24@qsortVS200:

; 1219 :             }
; 1220 : 
; 1221 :             /* lo < loguy <= hi+1, A[i] <= A[mid] for lo <= i < loguy,
; 1222 :                either loguy > hi or A[loguy] > A[mid] */
; 1223 : 
; 1224 :             do  {
; 1225 :                 higuy -= width;

  00968	2b f5		 sub	 esi, ebp

; 1226 :             } while (higuy > mid && compVS2003(higuy, mid) > 0);

  0096a	3b f3		 cmp	 esi, ebx
  0096c	76 10		 jbe	 SHORT $LN21@qsortVS200
  0096e	53		 push	 ebx
  0096f	56		 push	 esi
  00970	ff 94 24 28 01
	00 00		 call	 DWORD PTR _compVS2003$[esp+276]
  00977	83 c4 08	 add	 esp, 8
  0097a	85 c0		 test	 eax, eax
  0097c	7f ea		 jg	 SHORT $LL24@qsortVS200
$LN21@qsortVS200:

; 1227 : 
; 1228 :             /* lo <= higuy < hi, A[i] > A[mid] for higuy < i < hi,
; 1229 :                either higuy == lo or A[higuy] <= A[mid] */
; 1230 : 
; 1231 :             if (higuy < loguy)

  0097e	3b fe		 cmp	 edi, esi
  00980	77 3d		 ja	 SHORT $LN80@qsortVS200

; 1232 :                 break;
; 1233 : 
; 1234 :             /* if loguy > hi or higuy == lo, then we would have exited, so
; 1235 :                A[loguy] > A[mid], A[higuy] <= A[mid],
; 1236 :                loguy <= hi, higuy > lo */
; 1237 : 
; 1238 :             swapVS2003(loguy, higuy, width);

  00982	8b cd		 mov	 ecx, ebp
  00984	8b c6		 mov	 eax, esi
  00986	74 28		 je	 SHORT $LN87@qsortVS200
  00988	8b ef		 mov	 ebp, edi
  0098a	2b ee		 sub	 ebp, esi
  0098c	8d 64 24 00	 npad	 4
$LL62@qsortVS200:
  00990	0f b6 14 28	 movzx	 edx, BYTE PTR [eax+ebp]
  00994	88 54 24 1b	 mov	 BYTE PTR _tmp$6509[esp+272], dl
  00998	0f b6 10	 movzx	 edx, BYTE PTR [eax]
  0099b	88 14 28	 mov	 BYTE PTR [eax+ebp], dl
  0099e	0f b6 54 24 1b	 movzx	 edx, BYTE PTR _tmp$6509[esp+272]
  009a3	88 10		 mov	 BYTE PTR [eax], dl
  009a5	40		 inc	 eax
  009a6	49		 dec	 ecx
  009a7	75 e7		 jne	 SHORT $LL62@qsortVS200
  009a9	8b ac 24 1c 01
	00 00		 mov	 ebp, DWORD PTR _width$[esp+268]
$LN87@qsortVS200:

; 1239 : 
; 1240 :             /* If the partition element was moved, follow it.  Only need
; 1241 :                to check for mid == higuy, since before the swap,
; 1242 :                A[loguy] > A[mid] implies loguy != mid. */
; 1243 : 
; 1244 :             if (mid == higuy)

  009b0	3b de		 cmp	 ebx, esi
  009b2	0f 85 78 ff ff
	ff		 jne	 $LL36@qsortVS200

; 1245 :                 mid = loguy;

  009b8	8b df		 mov	 ebx, edi

; 1246 : 
; 1247 :             /* A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top
; 1248 :                of loop is re-established */
; 1249 :         }

  009ba	e9 71 ff ff ff	 jmp	 $LL36@qsortVS200
$LN80@qsortVS200:

; 1250 : 
; 1251 :         /*     A[i] <= A[mid] for lo <= i < loguy,
; 1252 :                A[i] > A[mid] for higuy < i < hi,
; 1253 :                A[hi] >= A[mid]
; 1254 :                higuy < loguy
; 1255 :            implying:
; 1256 :                higuy == loguy-1
; 1257 :                or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */
; 1258 : 
; 1259 :         /* Find adjacent elements equal to the partition element.  The
; 1260 :            doubled loop is to avoid calling comp(mid,mid), since some
; 1261 :            existing comparison funcs don't work when passed the same value
; 1262 :            for both pointers. */
; 1263 : 
; 1264 :         higuy += width;

  009bf	03 f5		 add	 esi, ebp

; 1265 :         if (mid < higuy) {

  009c1	3b de		 cmp	 ebx, esi
  009c3	73 1b		 jae	 SHORT $LL12@qsortVS200
$LL17@qsortVS200:

; 1266 :             do  {
; 1267 :                 higuy -= width;

  009c5	2b f5		 sub	 esi, ebp

; 1268 :             } while (higuy > mid && compVS2003(higuy, mid) == 0);

  009c7	3b f3		 cmp	 esi, ebx
  009c9	76 15		 jbe	 SHORT $LL12@qsortVS200
  009cb	53		 push	 ebx
  009cc	56		 push	 esi
  009cd	ff 94 24 28 01
	00 00		 call	 DWORD PTR _compVS2003$[esp+276]
  009d4	83 c4 08	 add	 esp, 8
  009d7	85 c0		 test	 eax, eax
  009d9	74 ea		 je	 SHORT $LL17@qsortVS200

; 1269 :         }
; 1270 :         if (mid >= higuy) {

  009db	3b de		 cmp	 ebx, esi
  009dd	72 1b		 jb	 SHORT $LN115@qsortVS200
  009df	90		 npad	 1
$LL12@qsortVS200:

; 1271 :             do  {
; 1272 :                 higuy -= width;
; 1273 :             } while (higuy > lo && compVS2003(higuy, mid) == 0);

  009e0	8b 44 24 14	 mov	 eax, DWORD PTR _lo$[esp+272]
  009e4	2b f5		 sub	 esi, ebp
  009e6	3b f0		 cmp	 esi, eax
  009e8	76 14		 jbe	 SHORT $LN10@qsortVS200
  009ea	53		 push	 ebx
  009eb	56		 push	 esi
  009ec	ff 94 24 28 01
	00 00		 call	 DWORD PTR _compVS2003$[esp+276]
  009f3	83 c4 08	 add	 esp, 8
  009f6	85 c0		 test	 eax, eax
  009f8	74 e6		 je	 SHORT $LL12@qsortVS200
$LN115@qsortVS200:
  009fa	8b 44 24 14	 mov	 eax, DWORD PTR _lo$[esp+272]
$LN10@qsortVS200:

; 1274 :         }
; 1275 : 
; 1276 :         /* OK, now we have the following:
; 1277 :               higuy < loguy
; 1278 :               lo <= higuy <= hi
; 1279 :               A[i]  <= A[mid] for lo <= i <= higuy
; 1280 :               A[i]  == A[mid] for higuy < i < loguy
; 1281 :               A[i]  >  A[mid] for loguy <= i < hi
; 1282 :               A[hi] >= A[mid] */
; 1283 : 
; 1284 :         /* We've finished the partition, now we want to sort the subarrays
; 1285 :            [lo, higuy] and [loguy, hi].
; 1286 :            We do the smaller one first to minimize stack usage.
; 1287 :            We only sort arrays of length 2 or more.*/
; 1288 : 
; 1289 :         if ( higuy - lo >= hi - loguy ) {

  009fe	8b 54 24 10	 mov	 edx, DWORD PTR _hi$[esp+272]
  00a02	8b ca		 mov	 ecx, edx
  00a04	8b de		 mov	 ebx, esi
  00a06	2b cf		 sub	 ecx, edi
  00a08	2b d8		 sub	 ebx, eax
  00a0a	3b d9		 cmp	 ebx, ecx
  00a0c	7c 2d		 jl	 SHORT $LN8@qsortVS200

; 1290 :             if (lo < higuy) {

  00a0e	3b c6		 cmp	 eax, esi
  00a10	73 14		 jae	 SHORT $LN7@qsortVS200

; 1291 :                 lostk[stkptr] = lo;

  00a12	8b 4c 24 1c	 mov	 ecx, DWORD PTR _stkptr$[esp+272]
  00a16	89 44 8c 20	 mov	 DWORD PTR _lostk$[esp+ecx*4+272], eax

; 1292 :                 histk[stkptr] = higuy;

  00a1a	89 b4 8c 98 00
	00 00		 mov	 DWORD PTR _histk$[esp+ecx*4+272], esi

; 1293 :                 ++stkptr;

  00a21	41		 inc	 ecx
  00a22	89 4c 24 1c	 mov	 DWORD PTR _stkptr$[esp+272], ecx
$LN7@qsortVS200:

; 1294 :             }                           /* save big recursion for later */
; 1295 : 
; 1296 :             if (loguy < hi) {

  00a26	3b fa		 cmp	 edi, edx
  00a28	0f 83 2d fe ff
	ff		 jae	 $LN116@qsortVS200

; 1297 :                 lo = loguy;
; 1298 :                 goto recurse;           /* do small recursion */

  00a2e	8b 74 24 10	 mov	 esi, DWORD PTR _hi$[esp+272]
  00a32	89 7c 24 14	 mov	 DWORD PTR _lo$[esp+272], edi
  00a36	e9 fb fd ff ff	 jmp	 $recurse$5432
$LN8@qsortVS200:

; 1299 :             }
; 1300 :         }
; 1301 :         else {
; 1302 :             if (loguy < hi) {

  00a3b	3b fa		 cmp	 edi, edx
  00a3d	73 14		 jae	 SHORT $LN4@qsortVS200

; 1303 :                 lostk[stkptr] = loguy;

  00a3f	8b 4c 24 1c	 mov	 ecx, DWORD PTR _stkptr$[esp+272]
  00a43	89 7c 8c 20	 mov	 DWORD PTR _lostk$[esp+ecx*4+272], edi

; 1304 :                 histk[stkptr] = hi;

  00a47	89 94 8c 98 00
	00 00		 mov	 DWORD PTR _histk$[esp+ecx*4+272], edx

; 1305 :                 ++stkptr;               /* save big recursion for later */

  00a4e	41		 inc	 ecx
  00a4f	89 4c 24 1c	 mov	 DWORD PTR _stkptr$[esp+272], ecx
$LN4@qsortVS200:

; 1306 :             }
; 1307 : 
; 1308 :             if (lo < higuy) {

  00a53	3b c6		 cmp	 eax, esi
  00a55	0f 83 00 fe ff
	ff		 jae	 $LN116@qsortVS200

; 1309 :                 hi = higuy;

  00a5b	89 74 24 10	 mov	 DWORD PTR _hi$[esp+272], esi

; 1310 :                 goto recurse;           /* do small recursion */

  00a5f	e9 d2 fd ff ff	 jmp	 $recurse$5432
$LN126@qsortVS200:
  00a64	5f		 pop	 edi
  00a65	5b		 pop	 ebx
$LN125@qsortVS200:
  00a66	5d		 pop	 ebp
$LN2@qsortVS200:
  00a67	5e		 pop	 esi

; 1322 :         goto recurse;           /* pop subarray from stack */
; 1323 :     }
; 1324 :     else
; 1325 :         return;                 /* all subarrays done */
; 1326 : }

  00a68	81 c4 00 01 00
	00		 add	 esp, 256		; 00000100H
  00a6e	c3		 ret	 0
_qsortVS2003 ENDP
_TEXT	ENDS
PUBLIC	_x$GSCopy$
PUBLIC	__$ArrayPad$
PUBLIC	_HORSPOOL
EXTRN	___security_cookie:DWORD
EXTRN	@__security_check_cookie@4:PROC
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_lastch$ = -1041					; size = 1
_x$GSCopy$ = -1040					; size = 4
$T6597 = -1036						; size = 4
_bm_bc$ = -1032						; size = 1024
__$ArrayPad$ = -4					; size = 4
_y$ = 8							; size = 4
_x$ = 12						; size = 4
_n$ = 16						; size = 4
_m$ = 20						; size = 4
_HORSPOOL PROC

; 1361 :    {

  00a70	55		 push	 ebp
  00a71	8b ec		 mov	 ebp, esp
  00a73	83 e4 f8	 and	 esp, -8			; fffffff8H
  00a76	81 ec 14 04 00
	00		 sub	 esp, 1044		; 00000414H
  00a7c	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00a81	33 c4		 xor	 eax, esp
  00a83	89 84 24 10 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1044], eax

; 1362 :     long i;
; 1363 :     int a, j, bm_bc[ASIZE];
; 1364 :     unsigned char ch, lastch;
; 1365 :    
; 1366 :     /* Preprocessing */
; 1367 :     for (a=0; a < ASIZE; a++) bm_bc[a]=m;

  00a8a	8b 45 14	 mov	 eax, DWORD PTR _m$[ebp]
  00a8d	53		 push	 ebx
  00a8e	8b 5d 0c	 mov	 ebx, DWORD PTR _x$[ebp]
  00a91	56		 push	 esi
  00a92	57		 push	 edi
  00a93	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  00a98	8d 7c 24 18	 lea	 edi, DWORD PTR _bm_bc$[esp+1056]
  00a9c	f3 ab		 rep stosd

; 1368 :     for (j=0; j < m-1; j++) bm_bc[x[j]]=m-j-1;

  00a9e	8d 50 ff	 lea	 edx, DWORD PTR [eax-1]
  00aa1	33 c9		 xor	 ecx, ecx

; 1378 :        i+=bm_bc[ch];

  00aa3	89 5c 24 10	 mov	 DWORD PTR _x$GSCopy$[esp+1056], ebx
  00aa7	85 d2		 test	 edx, edx
  00aa9	7e 13		 jle	 SHORT $LN5@HORSPOOL

; 1368 :     for (j=0; j < m-1; j++) bm_bc[x[j]]=m-j-1;

  00aab	8b f2		 mov	 esi, edx
  00aad	8d 49 00	 npad	 3
$LL7@HORSPOOL:
  00ab0	0f be 3c 0b	 movsx	 edi, BYTE PTR [ebx+ecx]
  00ab4	89 74 bc 18	 mov	 DWORD PTR _bm_bc$[esp+edi*4+1056], esi
  00ab8	41		 inc	 ecx
  00ab9	4e		 dec	 esi
  00aba	3b ca		 cmp	 ecx, edx
  00abc	7c f2		 jl	 SHORT $LL7@HORSPOOL
$LN5@HORSPOOL:

; 1369 :    
; 1370 :     /* Searching */
; 1371 :     lastch=x[m-1];

  00abe	8a 4c 03 ff	 mov	 cl, BYTE PTR [ebx+eax-1]
  00ac2	88 4c 24 0f	 mov	 BYTE PTR _lastch$[esp+1056], cl

; 1372 :     i=0;
; 1373 :     while (i <= n-m) {

  00ac6	8b 4d 10	 mov	 ecx, DWORD PTR _n$[ebp]
  00ac9	33 ff		 xor	 edi, edi
  00acb	2b c8		 sub	 ecx, eax
  00acd	89 4c 24 14	 mov	 DWORD PTR $T6597[esp+1056], ecx
  00ad1	78 6e		 js	 SHORT $LN3@HORSPOOL
  00ad3	8b 75 08	 mov	 esi, DWORD PTR _y$[ebp]
  00ad6	8d 4c 06 ff	 lea	 ecx, DWORD PTR [esi+eax-1]
$LN4@HORSPOOL:

; 1374 :        ch=y[i+m-1];
; 1375 :        if (ch ==lastch)

  00ada	8a 54 24 0f	 mov	 dl, BYTE PTR _lastch$[esp+1056]
  00ade	38 14 39	 cmp	 BYTE PTR [ecx+edi], dl
  00ae1	75 4c		 jne	 SHORT $LN1@HORSPOOL

; 1376 :           //if (memcmp(&y[i],x,m-1) == 0) OUTPUT(i);
; 1377 :           if (memcmp(&y[i],x,m-1) == 0) return(i);

  00ae3	8d 48 ff	 lea	 ecx, DWORD PTR [eax-1]
  00ae6	03 f7		 add	 esi, edi
  00ae8	8b d3		 mov	 edx, ebx
  00aea	83 f9 04	 cmp	 ecx, 4
  00aed	72 15		 jb	 SHORT $LN22@HORSPOOL
  00aef	90		 npad	 1
$LL14@HORSPOOL:
  00af0	8b 1e		 mov	 ebx, DWORD PTR [esi]
  00af2	3b 1a		 cmp	 ebx, DWORD PTR [edx]
  00af4	75 32		 jne	 SHORT $LN27@HORSPOOL
  00af6	83 e9 04	 sub	 ecx, 4
  00af9	83 c2 04	 add	 edx, 4
  00afc	83 c6 04	 add	 esi, 4
  00aff	83 f9 04	 cmp	 ecx, 4
  00b02	73 ec		 jae	 SHORT $LL14@HORSPOOL
$LN22@HORSPOOL:
  00b04	85 c9		 test	 ecx, ecx
  00b06	74 51		 je	 SHORT $LN16@HORSPOOL
  00b08	8a 1a		 mov	 bl, BYTE PTR [edx]
  00b0a	3a 1e		 cmp	 bl, BYTE PTR [esi]
  00b0c	75 1a		 jne	 SHORT $LN27@HORSPOOL
  00b0e	83 f9 01	 cmp	 ecx, 1
  00b11	76 46		 jbe	 SHORT $LN16@HORSPOOL
  00b13	8a 5a 01	 mov	 bl, BYTE PTR [edx+1]
  00b16	3a 5e 01	 cmp	 bl, BYTE PTR [esi+1]
  00b19	75 0d		 jne	 SHORT $LN27@HORSPOOL
  00b1b	83 f9 02	 cmp	 ecx, 2
  00b1e	76 39		 jbe	 SHORT $LN16@HORSPOOL
  00b20	8a 4a 02	 mov	 cl, BYTE PTR [edx+2]
  00b23	3a 4e 02	 cmp	 cl, BYTE PTR [esi+2]
  00b26	74 31		 je	 SHORT $LN16@HORSPOOL
$LN27@HORSPOOL:
  00b28	8b 75 08	 mov	 esi, DWORD PTR _y$[ebp]
  00b2b	8b 5c 24 10	 mov	 ebx, DWORD PTR _x$GSCopy$[esp+1056]
$LN1@HORSPOOL:

; 1378 :        i+=bm_bc[ch];

  00b2f	8d 4c 06 ff	 lea	 ecx, DWORD PTR [esi+eax-1]
  00b33	0f b6 14 39	 movzx	 edx, BYTE PTR [ecx+edi]
  00b37	03 7c 94 18	 add	 edi, DWORD PTR _bm_bc$[esp+edx*4+1056]
  00b3b	3b 7c 24 14	 cmp	 edi, DWORD PTR $T6597[esp+1056]
  00b3f	7e 99		 jle	 SHORT $LN4@HORSPOOL
$LN3@HORSPOOL:

; 1379 :     }
; 1380 :     return(-1);

  00b41	83 c8 ff	 or	 eax, -1

; 1381 :    }

  00b44	5f		 pop	 edi
  00b45	5e		 pop	 esi
  00b46	5b		 pop	 ebx
  00b47	8b 8c 24 10 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1044]
  00b4e	33 cc		 xor	 ecx, esp
  00b50	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00b55	8b e5		 mov	 esp, ebp
  00b57	5d		 pop	 ebp
  00b58	c3		 ret	 0
$LN16@HORSPOOL:
  00b59	8b 8c 24 1c 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1056]
  00b60	8b c7		 mov	 eax, edi
  00b62	5f		 pop	 edi
  00b63	5e		 pop	 esi
  00b64	5b		 pop	 ebx
  00b65	33 cc		 xor	 ecx, esp
  00b67	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00b6c	8b e5		 mov	 esp, ebp
  00b6e	5d		 pop	 ebp
  00b6f	c3		 ret	 0
_HORSPOOL ENDP
_TEXT	ENDS
PUBLIC	__$ArrayPad$
PUBLIC	_Boyer_Moore_Horspool_Kaze
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_i$ = -1052						; size = 4
tv222 = -1048						; size = 4
tv223 = -1044						; size = 4
$T6620 = -1040						; size = 4
tv307 = -1036						; size = 4
_bm_bc$ = -1032						; size = 1024
__$ArrayPad$ = -4					; size = 4
_y$ = 8							; size = 4
_x$ = 12						; size = 4
_n$ = 16						; size = 4
_m$ = 20						; size = 4
_Boyer_Moore_Horspool_Kaze PROC

; 1386 :    {

  00b70	55		 push	 ebp
  00b71	8b ec		 mov	 ebp, esp
  00b73	83 e4 f8	 and	 esp, -8			; fffffff8H
  00b76	81 ec 1c 04 00
	00		 sub	 esp, 1052		; 0000041cH
  00b7c	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00b81	33 c4		 xor	 eax, esp
  00b83	89 84 24 18 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1052], eax

; 1387 :     long i;
; 1388 :     int a, j, bm_bc[ASIZE];
; 1389 :     unsigned char ch;
; 1390 :     //unsigned char ch, lastch;
; 1391 :     //unsigned char firstch;
; 1392 :    
; 1393 :     /* Preprocessing */
; 1394 :     for (a=0; a < ASIZE; a++) bm_bc[a]=m;

  00b8a	8b 45 14	 mov	 eax, DWORD PTR _m$[ebp]
  00b8d	53		 push	 ebx
  00b8e	8b 5d 0c	 mov	 ebx, DWORD PTR _x$[ebp]
  00b91	56		 push	 esi
  00b92	57		 push	 edi
  00b93	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  00b98	8d 7c 24 20	 lea	 edi, DWORD PTR _bm_bc$[esp+1064]
  00b9c	f3 ab		 rep stosd

; 1395 :     for (j=0; j < m-1; j++) bm_bc[x[j]]=m-j-1;

  00b9e	8d 50 ff	 lea	 edx, DWORD PTR [eax-1]
  00ba1	33 c9		 xor	 ecx, ecx
  00ba3	85 d2		 test	 edx, edx
  00ba5	7e 17		 jle	 SHORT $LN4@Boyer_Moor
  00ba7	8b f2		 mov	 esi, edx
  00ba9	8d a4 24 00 00
	00 00		 npad	 7
$LL6@Boyer_Moor:
  00bb0	0f be 3c 0b	 movsx	 edi, BYTE PTR [ebx+ecx]
  00bb4	89 74 bc 20	 mov	 DWORD PTR _bm_bc$[esp+edi*4+1064], esi
  00bb8	41		 inc	 ecx
  00bb9	4e		 dec	 esi
  00bba	3b ca		 cmp	 ecx, edx
  00bbc	7c f2		 jl	 SHORT $LL6@Boyer_Moor
$LN4@Boyer_Moor:

; 1396 :    
; 1397 :     /* Searching */
; 1398 :     //lastch=x[m-1];
; 1399 :     //firstch=x[0];
; 1400 :     i=0;
; 1401 :     while (i <= n-m) {

  00bbe	8b 4d 10	 mov	 ecx, DWORD PTR _n$[ebp]
  00bc1	33 ff		 xor	 edi, edi
  00bc3	2b c8		 sub	 ecx, eax
  00bc5	89 7c 24 0c	 mov	 DWORD PTR _i$[esp+1064], edi
  00bc9	89 4c 24 18	 mov	 DWORD PTR $T6620[esp+1064], ecx
  00bcd	0f 88 94 00 00
	00		 js	 $LN2@Boyer_Moor
  00bd3	8b 4d 08	 mov	 ecx, DWORD PTR _y$[ebp]
  00bd6	8d 54 01 ff	 lea	 edx, DWORD PTR [ecx+eax-1]
  00bda	0f be 4c 03 ff	 movsx	 ecx, BYTE PTR [ebx+eax-1]
  00bdf	89 54 24 1c	 mov	 DWORD PTR tv307[esp+1064], edx
  00be3	89 4c 24 10	 mov	 DWORD PTR tv222[esp+1064], ecx
$LN3@Boyer_Moor:

; 1402 :        ch=y[i+m-1];
; 1403 :        //if (ch ==lastch)
; 1404 :           //if (memcmp(&y[i],x,m-1) == 0) OUTPUT(i);
; 1405 : // Below line gives: 315KB/clock
; 1406 :           //if (ch ==lastch && y[i] == firstch && memcmp(&y[i],x,m-1) == 0) return(i);  // Kaze: The idea(to prevent execution of slower 'memcmp') is borrowed from Karp-Rabin i.e. to perform a slower check only when the target "looks like".
; 1407 : // Below line gives: 328KB/clock
; 1408 :           if (ch ==x[m-1] && y[i] == x[0] && memcmp(&y[i],x,m-1) == 0) return(i);  // Kaze: The idea(to prevent execution of slower 'memcmp') is borrowed from Karp-Rabin i.e. to perform a slower check only when the target "looks like".

  00be7	8b 54 24 1c	 mov	 edx, DWORD PTR tv307[esp+1064]
  00beb	0f b6 0c 3a	 movzx	 ecx, BYTE PTR [edx+edi]
  00bef	89 4c 24 14	 mov	 DWORD PTR tv223[esp+1064], ecx
  00bf3	3b 4c 24 10	 cmp	 ecx, DWORD PTR tv222[esp+1064]
  00bf7	75 5c		 jne	 SHORT $LN1@Boyer_Moor
  00bf9	8b 4d 08	 mov	 ecx, DWORD PTR _y$[ebp]
  00bfc	8a 14 0f	 mov	 dl, BYTE PTR [edi+ecx]
  00bff	8d 34 0f	 lea	 esi, DWORD PTR [edi+ecx]
  00c02	3a 13		 cmp	 dl, BYTE PTR [ebx]
  00c04	75 4f		 jne	 SHORT $LN1@Boyer_Moor
  00c06	8d 48 ff	 lea	 ecx, DWORD PTR [eax-1]
  00c09	8b d3		 mov	 edx, ebx
  00c0b	83 f9 04	 cmp	 ecx, 4
  00c0e	72 18		 jb	 SHORT $LN21@Boyer_Moor
$LL13@Boyer_Moor:
  00c10	8b 3e		 mov	 edi, DWORD PTR [esi]
  00c12	3b 3a		 cmp	 edi, DWORD PTR [edx]
  00c14	75 3b		 jne	 SHORT $LN27@Boyer_Moor
  00c16	83 e9 04	 sub	 ecx, 4
  00c19	83 c2 04	 add	 edx, 4
  00c1c	83 c6 04	 add	 esi, 4
  00c1f	83 f9 04	 cmp	 ecx, 4
  00c22	73 ec		 jae	 SHORT $LL13@Boyer_Moor
  00c24	8b 7c 24 0c	 mov	 edi, DWORD PTR _i$[esp+1064]
$LN21@Boyer_Moor:
  00c28	85 c9		 test	 ecx, ecx
  00c2a	74 53		 je	 SHORT $LN15@Boyer_Moor
  00c2c	8a 02		 mov	 al, BYTE PTR [edx]
  00c2e	3a 06		 cmp	 al, BYTE PTR [esi]
  00c30	75 1a		 jne	 SHORT $LN26@Boyer_Moor
  00c32	83 f9 01	 cmp	 ecx, 1
  00c35	76 48		 jbe	 SHORT $LN15@Boyer_Moor
  00c37	8a 42 01	 mov	 al, BYTE PTR [edx+1]
  00c3a	3a 46 01	 cmp	 al, BYTE PTR [esi+1]
  00c3d	75 0d		 jne	 SHORT $LN26@Boyer_Moor
  00c3f	83 f9 02	 cmp	 ecx, 2
  00c42	76 3b		 jbe	 SHORT $LN15@Boyer_Moor
  00c44	8a 4a 02	 mov	 cl, BYTE PTR [edx+2]
  00c47	3a 4e 02	 cmp	 cl, BYTE PTR [esi+2]
  00c4a	74 33		 je	 SHORT $LN15@Boyer_Moor
$LN26@Boyer_Moor:
  00c4c	8b 45 14	 mov	 eax, DWORD PTR _m$[ebp]
  00c4f	eb 04		 jmp	 SHORT $LN1@Boyer_Moor
$LN27@Boyer_Moor:
  00c51	8b 7c 24 0c	 mov	 edi, DWORD PTR _i$[esp+1064]
$LN1@Boyer_Moor:

; 1409 :        i+=bm_bc[ch];

  00c55	8b 54 24 14	 mov	 edx, DWORD PTR tv223[esp+1064]
  00c59	03 7c 94 20	 add	 edi, DWORD PTR _bm_bc$[esp+edx*4+1064]
  00c5d	89 7c 24 0c	 mov	 DWORD PTR _i$[esp+1064], edi
  00c61	3b 7c 24 18	 cmp	 edi, DWORD PTR $T6620[esp+1064]
  00c65	7e 80		 jle	 SHORT $LN3@Boyer_Moor
$LN2@Boyer_Moor:

; 1410 :     }
; 1411 :     return(-1);

  00c67	83 c8 ff	 or	 eax, -1

; 1412 :    }

  00c6a	5f		 pop	 edi
  00c6b	5e		 pop	 esi
  00c6c	5b		 pop	 ebx
  00c6d	8b 8c 24 18 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1052]
  00c74	33 cc		 xor	 ecx, esp
  00c76	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00c7b	8b e5		 mov	 esp, ebp
  00c7d	5d		 pop	 ebp
  00c7e	c3		 ret	 0
$LN15@Boyer_Moor:
  00c7f	8b 8c 24 24 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1064]
  00c86	8b c7		 mov	 eax, edi
  00c88	5f		 pop	 edi
  00c89	5e		 pop	 esi
  00c8a	5b		 pop	 ebx
  00c8b	33 cc		 xor	 ecx, esp
  00c8d	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00c92	8b e5		 mov	 esp, ebp
  00c94	5d		 pop	 ebp
  00c95	c3		 ret	 0
_Boyer_Moore_Horspool_Kaze ENDP
_TEXT	ENDS
PUBLIC	_Brute_Force_Dummy
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_y$ = 8							; size = 4
_x$ = 12						; size = 4
_n$ = 16						; size = 4
_m$ = 20						; size = 4
_Brute_Force_Dummy PROC

; 1418 :     long i, j;
; 1419 :   
; 1420 :     /* Searching */
; 1421 :     for (i=0; i <= n-m; i++) {

  00ca0	8b 54 24 10	 mov	 edx, DWORD PTR _m$[esp-4]
  00ca4	53		 push	 ebx
  00ca5	55		 push	 ebp
  00ca6	8b 6c 24 14	 mov	 ebp, DWORD PTR _n$[esp+4]
  00caa	56		 push	 esi
  00cab	57		 push	 edi
  00cac	33 ff		 xor	 edi, edi
  00cae	2b ea		 sub	 ebp, edx
  00cb0	78 2d		 js	 SHORT $LN4@Brute_Forc
  00cb2	8b 44 24 18	 mov	 eax, DWORD PTR _x$[esp+12]
$LL6@Brute_Forc:

; 1422 :        j=0;

  00cb6	33 c9		 xor	 ecx, ecx

; 1423 :        while (j < m && y[i+j] == x[j]) j++;

  00cb8	85 d2		 test	 edx, edx
  00cba	7e 13		 jle	 SHORT $LN11@Brute_Forc
  00cbc	8b 74 24 14	 mov	 esi, DWORD PTR _y$[esp+12]
  00cc0	03 f7		 add	 esi, edi
$LL3@Brute_Forc:
  00cc2	8a 1c 0e	 mov	 bl, BYTE PTR [esi+ecx]
  00cc5	3a 1c 01	 cmp	 bl, BYTE PTR [ecx+eax]
  00cc8	75 0c		 jne	 SHORT $LN2@Brute_Forc
  00cca	41		 inc	 ecx
  00ccb	3b ca		 cmp	 ecx, edx
  00ccd	7c f3		 jl	 SHORT $LL3@Brute_Forc
$LN11@Brute_Forc:

; 1424 :        if (j >= m) return(i);

  00ccf	8b c7		 mov	 eax, edi
  00cd1	5f		 pop	 edi
  00cd2	5e		 pop	 esi
  00cd3	5d		 pop	 ebp
  00cd4	5b		 pop	 ebx

; 1427 :    }

  00cd5	c3		 ret	 0
$LN2@Brute_Forc:

; 1424 :        if (j >= m) return(i);

  00cd6	3b ca		 cmp	 ecx, edx
  00cd8	7d f5		 jge	 SHORT $LN11@Brute_Forc

; 1418 :     long i, j;
; 1419 :   
; 1420 :     /* Searching */
; 1421 :     for (i=0; i <= n-m; i++) {

  00cda	47		 inc	 edi
  00cdb	3b fd		 cmp	 edi, ebp
  00cdd	7e d7		 jle	 SHORT $LL6@Brute_Forc
$LN4@Brute_Forc:
  00cdf	5f		 pop	 edi
  00ce0	5e		 pop	 esi
  00ce1	5d		 pop	 ebp

; 1425 :     }
; 1426 :     return(-1);

  00ce2	83 c8 ff	 or	 eax, -1
  00ce5	5b		 pop	 ebx

; 1427 :    }

  00ce6	c3		 ret	 0
_Brute_Force_Dummy ENDP
_TEXT	ENDS
PUBLIC	_Karp_Rabin
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_d$ = -4						; size = 4
_y$ = 8							; size = 4
_x$ = 12						; size = 4
$T6648 = 16						; size = 4
_n$ = 16						; size = 4
tv185 = 20						; size = 4
_hx$ = 20						; size = 4
_m$ = 20						; size = 4
_Karp_Rabin PROC

; 1433 :    long Karp_Rabin(char *y, char *x, long n, int m) {

  00cf0	51		 push	 ecx
  00cf1	53		 push	 ebx
  00cf2	55		 push	 ebp

; 1434 :    int d, hx, hy, i, j;
; 1435 : 
; 1436 :    /* Preprocessing */
; 1437 :    /* computes d = 2^(m-1) with
; 1438 :       the left-shift operator */
; 1439 :    for (d = i = 1; i < m; ++i)

  00cf3	8b 6c 24 1c	 mov	 ebp, DWORD PTR _m$[esp+8]
  00cf7	b8 01 00 00 00	 mov	 eax, 1
  00cfc	56		 push	 esi
  00cfd	57		 push	 edi
  00cfe	89 44 24 10	 mov	 DWORD PTR _d$[esp+20], eax
  00d02	3b e8		 cmp	 ebp, eax
  00d04	7e 13		 jle	 SHORT $LN7@Karp_Rabin
  00d06	8d 4d ff	 lea	 ecx, DWORD PTR [ebp-1]
  00d09	8d a4 24 00 00
	00 00		 npad	 7
$LL9@Karp_Rabin:

; 1440 :       d = (d<<1);

  00d10	03 c0		 add	 eax, eax
  00d12	49		 dec	 ecx
  00d13	75 fb		 jne	 SHORT $LL9@Karp_Rabin
  00d15	89 44 24 10	 mov	 DWORD PTR _d$[esp+20], eax
$LN7@Karp_Rabin:

; 1441 : 
; 1442 :    for (hy = hx = i = 0; i < m; ++i) {

  00d19	8b 74 24 18	 mov	 esi, DWORD PTR _y$[esp+16]
  00d1d	33 ff		 xor	 edi, edi
  00d1f	33 d2		 xor	 edx, edx
  00d21	89 7c 24 24	 mov	 DWORD PTR _hx$[esp+16], edi
  00d25	85 ed		 test	 ebp, ebp
  00d27	7e 24		 jle	 SHORT $LN4@Karp_Rabin
  00d29	8b 4c 24 1c	 mov	 ecx, DWORD PTR _x$[esp+16]
  00d2d	8b c6		 mov	 eax, esi
  00d2f	2b ce		 sub	 ecx, esi
  00d31	89 6c 24 24	 mov	 DWORD PTR tv185[esp+16], ebp
$LL6@Karp_Rabin:

; 1443 :       hx = ((hx<<1) + x[i]);

  00d35	0f be 1c 01	 movsx	 ebx, BYTE PTR [ecx+eax]
  00d39	8d 3c 7b	 lea	 edi, DWORD PTR [ebx+edi*2]

; 1444 :       hy = ((hy<<1) + y[i]);

  00d3c	0f be 18	 movsx	 ebx, BYTE PTR [eax]
  00d3f	40		 inc	 eax
  00d40	ff 4c 24 24	 dec	 DWORD PTR tv185[esp+16]
  00d44	8d 14 53	 lea	 edx, DWORD PTR [ebx+edx*2]
  00d47	75 ec		 jne	 SHORT $LL6@Karp_Rabin

; 1443 :       hx = ((hx<<1) + x[i]);

  00d49	89 7c 24 24	 mov	 DWORD PTR _hx$[esp+16], edi
$LN4@Karp_Rabin:

; 1445 :    }
; 1446 : 
; 1447 :    /* Searching */
; 1448 :    j = 0;
; 1449 :    while (j <= n-m) {

  00d4d	8b 4c 24 20	 mov	 ecx, DWORD PTR _n$[esp+16]
  00d51	33 c0		 xor	 eax, eax
  00d53	2b cd		 sub	 ecx, ebp
  00d55	89 4c 24 20	 mov	 DWORD PTR $T6648[esp+16], ecx
  00d59	78 74		 js	 SHORT $LN2@Karp_Rabin
  00d5b	eb 03 8d 49 00	 npad	 5
$LL3@Karp_Rabin:

; 1450 :       if (hx == hy && memcmp(x, y + j, m) == 0) return(j);

  00d60	3b fa		 cmp	 edi, edx
  00d62	75 51		 jne	 SHORT $LN1@Karp_Rabin
  00d64	8b 7c 24 1c	 mov	 edi, DWORD PTR _x$[esp+16]
  00d68	03 f0		 add	 esi, eax
  00d6a	8b cd		 mov	 ecx, ebp
  00d6c	83 fd 04	 cmp	 ebp, 4
  00d6f	72 14		 jb	 SHORT $LN21@Karp_Rabin
$LL13@Karp_Rabin:
  00d71	8b 1f		 mov	 ebx, DWORD PTR [edi]
  00d73	3b 1e		 cmp	 ebx, DWORD PTR [esi]
  00d75	75 32		 jne	 SHORT $LN26@Karp_Rabin
  00d77	83 e9 04	 sub	 ecx, 4
  00d7a	83 c6 04	 add	 esi, 4
  00d7d	83 c7 04	 add	 edi, 4
  00d80	83 f9 04	 cmp	 ecx, 4
  00d83	73 ec		 jae	 SHORT $LL13@Karp_Rabin
$LN21@Karp_Rabin:
  00d85	85 c9		 test	 ecx, ecx
  00d87	74 49		 je	 SHORT $LN10@Karp_Rabin
  00d89	8a 1e		 mov	 bl, BYTE PTR [esi]
  00d8b	3a 1f		 cmp	 bl, BYTE PTR [edi]
  00d8d	75 1a		 jne	 SHORT $LN26@Karp_Rabin
  00d8f	83 f9 01	 cmp	 ecx, 1
  00d92	76 3e		 jbe	 SHORT $LN10@Karp_Rabin
  00d94	8a 5e 01	 mov	 bl, BYTE PTR [esi+1]
  00d97	3a 5f 01	 cmp	 bl, BYTE PTR [edi+1]
  00d9a	75 0d		 jne	 SHORT $LN26@Karp_Rabin
  00d9c	83 f9 02	 cmp	 ecx, 2
  00d9f	76 31		 jbe	 SHORT $LN10@Karp_Rabin
  00da1	8a 4e 02	 mov	 cl, BYTE PTR [esi+2]
  00da4	3a 4f 02	 cmp	 cl, BYTE PTR [edi+2]
  00da7	74 29		 je	 SHORT $LN10@Karp_Rabin
$LN26@Karp_Rabin:
  00da9	8b 74 24 18	 mov	 esi, DWORD PTR _y$[esp+16]
  00dad	8b 7c 24 24	 mov	 edi, DWORD PTR _hx$[esp+16]
  00db1	8b 4c 24 20	 mov	 ecx, DWORD PTR $T6648[esp+16]
$LN1@Karp_Rabin:

; 1451 :       hy = REHASH(y[j], y[j + m], hy);

  00db5	0f be 1c 30	 movsx	 ebx, BYTE PTR [eax+esi]
  00db9	0f af 5c 24 10	 imul	 ebx, DWORD PTR _d$[esp+20]
  00dbe	2b d3		 sub	 edx, ebx
  00dc0	8d 1c 30	 lea	 ebx, DWORD PTR [eax+esi]
  00dc3	0f be 1c 2b	 movsx	 ebx, BYTE PTR [ebx+ebp]

; 1452 :       ++j;

  00dc7	40		 inc	 eax
  00dc8	8d 14 53	 lea	 edx, DWORD PTR [ebx+edx*2]
  00dcb	3b c1		 cmp	 eax, ecx
  00dcd	7e 91		 jle	 SHORT $LL3@Karp_Rabin
$LN2@Karp_Rabin:

; 1453 :    }
; 1454 :     return(-1);

  00dcf	83 c8 ff	 or	 eax, -1
$LN10@Karp_Rabin:
  00dd2	5f		 pop	 edi
  00dd3	5e		 pop	 esi
  00dd4	5d		 pop	 ebp
  00dd5	5b		 pop	 ebx

; 1455 :    }

  00dd6	59		 pop	 ecx
  00dd7	c3		 ret	 0
_Karp_Rabin ENDP
_TEXT	ENDS
PUBLIC	_KarpRabinKaze
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_pbTargetMax$ = -4					; size = 4
_ulHashPattern$ = 8					; size = 4
_pbTarget$ = 8						; size = 4
_pbPattern$ = 12					; size = 4
tv199 = 16						; size = 4
_cbTarget$ = 16						; size = 4
_cbPattern$ = 20					; size = 4
_KarpRabinKaze PROC

; 1464 : {

  00de0	51		 push	 ecx

; 1465 :     unsigned int    i;
; 1466 :     char *  pbTargetMax = pbTarget + cbTarget;

  00de1	8b 44 24 10	 mov	 eax, DWORD PTR _cbTarget$[esp]
  00de5	55		 push	 ebp
  00de6	8b 6c 24 0c	 mov	 ebp, DWORD PTR _pbTarget$[esp+4]
  00dea	8d 0c 28	 lea	 ecx, DWORD PTR [eax+ebp]
  00ded	57		 push	 edi

; 1467 :     char *  pbPatternMax = pbPattern + cbPattern;

  00dee	8b 7c 24 1c	 mov	 edi, DWORD PTR _cbPattern$[esp+8]
  00df2	89 4c 24 08	 mov	 DWORD PTR _pbTargetMax$[esp+12], ecx
  00df6	8b 4c 24 14	 mov	 ecx, DWORD PTR _pbPattern$[esp+8]
  00dfa	8d 14 39	 lea	 edx, DWORD PTR [ecx+edi]

; 1468 :     unsigned long  ulBaseToPowerMod = 1;
; 1469 :     register unsigned long  ulHashPattern = 0;
; 1470 :     unsigned long  ulHashTarget = 0;
; 1471 : long hits = 0;
; 1472 : //unsigned long count;
; 1473 :     //char *  buf1;
; 1474 :     //char *  buf2;
; 1475 : 
; 1476 :     if (cbPattern > cbTarget)

  00dfd	3b f8		 cmp	 edi, eax
  00dff	76 06		 jbe	 SHORT $LN16@KarpRabinK

; 1477 :         return(NULL);

  00e01	5f		 pop	 edi
  00e02	33 c0		 xor	 eax, eax
  00e04	5d		 pop	 ebp

; 1559 : }

  00e05	59		 pop	 ecx
  00e06	c3		 ret	 0
$LN16@KarpRabinK:

; 1478 : 
; 1479 :     // Compute the power of the left most character in base ulBase
; 1480 :     //for (i = 1; i < cbPattern; i++) ulBaseToPowerMod = (ulBase * ulBaseToPowerMod);
; 1481 : 
; 1482 :     // Calculate the hash function for the src (and the first dst)
; 1483 :     while (pbPattern < pbPatternMax)

  00e07	3b ca		 cmp	 ecx, edx
  00e09	73 06		 jae	 SHORT $LN6@KarpRabinK
  00e0b	2b d1		 sub	 edx, ecx
  00e0d	03 ca		 add	 ecx, edx
  00e0f	03 ea		 add	 ebp, edx
$LN6@KarpRabinK:

; 1484 :     {
; 1485 :         // Below lines give 366KB/clock for 'underdog':
; 1486 :         //ulHashPattern = (ulHashPattern*ulBase + *pbPattern);
; 1487 :         //ulHashTarget = (ulHashTarget*ulBase + *pbTarget);
; 1488 :         pbPattern++;
; 1489 :         pbTarget++;
; 1490 :     }
; 1491 :         // Below lines give 436KB/clock for 'underdog' + requirement pattern to be 4 chars min.:
; 1492 :         //ulHashPattern = ( (*(long *)(pbPattern-cbPattern)) & 0xffffff00 ) + *(pbPattern-1);
; 1493 :         //ulHashTarget = ( (*(long *)(pbTarget-cbPattern)) & 0xffffff00 ) + *(pbTarget-1);
; 1494 :         // Below lines give 482KB/clock for 'underdog' + requirement pattern to be 2 chars min.:
; 1495 :         //ulHashPattern = ( (*(unsigned short *)(pbPattern-cbPattern)) | *(pbPattern-1) );
; 1496 :         //ulHashTarget = ( (*(unsigned short *)(pbTarget-cbPattern)) | *(pbTarget-1) );
; 1497 :         // Below lines give 482KB/clock for 'underdog' + requirement pattern to be 2 chars min.:
; 1498 :         //ulHashPattern = ( (*(unsigned short *)(pbPattern-cbPattern)) & 0xff00 ) + *(pbPattern-1);
; 1499 :         //ulHashTarget = ( (*(unsigned short *)(pbTarget-cbPattern)) & 0xff00 ) + *(pbTarget-1);
; 1500 :         // Below lines give 605KB/clock for 'underdog' + requirement pattern to be 2 chars min.:
; 1501 :         //ulHashPattern = ( (*(unsigned short *)(pbPattern-cbPattern))<<8 ) + *(pbPattern-1);
; 1502 :         //ulHashTarget = ( (*(unsigned short *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1);
; 1503 :         // Below lines give 668KB/clock for 'underdog':
; 1504 :         ulHashPattern = ( (*(char *)(pbPattern-cbPattern))<<8 ) + *(pbPattern-1);

  00e11	0f be 51 ff	 movsx	 edx, BYTE PTR [ecx-1]

; 1505 :         ulHashTarget = ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1);

  00e15	0f be 45 ff	 movsx	 eax, BYTE PTR [ebp-1]
  00e19	53		 push	 ebx
  00e1a	56		 push	 esi
  00e1b	8b f1		 mov	 esi, ecx
  00e1d	2b f7		 sub	 esi, edi
  00e1f	0f be 1e	 movsx	 ebx, BYTE PTR [esi]
  00e22	c1 e3 08	 shl	 ebx, 8
  00e25	03 da		 add	 ebx, edx
  00e27	8b d5		 mov	 edx, ebp
  00e29	2b d7		 sub	 edx, edi
  00e2b	0f be 0a	 movsx	 ecx, BYTE PTR [edx]
  00e2e	c1 e1 08	 shl	 ecx, 8
  00e31	03 c8		 add	 ecx, eax
  00e33	89 74 24 20	 mov	 DWORD PTR tv199[esp+16], esi
  00e37	89 5c 24 18	 mov	 DWORD PTR _ulHashPattern$[esp+16], ebx
  00e3b	8b c2		 mov	 eax, edx
  00e3d	8d 49 00	 npad	 3
$LL4@KarpRabinK:

; 1506 : 
; 1507 :     // Dynamically produce hash values for the string as we go
; 1508 :     for ( ;; )
; 1509 :     {
; 1510 :         if ( (ulHashPattern == ulHashTarget) && !memcmp(pbPattern-cbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )

  00e40	3b d9		 cmp	 ebx, ecx
  00e42	75 4c		 jne	 SHORT $LN2@KarpRabinK
  00e44	8b cf		 mov	 ecx, edi
  00e46	8b d0		 mov	 edx, eax
  00e48	83 ff 04	 cmp	 edi, 4
  00e4b	72 17		 jb	 SHORT $LN19@KarpRabinK
  00e4d	8d 49 00	 npad	 3
$LL11@KarpRabinK:
  00e50	8b 1e		 mov	 ebx, DWORD PTR [esi]
  00e52	3b 1a		 cmp	 ebx, DWORD PTR [edx]
  00e54	75 32		 jne	 SHORT $LN23@KarpRabinK
  00e56	83 e9 04	 sub	 ecx, 4
  00e59	83 c2 04	 add	 edx, 4
  00e5c	83 c6 04	 add	 esi, 4
  00e5f	83 f9 04	 cmp	 ecx, 4
  00e62	73 ec		 jae	 SHORT $LL11@KarpRabinK
$LN19@KarpRabinK:
  00e64	85 c9		 test	 ecx, ecx
  00e66	74 3f		 je	 SHORT $LN13@KarpRabinK
  00e68	8a 1a		 mov	 bl, BYTE PTR [edx]
  00e6a	3a 1e		 cmp	 bl, BYTE PTR [esi]
  00e6c	75 1a		 jne	 SHORT $LN23@KarpRabinK
  00e6e	83 f9 01	 cmp	 ecx, 1
  00e71	76 34		 jbe	 SHORT $LN13@KarpRabinK
  00e73	8a 5a 01	 mov	 bl, BYTE PTR [edx+1]
  00e76	3a 5e 01	 cmp	 bl, BYTE PTR [esi+1]
  00e79	75 0d		 jne	 SHORT $LN23@KarpRabinK
  00e7b	83 f9 02	 cmp	 ecx, 2
  00e7e	76 27		 jbe	 SHORT $LN13@KarpRabinK
  00e80	8a 4a 02	 mov	 cl, BYTE PTR [edx+2]
  00e83	3a 4e 02	 cmp	 cl, BYTE PTR [esi+2]
  00e86	74 1f		 je	 SHORT $LN13@KarpRabinK
$LN23@KarpRabinK:
  00e88	8b 5c 24 18	 mov	 ebx, DWORD PTR _ulHashPattern$[esp+16]
  00e8c	8b 74 24 20	 mov	 esi, DWORD PTR tv199[esp+16]
$LN2@KarpRabinK:

; 1524 :             //hits++;
; 1525 :                                                              
; 1526 :         if (pbTarget == pbTargetMax)

  00e90	3b 6c 24 10	 cmp	 ebp, DWORD PTR _pbTargetMax$[esp+20]
  00e94	74 1b		 je	 SHORT $LN20@KarpRabinK

; 1528 : 
; 1529 :         // Below line gives 482KB/clock for 'underdog' + requirement pattern to be 2 chars min.:
; 1530 :         //ulHashTarget = ( (*(unsigned short *)(pbTarget+1-cbPattern)) | *pbTarget );
; 1531 :         // Below line gives 436KB/clock for 'underdog' + requirement pattern to be 4 chars min.:
; 1532 :         //ulHashTarget = ( (*(long *)(pbTarget+1-cbPattern)) & 0xffffff00 ) + *pbTarget;
; 1533 : //; Line 696
; 1534 : //        movsx   esi, BYTE PTR [ebx]
; 1535 : //        mov     ecx, DWORD PTR [edx+1]
; 1536 : //        and     ecx, -256                               ; ffffff00H
; 1537 : //        add     ecx, esi
; 1538 :         // Below line gives 482KB/clock for 'underdog' + requirement pattern to be 2 chars min.:
; 1539 :         //ulHashTarget = ( (*(unsigned short *)(pbTarget+1-cbPattern)) & 0xff00 ) + *pbTarget;
; 1540 : //; Line 691
; 1541 : //        movsx   esi, BYTE PTR [ebx]
; 1542 : //        xor     ecx, ecx
; 1543 : //        mov     cx, WORD PTR [edx+1]
; 1544 : //        and     ecx, 65280                              ; 0000ff00H
; 1545 : //        add     ecx, esi
; 1546 :         // Below line gives 605KB/clock for 'underdog' + requirement pattern to be 2 chars min.:
; 1547 :         //ulHashTarget = ( (*(unsigned short *)(pbTarget+1-cbPattern))<<8 ) + *pbTarget;
; 1548 :         // Below line gives 668KB/clock for 'underdog':
; 1549 :         ulHashTarget = ( (*(char *)(pbTarget+1-cbPattern))<<8 ) + *pbTarget;

  00e96	0f be 48 01	 movsx	 ecx, BYTE PTR [eax+1]
  00e9a	0f be 55 00	 movsx	 edx, BYTE PTR [ebp]
  00e9e	c1 e1 08	 shl	 ecx, 8
  00ea1	03 ca		 add	 ecx, edx

; 1550 : //; Line 718
; 1551 : //        movsx   ecx, BYTE PTR [eax+1]
; 1552 : //        movsx   edx, BYTE PTR [ebp]
; 1553 : //        shl     ecx, 8
; 1554 : //        add     ecx, edx
; 1555 :         // Below line gives 366KB/clock for 'underdog':
; 1556 :         //ulHashTarget = (ulHashTarget - *(pbTarget-cbPattern)*ulBaseToPowerMod)*ulBase + *pbTarget;
; 1557 :         pbTarget++;

  00ea3	45		 inc	 ebp
  00ea4	40		 inc	 eax

; 1558 :     }

  00ea5	eb 99		 jmp	 SHORT $LL4@KarpRabinK
$LN13@KarpRabinK:
  00ea7	5e		 pop	 esi

; 1511 :        // if ( ulHashPattern == ulHashTarget ) {
; 1512 :        // 
; 1513 :        //  count = cbPattern;
; 1514 :        //  buf1 = pbPattern-cbPattern;
; 1515 :        //  buf2 = pbTarget-cbPattern;
; 1516 :        //  while ( --count && *(char *)buf1 == *(char *)buf2 ) {
; 1517 :        //          buf1 = (char *)buf1 + 1;
; 1518 :        //          buf2 = (char *)buf2 + 1;
; 1519 :        //  }
; 1520 :        //                 
; 1521 :        //  if ( *((unsigned char *)buf1) - *((unsigned char *)buf2) == 0) hits++;
; 1522 :        //  }
; 1523 :             return((pbTarget-cbPattern));

  00ea8	8b c5		 mov	 eax, ebp
  00eaa	5b		 pop	 ebx
  00eab	2b c7		 sub	 eax, edi
  00ead	5f		 pop	 edi
  00eae	5d		 pop	 ebp

; 1559 : }

  00eaf	59		 pop	 ecx
  00eb0	c3		 ret	 0
$LN20@KarpRabinK:
  00eb1	5e		 pop	 esi
  00eb2	5b		 pop	 ebx
  00eb3	5f		 pop	 edi

; 1527 :             return(NULL);

  00eb4	33 c0		 xor	 eax, eax
  00eb6	5d		 pop	 ebp

; 1559 : }

  00eb7	59		 pop	 ecx
  00eb8	c3		 ret	 0
_KarpRabinKaze ENDP
_TEXT	ENDS
PUBLIC	_pbPattern$GSCopy$
PUBLIC	__$ArrayPad$
PUBLIC	_Railgun
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
tv542 = -1048						; size = 4
_pbPattern$GSCopy$ = -1048				; size = 4
$T6686 = -1044						; size = 4
_ulHashPattern$ = -1044					; size = 4
tv545 = -1040						; size = 4
tv413 = -1040						; size = 4
tv297 = -1036						; size = 4
_pbTargetMax$ = -1036					; size = 4
_countSTATIC$ = -1032					; size = 4
_bm_bc$ = -1028						; size = 1024
__$ArrayPad$ = -4					; size = 4
_pbTarget$ = 8						; size = 4
_pbPattern$ = 12					; size = 4
_cbTarget$ = 16						; size = 4
_cbPattern$ = 20					; size = 4
_Railgun PROC

; 1569 : {

  00ec0	81 ec 18 04 00
	00		 sub	 esp, 1048		; 00000418H
  00ec6	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00ecb	33 c4		 xor	 eax, esp
  00ecd	89 84 24 14 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1048], eax

; 1570 :     char *  pbTargetMax = pbTarget + cbTarget;
; 1571 :     register unsigned long  ulHashPattern;
; 1572 :     unsigned long  ulHashTarget;
; 1573 :     unsigned long  count;
; 1574 :     unsigned long  countSTATIC, countRemainder;
; 1575 : 
; 1576 :     long i; //BMH needed
; 1577 :     int a, j, bm_bc[ASIZE]; //BMH needed
; 1578 :     unsigned char ch; //BMH needed
; 1579 : //    unsigned char lastch, firstch; //BMH needed
; 1580 : 
; 1581 :     if (cbPattern > cbTarget)

  00ed4	8b 94 24 28 04
	00 00		 mov	 edx, DWORD PTR _cbPattern$[esp+1044]
  00edb	53		 push	 ebx
  00edc	8b 9c 24 24 04
	00 00		 mov	 ebx, DWORD PTR _pbPattern$[esp+1048]
  00ee3	55		 push	 ebp
  00ee4	8b ac 24 24 04
	00 00		 mov	 ebp, DWORD PTR _pbTarget$[esp+1052]
  00eeb	56		 push	 esi
  00eec	8b b4 24 30 04
	00 00		 mov	 esi, DWORD PTR _cbTarget$[esp+1056]
  00ef3	8d 04 2e	 lea	 eax, DWORD PTR [esi+ebp]

; 1660 :          }
; 1661 :          if ( count == 0) return(pbTarget+i);

  00ef6	89 5c 24 0c	 mov	 DWORD PTR _pbPattern$GSCopy$[esp+1060], ebx
  00efa	89 44 24 18	 mov	 DWORD PTR _pbTargetMax$[esp+1060], eax
  00efe	3b d6		 cmp	 edx, esi
  00f00	76 1a		 jbe	 SHORT $LN22@Railgun

; 1582 :         return(NULL);

  00f02	5e		 pop	 esi
  00f03	5d		 pop	 ebp
  00f04	33 c0		 xor	 eax, eax
  00f06	5b		 pop	 ebx

; 1666 : }
; 1667 : }

  00f07	8b 8c 24 14 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1048]
  00f0e	33 cc		 xor	 ecx, esp
  00f10	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00f15	81 c4 18 04 00
	00		 add	 esp, 1048		; 00000418H
  00f1b	c3		 ret	 0
$LN22@Railgun:

; 1583 : 
; 1584 :         countSTATIC = cbPattern-2;

  00f1c	8d 4a fe	 lea	 ecx, DWORD PTR [edx-2]
  00f1f	57		 push	 edi
  00f20	89 4c 24 20	 mov	 DWORD PTR _countSTATIC$[esp+1064], ecx

; 1585 : 
; 1586 : // Doesn't work when cbPattern = 1
; 1587 : if (cbTarget<961) // This value is arbitrary(don't know how exactly), it ensures(at least must) better performance than 'Boyer_Moore_Horspool'.

  00f24	81 fe c1 03 00
	00		 cmp	 esi, 961		; 000003c1H
  00f2a	0f 83 94 00 00
	00		 jae	 $LN21@Railgun

; 1588 : {
; 1589 :         pbTarget = pbTarget+cbPattern;
; 1590 :         ulHashPattern = ( (*(char *)(pbPattern))<<8 ) + *(pbPattern+(cbPattern-1));

  00f30	0f be 03	 movsx	 eax, BYTE PTR [ebx]
  00f33	0f be 4c 13 ff	 movsx	 ecx, BYTE PTR [ebx+edx-1]
  00f38	c1 e0 08	 shl	 eax, 8
  00f3b	03 c8		 add	 ecx, eax

; 1638 :     }

  00f3d	b8 02 00 00 00	 mov	 eax, 2
  00f42	2b c2		 sub	 eax, edx
  00f44	bf 01 00 00 00	 mov	 edi, 1
  00f49	03 ea		 add	 ebp, edx
  00f4b	2b fa		 sub	 edi, edx
  00f4d	89 4c 24 14	 mov	 DWORD PTR _ulHashPattern$[esp+1064], ecx
  00f51	89 44 24 10	 mov	 DWORD PTR tv542[esp+1064], eax
  00f55	89 7c 24 18	 mov	 DWORD PTR tv545[esp+1064], edi
  00f59	8d a4 24 00 00
	00 00		 npad	 7
$LL20@Railgun:

; 1591 : 
; 1592 :     for ( ;; )
; 1593 :     {
; 1594 :         // The line below gives for 'cbPattern'>=1:
; 1595 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 1596 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 1597 : /*
; 1598 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 1599 :             return((long)(pbTarget-cbPattern));
; 1600 : */
; 1601 : 
; 1602 :         // The fragment below gives for 'cbPattern'>=2:
; 1603 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 1604 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 1605 : 
; 1606 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {

  00f60	0f be 44 2f ff	 movsx	 eax, BYTE PTR [edi+ebp-1]
  00f65	0f be 75 ff	 movsx	 esi, BYTE PTR [ebp-1]
  00f69	c1 e0 08	 shl	 eax, 8
  00f6c	03 c6		 add	 eax, esi
  00f6e	3b c8		 cmp	 ecx, eax
  00f70	75 30		 jne	 SHORT $LN43@Railgun

; 1607 :          count = countSTATIC;

  00f72	8b 44 24 20	 mov	 eax, DWORD PTR _countSTATIC$[esp+1064]

; 1608 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {

  00f76	85 c0		 test	 eax, eax
  00f78	74 16		 je	 SHORT $LN39@Railgun

; 1607 :          count = countSTATIC;

  00f7a	8b 4c 24 10	 mov	 ecx, DWORD PTR tv542[esp+1064]
  00f7e	8d 7b 01	 lea	 edi, DWORD PTR [ebx+1]
  00f81	8d 74 29 ff	 lea	 esi, DWORD PTR [ecx+ebp-1]
$LL17@Railgun:

; 1608 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {

  00f85	8a 0f		 mov	 cl, BYTE PTR [edi]
  00f87	3a 0e		 cmp	 cl, BYTE PTR [esi]
  00f89	75 0b		 jne	 SHORT $LN16@Railgun

; 1609 :                count--;

  00f8b	46		 inc	 esi
  00f8c	47		 inc	 edi
  00f8d	48		 dec	 eax
  00f8e	75 f5		 jne	 SHORT $LL17@Railgun
$LN39@Railgun:

; 1610 :          }
; 1611 :          if ( count == 0) return((pbTarget-cbPattern));

  00f90	8b c5		 mov	 eax, ebp
  00f92	2b c2		 sub	 eax, edx

; 1637 :             return(NULL);

  00f94	eb 15		 jmp	 SHORT $LN44@Railgun
$LN16@Railgun:

; 1610 :          }
; 1611 :          if ( count == 0) return((pbTarget-cbPattern));

  00f96	85 c0		 test	 eax, eax
  00f98	74 f6		 je	 SHORT $LN39@Railgun
  00f9a	8b 4c 24 14	 mov	 ecx, DWORD PTR _ulHashPattern$[esp+1064]
  00f9e	8b 7c 24 18	 mov	 edi, DWORD PTR tv545[esp+1064]
$LN43@Railgun:

; 1612 :         }
; 1613 : 
; 1614 :         // The fragment below gives for 'cbPattern'>=2:
; 1615 : 	// Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/554
; 1616 : 	// Karp_Rabin_Kaze_4_OCTETS performance: 364KB/clock
; 1617 : /*
; 1618 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 1619 :          count = countSTATIC>>2;
; 1620 :          countRemainder = countSTATIC % 4;
; 1621 : 
; 1622 :          while ( count && *(unsigned long *)(pbPattern+1+((count-1)<<2)) == *(unsigned long *)(pbTarget-cbPattern+1+((count-1)<<2)) ) {
; 1623 :                count--;
; 1624 :          }
; 1625 : 	 //if (count == 0) {  // Disastrous degradation only from this line(317KB/clock when 1+2x4+2+1 bytes pattern: 'skillessness'; 312KB/clock when 1+1x4+2+1 bytes pattern: 'underdog'), otherwise 368KB/clock.
; 1626 :          while ( countRemainder && *(char *)(pbPattern+1+(countSTATIC-countRemainder)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-countRemainder)) ) {
; 1627 :                countRemainder--;
; 1628 :          }
; 1629 :          //if ( countRemainder == 0) return((long)(pbTarget-cbPattern));
; 1630 :          if ( count+countRemainder == 0) return((long)(pbTarget-cbPattern));
; 1631 :          //}
; 1632 :         }
; 1633 : */
; 1634 : 
; 1635 :         pbTarget++;

  00fa2	45		 inc	 ebp

; 1636 :         if (pbTarget > pbTargetMax)

  00fa3	3b 6c 24 1c	 cmp	 ebp, DWORD PTR _pbTargetMax$[esp+1064]
  00fa7	76 b7		 jbe	 SHORT $LL20@Railgun
$LN5@Railgun:

; 1664 :     }
; 1665 :     return(NULL);

  00fa9	33 c0		 xor	 eax, eax
$LN44@Railgun:

; 1666 : }
; 1667 : }

  00fab	8b 8c 24 24 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1064]
  00fb2	5f		 pop	 edi
  00fb3	5e		 pop	 esi
  00fb4	5d		 pop	 ebp
  00fb5	5b		 pop	 ebx
  00fb6	33 cc		 xor	 ecx, esp
  00fb8	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00fbd	81 c4 18 04 00
	00		 add	 esp, 1048		; 00000418H
  00fc3	c3		 ret	 0
$LN21@Railgun:

; 1639 : }
; 1640 : else
; 1641 : {
; 1642 :     /* Preprocessing */
; 1643 :     for (a=0; a < ASIZE; a++) bm_bc[a]=cbPattern;

  00fc4	8b c2		 mov	 eax, edx
  00fc6	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  00fcb	8d 7c 24 24	 lea	 edi, DWORD PTR _bm_bc$[esp+1064]
  00fcf	f3 ab		 rep stosd

; 1644 :     for (j=0; j < cbPattern-1; j++) bm_bc[pbPattern[j]]=cbPattern-j-1;

  00fd1	8d 7a ff	 lea	 edi, DWORD PTR [edx-1]
  00fd4	33 c0		 xor	 eax, eax
  00fd6	85 ff		 test	 edi, edi
  00fd8	74 18		 je	 SHORT $LN7@Railgun
  00fda	8d 4a ff	 lea	 ecx, DWORD PTR [edx-1]
  00fdd	8d 49 00	 npad	 3
$LL42@Railgun:
  00fe0	0f be 1c 03	 movsx	 ebx, BYTE PTR [ebx+eax]
  00fe4	89 4c 9c 24	 mov	 DWORD PTR _bm_bc$[esp+ebx*4+1064], ecx
  00fe8	8b 5c 24 10	 mov	 ebx, DWORD PTR _pbPattern$GSCopy$[esp+1064]
  00fec	40		 inc	 eax
  00fed	49		 dec	 ecx
  00fee	3b c7		 cmp	 eax, edi
  00ff0	72 ee		 jb	 SHORT $LL42@Railgun
$LN7@Railgun:

; 1645 : 
; 1646 :     /* Searching */
; 1647 :     //lastch=pbPattern[cbPattern-1];
; 1648 :     //firstch=pbPattern[0];
; 1649 :     i=0;

  00ff2	33 ff		 xor	 edi, edi

; 1650 :     while (i <= cbTarget-cbPattern) {

  00ff4	2b f2		 sub	 esi, edx
  00ff6	8d 44 2a ff	 lea	 eax, DWORD PTR [edx+ebp-1]
  00ffa	0f be 54 13 ff	 movsx	 edx, BYTE PTR [ebx+edx-1]
  00fff	89 74 24 14	 mov	 DWORD PTR $T6686[esp+1064], esi
  01003	89 44 24 18	 mov	 DWORD PTR tv413[esp+1064], eax
  01007	89 54 24 1c	 mov	 DWORD PTR tv297[esp+1064], edx
  0100b	eb 03 8d 49 00	 npad	 5
$LL6@Railgun:

; 1651 :        ch=pbTarget[i+cbPattern-1];
; 1652 :        //if (ch ==lastch)
; 1653 :           //if (memcmp(&pbTarget[i],pbPattern,cbPattern-1) == 0) OUTPUT(i);
; 1654 :           //if (ch == lastch && pbTarget[i] == firstch && memcmp(&pbTarget[i],pbPattern,cbPattern-1) == 0) return(i);  // Kaze: The idea(to prevent execution of slower 'memcmp') is borrowed from Karp-Rabin i.e. to perform a slower check only when the target "looks like".
; 1655 :           if (ch == pbPattern[cbPattern-1] && pbTarget[i] == pbPattern[0])

  01010	0f b6 0c 38	 movzx	 ecx, BYTE PTR [eax+edi]
  01014	3b 4c 24 1c	 cmp	 ecx, DWORD PTR tv297[esp+1064]
  01018	75 31		 jne	 SHORT $LN1@Railgun
  0101a	8a 0c 2f	 mov	 cl, BYTE PTR [edi+ebp]
  0101d	3a 0b		 cmp	 cl, BYTE PTR [ebx]
  0101f	75 2a		 jne	 SHORT $LN1@Railgun

; 1656 :              {
; 1657 :          count = countSTATIC;

  01021	8b 44 24 20	 mov	 eax, DWORD PTR _countSTATIC$[esp+1064]

; 1658 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+(countSTATIC-count)) ) {

  01025	85 c0		 test	 eax, eax
  01027	74 12		 je	 SHORT $LN33@Railgun

; 1656 :              {
; 1657 :          count = countSTATIC;

  01029	8d 73 01	 lea	 esi, DWORD PTR [ebx+1]
  0102c	8d 4c 2f 01	 lea	 ecx, DWORD PTR [edi+ebp+1]
$LL3@Railgun:

; 1658 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+(countSTATIC-count)) ) {

  01030	8a 16		 mov	 dl, BYTE PTR [esi]
  01032	3a 11		 cmp	 dl, BYTE PTR [ecx]
  01034	75 0d		 jne	 SHORT $LN2@Railgun

; 1659 :                count--;

  01036	41		 inc	 ecx
  01037	46		 inc	 esi
  01038	48		 dec	 eax
  01039	75 f5		 jne	 SHORT $LL3@Railgun
$LN33@Railgun:

; 1660 :          }
; 1661 :          if ( count == 0) return(pbTarget+i);

  0103b	8d 04 2f	 lea	 eax, DWORD PTR [edi+ebp]
  0103e	e9 68 ff ff ff	 jmp	 $LN44@Railgun
$LN2@Railgun:
  01043	85 c0		 test	 eax, eax
  01045	74 f4		 je	 SHORT $LN33@Railgun
  01047	8b 44 24 18	 mov	 eax, DWORD PTR tv413[esp+1064]
$LN1@Railgun:

; 1662 : 	     }
; 1663 :        i+=bm_bc[ch];

  0104b	0f b6 0c 38	 movzx	 ecx, BYTE PTR [eax+edi]
  0104f	03 7c 8c 24	 add	 edi, DWORD PTR _bm_bc$[esp+ecx*4+1064]
  01053	3b 7c 24 14	 cmp	 edi, DWORD PTR $T6686[esp+1064]
  01057	76 b7		 jbe	 SHORT $LL6@Railgun

; 1650 :     while (i <= cbTarget-cbPattern) {

  01059	e9 4b ff ff ff	 jmp	 $LN5@Railgun
_Railgun ENDP
_TEXT	ENDS
PUBLIC	_pbPattern$GSCopy$
PUBLIC	__$ArrayPad$
PUBLIC	_Railgun_totalhits
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
tv547 = -1052						; size = 4
$T6710 = -1052						; size = 4
tv550 = -1048						; size = 4
tv357 = -1048						; size = 4
tv415 = -1044						; size = 4
_pbTargetMax$ = -1044					; size = 4
_pbPattern$GSCopy$ = -1040				; size = 4
_countSTATIC$ = -1036					; size = 4
_bm_bc$ = -1032						; size = 1024
__$ArrayPad$ = -4					; size = 4
_pbTarget$ = 8						; size = 4
_pbPattern$ = 12					; size = 4
_cbTarget$ = 16						; size = 4
_cbPattern$ = 20					; size = 4
_Railgun_totalhits PROC

; 1676 : {

  01060	55		 push	 ebp
  01061	8b ec		 mov	 ebp, esp
  01063	83 e4 f8	 and	 esp, -8			; fffffff8H
  01066	81 ec 1c 04 00
	00		 sub	 esp, 1052		; 0000041cH
  0106c	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  01071	33 c4		 xor	 eax, esp
  01073	89 84 24 18 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1052], eax

; 1677 :     char *  pbTargetMax = pbTarget + cbTarget;

  0107a	8b 55 10	 mov	 edx, DWORD PTR _cbTarget$[ebp]
  0107d	53		 push	 ebx
  0107e	8b 5d 08	 mov	 ebx, DWORD PTR _pbTarget$[ebp]
  01081	8d 04 13	 lea	 eax, DWORD PTR [ebx+edx]
  01084	56		 push	 esi
  01085	8b 75 0c	 mov	 esi, DWORD PTR _pbPattern$[ebp]
  01088	89 44 24 10	 mov	 DWORD PTR _pbTargetMax$[esp+1060], eax

; 1678 :     register unsigned long  ulHashPattern;
; 1679 :     unsigned long  ulHashTarget;
; 1680 :     unsigned long  count;
; 1681 :     unsigned long  countSTATIC, countRemainder;
; 1682 : 
; 1683 :     long i; //BMH needed
; 1684 :     int a, j, bm_bc[ASIZE]; //BMH needed
; 1685 :     unsigned char ch; //BMH needed
; 1686 : //    unsigned char lastch, firstch; //BMH needed
; 1687 : 
; 1688 :     if (cbPattern > cbTarget)

  0108c	8b 45 14	 mov	 eax, DWORD PTR _cbPattern$[ebp]
  0108f	57		 push	 edi

; 1769 : 	     }
; 1770 :        i+=bm_bc[ch];

  01090	89 74 24 18	 mov	 DWORD PTR _pbPattern$GSCopy$[esp+1064], esi
  01094	3b c2		 cmp	 eax, edx
  01096	0f 87 4a 01 00
	00		 ja	 $LN47@Railgun_to

; 1689 :         return(NULL);
; 1690 : 
; 1691 :         countSTATIC = cbPattern-2;

  0109c	8d 48 fe	 lea	 ecx, DWORD PTR [eax-2]
  0109f	89 4c 24 1c	 mov	 DWORD PTR _countSTATIC$[esp+1064], ecx

; 1692 : 
; 1693 : // Doesn't work when cbPattern = 1
; 1694 : if (cbTarget<961) // This value is arbitrary(don't know how exactly), it ensures(at least must) better performance than 'Boyer_Moore_Horspool'.

  010a3	81 fa c1 03 00
	00		 cmp	 edx, 961		; 000003c1H
  010a9	0f 83 96 00 00
	00		 jae	 $LN21@Railgun_to

; 1695 : {
; 1696 :         pbTarget = pbTarget+cbPattern;
; 1697 :         ulHashPattern = ( (*(char *)(pbPattern))<<8 ) + *(pbPattern+(cbPattern-1));

  010af	0f be 16	 movsx	 edx, BYTE PTR [esi]
  010b2	0f be 7c 06 ff	 movsx	 edi, BYTE PTR [esi+eax-1]
  010b7	c1 e2 08	 shl	 edx, 8
  010ba	03 fa		 add	 edi, edx

; 1743 :         if (pbTarget > pbTargetMax)

  010bc	b9 02 00 00 00	 mov	 ecx, 2
  010c1	2b c8		 sub	 ecx, eax
  010c3	ba 01 00 00 00	 mov	 edx, 1
  010c8	03 d8		 add	 ebx, eax
  010ca	2b d0		 sub	 edx, eax
  010cc	89 4c 24 0c	 mov	 DWORD PTR tv547[esp+1064], ecx
  010d0	89 54 24 10	 mov	 DWORD PTR tv550[esp+1064], edx
  010d4	eb 16		 jmp	 SHORT $LN20@Railgun_to
  010d6	eb 08 8d a4 24
	00 00 00 00 90	 npad	 10
$LL44@Railgun_to:
  010e0	8b 4c 24 0c	 mov	 ecx, DWORD PTR tv547[esp+1064]
  010e4	8b 54 24 10	 mov	 edx, DWORD PTR tv550[esp+1064]
  010e8	8b 74 24 18	 mov	 esi, DWORD PTR _pbPattern$GSCopy$[esp+1064]
$LN20@Railgun_to:

; 1698 : 
; 1699 :     for ( ;; )
; 1700 :     {
; 1701 :         // The line below gives for 'cbPattern'>=1:
; 1702 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 1703 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 1704 : /*
; 1705 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 1706 :             return((long)(pbTarget-cbPattern));
; 1707 : */
; 1708 : 
; 1709 :         // The fragment below gives for 'cbPattern'>=2:
; 1710 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 1711 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 1712 : 
; 1713 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {

  010ec	0f be 44 1a ff	 movsx	 eax, BYTE PTR [edx+ebx-1]
  010f1	0f be 53 ff	 movsx	 edx, BYTE PTR [ebx-1]
  010f5	c1 e0 08	 shl	 eax, 8
  010f8	03 c2		 add	 eax, edx
  010fa	3b f8		 cmp	 edi, eax
  010fc	75 29		 jne	 SHORT $LN15@Railgun_to

; 1714 :          count = countSTATIC;

  010fe	8b 44 24 1c	 mov	 eax, DWORD PTR _countSTATIC$[esp+1064]

; 1715 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {

  01102	85 c0		 test	 eax, eax
  01104	74 1b		 je	 SHORT $LN38@Railgun_to

; 1714 :          count = countSTATIC;

  01106	46		 inc	 esi
  01107	8d 4c 19 ff	 lea	 ecx, DWORD PTR [ecx+ebx-1]
  0110b	eb 03 8d 49 00	 npad	 5
$LL17@Railgun_to:

; 1715 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {

  01110	8a 16		 mov	 dl, BYTE PTR [esi]
  01112	3a 11		 cmp	 dl, BYTE PTR [ecx]
  01114	75 07		 jne	 SHORT $LN16@Railgun_to

; 1716 :                count--;

  01116	41		 inc	 ecx
  01117	46		 inc	 esi
  01118	48		 dec	 eax
  01119	75 f5		 jne	 SHORT $LL17@Railgun_to

; 1717 :          }
; 1718 :          if ( count == 0) Railgunhits++; //return((pbTarget-cbPattern));

  0111b	eb 04		 jmp	 SHORT $LN38@Railgun_to
$LN16@Railgun_to:
  0111d	85 c0		 test	 eax, eax
  0111f	75 06		 jne	 SHORT $LN15@Railgun_to
$LN38@Railgun_to:
  01121	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits
$LN15@Railgun_to:

; 1719 :         }
; 1720 : 
; 1721 :         // The fragment below gives for 'cbPattern'>=2:
; 1722 : 	// Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/554
; 1723 : 	// Karp_Rabin_Kaze_4_OCTETS performance: 364KB/clock
; 1724 : /*
; 1725 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 1726 :          count = countSTATIC>>2;
; 1727 :          countRemainder = countSTATIC % 4;
; 1728 : 
; 1729 :          while ( count && *(unsigned long *)(pbPattern+1+((count-1)<<2)) == *(unsigned long *)(pbTarget-cbPattern+1+((count-1)<<2)) ) {
; 1730 :                count--;
; 1731 :          }
; 1732 : 	 //if (count == 0) {  // Disastrous degradation only from this line(317KB/clock when 1+2x4+2+1 bytes pattern: 'skillessness'; 312KB/clock when 1+1x4+2+1 bytes pattern: 'underdog'), otherwise 368KB/clock.
; 1733 :          while ( countRemainder && *(char *)(pbPattern+1+(countSTATIC-countRemainder)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-countRemainder)) ) {
; 1734 :                countRemainder--;
; 1735 :          }
; 1736 :          //if ( countRemainder == 0) return((long)(pbTarget-cbPattern));
; 1737 :          if ( count+countRemainder == 0) return((long)(pbTarget-cbPattern));
; 1738 :          //}
; 1739 :         }
; 1740 : */
; 1741 : 
; 1742 :         pbTarget++;

  01127	43		 inc	 ebx

; 1743 :         if (pbTarget > pbTargetMax)

  01128	3b 5c 24 14	 cmp	 ebx, DWORD PTR _pbTargetMax$[esp+1064]
  0112c	76 b2		 jbe	 SHORT $LL44@Railgun_to

; 1771 :     }
; 1772 :     return(NULL);

  0112e	33 c0		 xor	 eax, eax

; 1773 : }
; 1774 : }

  01130	5f		 pop	 edi
  01131	5e		 pop	 esi
  01132	5b		 pop	 ebx
  01133	8b 8c 24 18 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1052]
  0113a	33 cc		 xor	 ecx, esp
  0113c	e8 00 00 00 00	 call	 @__security_check_cookie@4
  01141	8b e5		 mov	 esp, ebp
  01143	5d		 pop	 ebp
  01144	c3		 ret	 0
$LN21@Railgun_to:

; 1744 :             return(NULL);
; 1745 :     }
; 1746 : }
; 1747 : else
; 1748 : {
; 1749 :     /* Preprocessing */
; 1750 :     for (a=0; a < ASIZE; a++) bm_bc[a]=cbPattern;

  01145	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  0114a	8d 7c 24 20	 lea	 edi, DWORD PTR _bm_bc$[esp+1064]
  0114e	f3 ab		 rep stosd

; 1751 :     for (j=0; j < cbPattern-1; j++) bm_bc[pbPattern[j]]=cbPattern-j-1;

  01150	8d 70 ff	 lea	 esi, DWORD PTR [eax-1]
  01153	33 c9		 xor	 ecx, ecx
  01155	85 f6		 test	 esi, esi
  01157	74 18		 je	 SHORT $LN7@Railgun_to
  01159	8d 78 ff	 lea	 edi, DWORD PTR [eax-1]
$LN9@Railgun_to:
  0115c	8b 74 24 18	 mov	 esi, DWORD PTR _pbPattern$GSCopy$[esp+1064]
  01160	0f be 34 0e	 movsx	 esi, BYTE PTR [esi+ecx]
  01164	89 7c b4 20	 mov	 DWORD PTR _bm_bc$[esp+esi*4+1064], edi
  01168	41		 inc	 ecx
  01169	8d 70 ff	 lea	 esi, DWORD PTR [eax-1]
  0116c	4f		 dec	 edi
  0116d	3b ce		 cmp	 ecx, esi
  0116f	72 eb		 jb	 SHORT $LN9@Railgun_to
$LN7@Railgun_to:

; 1752 : 
; 1753 :     /* Searching */
; 1754 :     //lastch=pbPattern[cbPattern-1];
; 1755 :     //firstch=pbPattern[0];
; 1756 :     i=0;

  01171	33 ff		 xor	 edi, edi

; 1757 :     while (i <= cbTarget-cbPattern) {

  01173	2b d0		 sub	 edx, eax
  01175	8d 4c 03 ff	 lea	 ecx, DWORD PTR [ebx+eax-1]
  01179	89 54 24 0c	 mov	 DWORD PTR $T6710[esp+1064], edx
  0117d	89 4c 24 14	 mov	 DWORD PTR tv415[esp+1064], ecx
$LN6@Railgun_to:

; 1758 :        ch=pbTarget[i+cbPattern-1];
; 1759 :        //if (ch ==lastch)
; 1760 :           //if (memcmp(&pbTarget[i],pbPattern,cbPattern-1) == 0) OUTPUT(i);
; 1761 :           //if (ch == lastch && pbTarget[i] == firstch && memcmp(&pbTarget[i],pbPattern,cbPattern-1) == 0) return(i);  // Kaze: The idea(to prevent execution of slower 'memcmp') is borrowed from Karp-Rabin i.e. to perform a slower check only when the target "looks like".
; 1762 :           if (ch == pbPattern[cbPattern-1] && pbTarget[i] == pbPattern[0])

  01181	8b 54 24 14	 mov	 edx, DWORD PTR tv415[esp+1064]
  01185	0f b6 0c 3a	 movzx	 ecx, BYTE PTR [edx+edi]
  01189	8b 74 24 18	 mov	 esi, DWORD PTR _pbPattern$GSCopy$[esp+1064]
  0118d	0f be 54 06 ff	 movsx	 edx, BYTE PTR [esi+eax-1]
  01192	89 4c 24 10	 mov	 DWORD PTR tv357[esp+1064], ecx
  01196	3b ca		 cmp	 ecx, edx
  01198	75 3e		 jne	 SHORT $LN1@Railgun_to
  0119a	8a 0c 1f	 mov	 cl, BYTE PTR [edi+ebx]
  0119d	3a 0e		 cmp	 cl, BYTE PTR [esi]
  0119f	75 37		 jne	 SHORT $LN1@Railgun_to

; 1763 :              {
; 1764 :          count = countSTATIC;

  011a1	8b 4c 24 1c	 mov	 ecx, DWORD PTR _countSTATIC$[esp+1064]

; 1765 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+(countSTATIC-count)) ) {

  011a5	85 c9		 test	 ecx, ecx
  011a7	74 24		 je	 SHORT $LN37@Railgun_to

; 1763 :              {
; 1764 :          count = countSTATIC;

  011a9	46		 inc	 esi
  011aa	8d 54 1f 01	 lea	 edx, DWORD PTR [edi+ebx+1]
  011ae	8b ff		 npad	 2
$LL3@Railgun_to:

; 1765 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+(countSTATIC-count)) ) {

  011b0	8a 1e		 mov	 bl, BYTE PTR [esi]
  011b2	3a 1a		 cmp	 bl, BYTE PTR [edx]
  011b4	75 10		 jne	 SHORT $LN2@Railgun_to

; 1766 :                count--;

  011b6	42		 inc	 edx
  011b7	46		 inc	 esi
  011b8	49		 dec	 ecx
  011b9	75 f5		 jne	 SHORT $LL3@Railgun_to

; 1767 :          }
; 1768 :          if ( count == 0) Railgunhits++; //return(pbTarget+i);

  011bb	8b 5d 08	 mov	 ebx, DWORD PTR _pbTarget$[ebp]
  011be	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits
  011c4	eb 12		 jmp	 SHORT $LN1@Railgun_to
$LN2@Railgun_to:
  011c6	85 c9		 test	 ecx, ecx
  011c8	75 0b		 jne	 SHORT $LN39@Railgun_to
  011ca	8b 5d 08	 mov	 ebx, DWORD PTR _pbTarget$[ebp]
$LN37@Railgun_to:
  011cd	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits
  011d3	eb 03		 jmp	 SHORT $LN1@Railgun_to
$LN39@Railgun_to:
  011d5	8b 5d 08	 mov	 ebx, DWORD PTR _pbTarget$[ebp]
$LN1@Railgun_to:

; 1769 : 	     }
; 1770 :        i+=bm_bc[ch];

  011d8	8b 54 24 10	 mov	 edx, DWORD PTR tv357[esp+1064]
  011dc	03 7c 94 20	 add	 edi, DWORD PTR _bm_bc$[esp+edx*4+1064]
  011e0	3b 7c 24 0c	 cmp	 edi, DWORD PTR $T6710[esp+1064]
  011e4	76 9b		 jbe	 SHORT $LN6@Railgun_to
$LN47@Railgun_to:

; 1773 : }
; 1774 : }

  011e6	8b 8c 24 24 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1064]
  011ed	5f		 pop	 edi
  011ee	5e		 pop	 esi
  011ef	5b		 pop	 ebx
  011f0	33 cc		 xor	 ecx, esp
  011f2	33 c0		 xor	 eax, eax
  011f4	e8 00 00 00 00	 call	 @__security_check_cookie@4
  011f9	8b e5		 mov	 esp, ebp
  011fb	5d		 pop	 ebp
  011fc	c3		 ret	 0
_Railgun_totalhits ENDP
_TEXT	ENDS
PUBLIC	_KarpRabinKaze_BOOSTED
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_ulHashPattern$ = 8					; size = 4
_pbTarget$ = 8						; size = 4
_pbPattern$ = 12					; size = 4
_pbTargetMax$ = 16					; size = 4
_cbTarget$ = 16						; size = 4
_cbPattern$ = 20					; size = 4
_KarpRabinKaze_BOOSTED PROC

; 1784 :     char *  pbTargetMax = pbTarget + cbTarget;

  01200	8b 4c 24 0c	 mov	 ecx, DWORD PTR _cbTarget$[esp-4]
  01204	8b 44 24 04	 mov	 eax, DWORD PTR _pbTarget$[esp-4]
  01208	57		 push	 edi

; 1785 :     register unsigned long  ulHashPattern;
; 1786 :     unsigned long  ulHashTarget;
; 1787 : 
; 1788 :     if (cbPattern > cbTarget)

  01209	8b 7c 24 14	 mov	 edi, DWORD PTR _cbPattern$[esp]
  0120d	8d 14 08	 lea	 edx, DWORD PTR [eax+ecx]
  01210	89 54 24 10	 mov	 DWORD PTR _pbTargetMax$[esp], edx
  01214	3b f9		 cmp	 edi, ecx
  01216	76 04		 jbe	 SHORT $LN5@KarpRabinK@2

; 1789 :         return(NULL);

  01218	33 c0		 xor	 eax, eax
  0121a	5f		 pop	 edi

; 1806 :     }
; 1807 : }

  0121b	c3		 ret	 0
$LN5@KarpRabinK@2:
  0121c	55		 push	 ebp
  0121d	56		 push	 esi

; 1790 : 
; 1791 :         pbTarget = pbTarget+cbPattern;
; 1792 :         ulHashPattern = ( (*(char *)(pbPattern))<<8 ) + *(pbPattern+(cbPattern-1));

  0121e	8b 74 24 14	 mov	 esi, DWORD PTR _pbPattern$[esp+8]
  01222	0f be 16	 movsx	 edx, BYTE PTR [esi]
  01225	0f be 4c 3e ff	 movsx	 ecx, BYTE PTR [esi+edi-1]
  0122a	03 c7		 add	 eax, edi
  0122c	c1 e2 08	 shl	 edx, 8
  0122f	03 ca		 add	 ecx, edx
  01231	8b e8		 mov	 ebp, eax
  01233	89 4c 24 10	 mov	 DWORD PTR _ulHashPattern$[esp+8], ecx
  01237	2b ef		 sub	 ebp, edi
  01239	53		 push	 ebx
  0123a	8d 9b 00 00 00
	00		 npad	 6
$LL4@KarpRabinK@2:

; 1793 : 
; 1794 :     for ( ;; )
; 1795 :     {
; 1796 :         // Kaze: The idea(FAILED) here is to add an additional(second) layer in order to prevent execution of slower hash calculation(i.e. first layer) which(hash) prevents execution of even slower 'memcmp'.
; 1797 :         // The line below gives: 314KB/clock
; 1798 :         //if ( *pbPattern == *(char *)(pbTarget-cbPattern) && (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 1799 :         // The line below gives: 370KB/clock
; 1800 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )

  01240	0f be 5d 00	 movsx	 ebx, BYTE PTR [ebp]
  01244	0f be 54 2f ff	 movsx	 edx, BYTE PTR [edi+ebp-1]
  01249	c1 e3 08	 shl	 ebx, 8
  0124c	03 d3		 add	 edx, ebx
  0124e	3b ca		 cmp	 ecx, edx
  01250	75 4e		 jne	 SHORT $LN20@KarpRabinK@2
  01252	8b cf		 mov	 ecx, edi
  01254	8b d5		 mov	 edx, ebp
  01256	83 ff 04	 cmp	 edi, 4
  01259	72 19		 jb	 SHORT $LN16@KarpRabinK@2
  0125b	eb 03 8d 49 00	 npad	 5
$LL9@KarpRabinK@2:
  01260	8b 1e		 mov	 ebx, DWORD PTR [esi]
  01262	3b 1a		 cmp	 ebx, DWORD PTR [edx]
  01264	75 32		 jne	 SHORT $LN19@KarpRabinK@2
  01266	83 e9 04	 sub	 ecx, 4
  01269	83 c2 04	 add	 edx, 4
  0126c	83 c6 04	 add	 esi, 4
  0126f	83 f9 04	 cmp	 ecx, 4
  01272	73 ec		 jae	 SHORT $LL9@KarpRabinK@2
$LN16@KarpRabinK@2:
  01274	85 c9		 test	 ecx, ecx
  01276	74 37		 je	 SHORT $LN11@KarpRabinK@2
  01278	8a 1a		 mov	 bl, BYTE PTR [edx]
  0127a	3a 1e		 cmp	 bl, BYTE PTR [esi]
  0127c	75 1a		 jne	 SHORT $LN19@KarpRabinK@2
  0127e	83 f9 01	 cmp	 ecx, 1
  01281	76 2c		 jbe	 SHORT $LN11@KarpRabinK@2
  01283	8a 5a 01	 mov	 bl, BYTE PTR [edx+1]
  01286	3a 5e 01	 cmp	 bl, BYTE PTR [esi+1]
  01289	75 0d		 jne	 SHORT $LN19@KarpRabinK@2
  0128b	83 f9 02	 cmp	 ecx, 2
  0128e	76 1f		 jbe	 SHORT $LN11@KarpRabinK@2
  01290	8a 4a 02	 mov	 cl, BYTE PTR [edx+2]
  01293	3a 4e 02	 cmp	 cl, BYTE PTR [esi+2]
  01296	74 17		 je	 SHORT $LN11@KarpRabinK@2
$LN19@KarpRabinK@2:
  01298	8b 74 24 18	 mov	 esi, DWORD PTR _pbPattern$[esp+12]
  0129c	8b 4c 24 14	 mov	 ecx, DWORD PTR _ulHashPattern$[esp+12]
$LN20@KarpRabinK@2:

; 1802 : 
; 1803 :         pbTarget++;

  012a0	40		 inc	 eax
  012a1	45		 inc	 ebp

; 1804 :         if (pbTarget > pbTargetMax)

  012a2	3b 44 24 1c	 cmp	 eax, DWORD PTR _pbTargetMax$[esp+12]
  012a6	76 98		 jbe	 SHORT $LL4@KarpRabinK@2

; 1805 :             return(NULL);

  012a8	5b		 pop	 ebx
  012a9	5e		 pop	 esi
  012aa	5d		 pop	 ebp
  012ab	33 c0		 xor	 eax, eax
  012ad	5f		 pop	 edi

; 1806 :     }
; 1807 : }

  012ae	c3		 ret	 0
$LN11@KarpRabinK@2:
  012af	5b		 pop	 ebx
  012b0	5e		 pop	 esi
  012b1	5d		 pop	 ebp

; 1801 :             return((pbTarget-cbPattern));

  012b2	2b c7		 sub	 eax, edi
  012b4	5f		 pop	 edi

; 1806 :     }
; 1807 : }

  012b5	c3		 ret	 0
_KarpRabinKaze_BOOSTED ENDP
_TEXT	ENDS
PUBLIC	_strstr_Microsoft
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_str1$ = 8						; size = 4
_str2$ = 12						; size = 4
_strstr_Microsoft PROC

; 1814 : {

  012c0	56		 push	 esi

; 1815 :         char *cp = (char *) str1;

  012c1	8b 74 24 08	 mov	 esi, DWORD PTR _str1$[esp]
  012c5	57		 push	 edi

; 1816 :         char *s1, *s2;
; 1817 : 
; 1818 :         if ( !*str2 )

  012c6	8b 7c 24 10	 mov	 edi, DWORD PTR _str2$[esp+4]
  012ca	80 3f 00	 cmp	 BYTE PTR [edi], 0
  012cd	8b c6		 mov	 eax, esi

; 1819 :             return((char *)str1);

  012cf	74 3d		 je	 SHORT $LN7@strstr_Mic

; 1820 : 
; 1821 :         while (*cp)

  012d1	8a 16		 mov	 dl, BYTE PTR [esi]
  012d3	53		 push	 ebx
  012d4	84 d2		 test	 dl, dl
  012d6	74 33		 je	 SHORT $LN4@strstr_Mic
  012d8	2b f7		 sub	 esi, edi
  012da	8d 9b 00 00 00
	00		 npad	 6
$LL5@strstr_Mic:

; 1822 :         {
; 1823 :                 s1 = cp;
; 1824 :                 s2 = (char *) str2;

  012e0	8b cf		 mov	 ecx, edi

; 1825 : 
; 1826 :                 while ( *s1 && *s2 && !(*s1-*s2) )

  012e2	84 d2		 test	 dl, dl
  012e4	74 17		 je	 SHORT $LN2@strstr_Mic
$LL3@strstr_Mic:
  012e6	8a 11		 mov	 dl, BYTE PTR [ecx]
  012e8	84 d2		 test	 dl, dl
  012ea	74 21		 je	 SHORT $LN14@strstr_Mic
  012ec	0f be 1c 0e	 movsx	 ebx, BYTE PTR [esi+ecx]
  012f0	0f be d2	 movsx	 edx, dl
  012f3	2b da		 sub	 ebx, edx
  012f5	75 06		 jne	 SHORT $LN2@strstr_Mic

; 1827 :                         s1++, s2++;

  012f7	41		 inc	 ecx
  012f8	38 1c 0e	 cmp	 BYTE PTR [esi+ecx], bl
  012fb	75 e9		 jne	 SHORT $LL3@strstr_Mic
$LN2@strstr_Mic:

; 1828 : 
; 1829 :                 if (!*s2)

  012fd	80 39 00	 cmp	 BYTE PTR [ecx], 0
  01300	74 0b		 je	 SHORT $LN14@strstr_Mic

; 1830 :                         return(cp);
; 1831 : 
; 1832 :                 cp++;

  01302	8a 50 01	 mov	 dl, BYTE PTR [eax+1]
  01305	40		 inc	 eax
  01306	46		 inc	 esi
  01307	84 d2		 test	 dl, dl
  01309	75 d5		 jne	 SHORT $LL5@strstr_Mic
$LN4@strstr_Mic:

; 1833 :         }
; 1834 :         return(NULL);

  0130b	33 c0		 xor	 eax, eax
$LN14@strstr_Mic:
  0130d	5b		 pop	 ebx
$LN7@strstr_Mic:
  0130e	5f		 pop	 edi
  0130f	5e		 pop	 esi

; 1835 : }

  01310	c3		 ret	 0
_strstr_Microsoft ENDP
_TEXT	ENDS
PUBLIC	_strstr_GNU_C_Library
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_b$ = 8							; size = 1
_phaystack$ = 8						; size = 4
_c$5767 = 12						; size = 1
_pneedle$ = 12						; size = 4
_strstr_GNU_C_Library PROC

; 1842 :   const unsigned char *haystack, *needle;
; 1843 :   char b;
; 1844 :   const unsigned char *rneedle;
; 1845 : 
; 1846 :   haystack = (const unsigned char *) phaystack;

  01320	8b 44 24 04	 mov	 eax, DWORD PTR _phaystack$[esp-4]
  01324	53		 push	 ebx
  01325	55		 push	 ebp
  01326	56		 push	 esi

; 1847 : 
; 1848 :   if ((b = *(needle = (const unsigned char *) pneedle)))

  01327	8b 74 24 14	 mov	 esi, DWORD PTR _pneedle$[esp+8]
  0132b	8a 16		 mov	 dl, BYTE PTR [esi]
  0132d	57		 push	 edi
  0132e	88 54 24 14	 mov	 BYTE PTR _b$[esp+12], dl
  01332	84 d2		 test	 dl, dl
  01334	0f 84 a8 00 00
	00		 je	 $foundneedle$5775

; 1849 :     {
; 1850 :       char c;
; 1851 :       haystack--;		/* possible ANSI violation */

  0133a	48		 dec	 eax
  0133b	eb 03 8d 49 00	 npad	 5
$LL27@strstr_GNU:

; 1852 : 
; 1853 :       {
; 1854 : 	char a;
; 1855 : 	do
; 1856 : 	  if (!(a = *++haystack))

  01340	8a 48 01	 mov	 cl, BYTE PTR [eax+1]
  01343	40		 inc	 eax
  01344	84 c9		 test	 cl, cl
  01346	0f 84 94 00 00
	00		 je	 $ret0$5773

; 1857 : 	    goto ret0;
; 1858 : 	while (a != b);

  0134c	3a ca		 cmp	 cl, dl
  0134e	75 f0		 jne	 SHORT $LL27@strstr_GNU

; 1859 :       }
; 1860 : 
; 1861 :       if (!(c = *++needle))

  01350	8a 5e 01	 mov	 bl, BYTE PTR [esi+1]
  01353	88 5c 24 18	 mov	 BYTE PTR _c$5767[esp+12], bl
  01357	84 db		 test	 bl, bl
  01359	0f 84 83 00 00
	00		 je	 $foundneedle$5775

; 1862 : 	goto foundneedle;
; 1863 :       ++needle;
; 1864 :       goto jin;
; 1865 : 
; 1866 :       for (;;)
; 1867 : 	{
; 1868 : 	  {
; 1869 : 	    char a;
; 1870 : 	    if (0)
; 1871 : 	    jin:{
; 1872 : 		if ((a = *++haystack) == c)

  0135f	8a 48 01	 mov	 cl, BYTE PTR [eax+1]
  01362	40		 inc	 eax
  01363	83 c6 02	 add	 esi, 2
$jin$5776:
  01366	3a cb		 cmp	 cl, bl
  01368	74 26		 je	 SHORT $crest$5783
$LN17@strstr_GNU:

; 1877 : 	    do
; 1878 : 	      {
; 1879 : 		for (; a != b; a = *++haystack)

  0136a	3a ca		 cmp	 cl, dl
  0136c	74 1a		 je	 SHORT $LN16@strstr_GNU
  0136e	8b ff		 npad	 2
$LL14@strstr_GNU:

; 1880 : 		  {
; 1881 : 		    if (!a)

  01370	84 c9		 test	 cl, cl
  01372	74 6c		 je	 SHORT $ret0$5773

; 1882 : 		      goto ret0;
; 1883 : 		    if ((a = *++haystack) == b)

  01374	8a 48 01	 mov	 cl, BYTE PTR [eax+1]
  01377	40		 inc	 eax
  01378	3a ca		 cmp	 cl, dl
  0137a	74 0c		 je	 SHORT $LN16@strstr_GNU

; 1884 : 		      break;
; 1885 : 		    if (!a)

  0137c	84 c9		 test	 cl, cl
  0137e	74 60		 je	 SHORT $ret0$5773

; 1877 : 	    do
; 1878 : 	      {
; 1879 : 		for (; a != b; a = *++haystack)

  01380	8a 48 01	 mov	 cl, BYTE PTR [eax+1]
  01383	40		 inc	 eax
  01384	3a ca		 cmp	 cl, dl
  01386	75 e8		 jne	 SHORT $LL14@strstr_GNU
$LN16@strstr_GNU:

; 1886 : 		      goto ret0;
; 1887 : 		  }
; 1888 : 	      }
; 1889 : 	    while ((a = *++haystack) != c);

  01388	8a 48 01	 mov	 cl, BYTE PTR [eax+1]
  0138b	40		 inc	 eax
  0138c	3a cb		 cmp	 cl, bl
  0138e	75 da		 jne	 SHORT $LN17@strstr_GNU
$crest$5783:

; 1890 : 	  }
; 1891 : 	crest:
; 1892 : 	  {
; 1893 : 	    char a;
; 1894 : 	    {
; 1895 : 	      const unsigned char *rhaystack;
; 1896 : 	      if (*(rhaystack = haystack-- + 1) == (a = *(rneedle = needle)))

  01390	8a 0e		 mov	 cl, BYTE PTR [esi]
  01392	0f b6 58 01	 movzx	 ebx, BYTE PTR [eax+1]
  01396	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
  01399	0f be e9	 movsx	 ebp, cl
  0139c	48		 dec	 eax
  0139d	8b fe		 mov	 edi, esi
  0139f	3b dd		 cmp	 ebx, ebp
  013a1	75 29		 jne	 SHORT $LN5@strstr_GNU
$LL7@strstr_GNU:

; 1897 : 		do
; 1898 : 		  {
; 1899 : 		    if (!a)

  013a3	84 c9		 test	 cl, cl
  013a5	74 3b		 je	 SHORT $foundneedle$5775

; 1900 : 		      goto foundneedle;
; 1901 : 		    if (*++rhaystack != (a = *++needle))

  013a7	8a 4e 01	 mov	 cl, BYTE PTR [esi+1]
  013aa	0f b6 5a 01	 movzx	 ebx, BYTE PTR [edx+1]
  013ae	42		 inc	 edx
  013af	0f be e9	 movsx	 ebp, cl
  013b2	3b dd		 cmp	 ebx, ebp
  013b4	75 16		 jne	 SHORT $LN5@strstr_GNU

; 1902 : 		      break;
; 1903 : 		    if (!a)

  013b6	84 c9		 test	 cl, cl
  013b8	74 28		 je	 SHORT $foundneedle$5775

; 1904 : 		      goto foundneedle;
; 1905 : 		  }
; 1906 : 		while (*++rhaystack == (a = *++needle));

  013ba	8a 4e 02	 mov	 cl, BYTE PTR [esi+2]
  013bd	0f b6 5a 01	 movzx	 ebx, BYTE PTR [edx+1]
  013c1	83 c6 02	 add	 esi, 2
  013c4	42		 inc	 edx
  013c5	0f be e9	 movsx	 ebp, cl
  013c8	3b dd		 cmp	 ebx, ebp
  013ca	74 d7		 je	 SHORT $LL7@strstr_GNU
$LN5@strstr_GNU:

; 1907 : 	      needle = rneedle;	/* took the register-poor aproach */

  013cc	8b f7		 mov	 esi, edi

; 1908 : 	    }
; 1909 : 	    if (!a)

  013ce	84 c9		 test	 cl, cl
  013d0	74 10		 je	 SHORT $foundneedle$5775

; 1873 : 		  goto crest;
; 1874 : 	      }
; 1875 : 	    else
; 1876 : 	      a = *++haystack;

  013d2	8a 48 01	 mov	 cl, BYTE PTR [eax+1]
  013d5	8a 54 24 14	 mov	 dl, BYTE PTR _b$[esp+12]
  013d9	8a 5c 24 18	 mov	 bl, BYTE PTR _c$5767[esp+12]
  013dd	40		 inc	 eax
  013de	eb 8a		 jmp	 SHORT $LN17@strstr_GNU
$ret0$5773:

; 1910 : 	      break;
; 1911 : 	  }
; 1912 : 	}
; 1913 :     }
; 1914 : foundneedle:
; 1915 :   return (char *) haystack;
; 1916 : ret0:
; 1917 :   return 0;

  013e0	33 c0		 xor	 eax, eax
$foundneedle$5775:
  013e2	5f		 pop	 edi
  013e3	5e		 pop	 esi
  013e4	5d		 pop	 ebp
  013e5	5b		 pop	 ebx

; 1918 : }

  013e6	c3		 ret	 0
_strstr_GNU_C_Library ENDP
_TEXT	ENDS
PUBLIC	_pbPattern$GSCopy$
PUBLIC	__$ArrayPad$
PUBLIC	_Railgun_Quadruplet
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
tv701 = -1056						; size = 4
tv544 = -1056						; size = 4
$T6785 = -1056						; size = 4
_Quadruplet3rd$ = -1052					; size = 4
_countSTATIC$ = -1052					; size = 4
_pbPattern$GSCopy$ = -1048				; size = 4
tv698 = -1044						; size = 4
_Quadruplet2nd$ = -1044					; size = 4
tv569 = -1040						; size = 4
_ulHashPattern$ = -1040					; size = 4
tv392 = -1036						; size = 4
_Quadruplet4th$ = -1036					; size = 4
_pbTargetMax$ = -1032					; size = 4
_bm_bc$ = -1028						; size = 1024
__$ArrayPad$ = -4					; size = 4
_pbTarget$ = 8						; size = 4
_pbPattern$ = 12					; size = 4
_cbTarget$ = 16						; size = 4
_cbPattern$ = 20					; size = 4
_Railgun_Quadruplet PROC

; 1927 : {

  013f0	81 ec 20 04 00
	00		 sub	 esp, 1056		; 00000420H
  013f6	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  013fb	33 c4		 xor	 eax, esp
  013fd	89 84 24 1c 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1056], eax

; 1928 :     char * pbTargetMax = pbTarget + cbTarget;

  01404	8b 94 24 2c 04
	00 00		 mov	 edx, DWORD PTR _cbTarget$[esp+1052]
  0140b	53		 push	 ebx
  0140c	8b 9c 24 28 04
	00 00		 mov	 ebx, DWORD PTR _pbTarget$[esp+1056]
  01413	55		 push	 ebp

; 1929 :     register unsigned long  ulHashPattern;
; 1930 :     unsigned long ulHashTarget;
; 1931 :     unsigned long count;
; 1932 :     unsigned long countSTATIC;
; 1933 : //  unsigned long countRemainder;
; 1934 : 
; 1935 : /*
; 1936 :     const unsigned char SINGLET = *(char *)(pbPattern);
; 1937 :     const unsigned long Quadruplet2nd = SINGLET<<8;
; 1938 :     const unsigned long Quadruplet3rd = SINGLET<<16;
; 1939 :     const unsigned long Quadruplet4th = SINGLET<<24;
; 1940 : */
; 1941 :     unsigned char SINGLET;
; 1942 :     unsigned long Quadruplet2nd;
; 1943 :     unsigned long Quadruplet3rd;
; 1944 :     unsigned long Quadruplet4th;
; 1945 : 
; 1946 :     unsigned long  AdvanceHopperGrass;
; 1947 : 
; 1948 :     long i; //BMH needed
; 1949 :     int a, j, bm_bc[ASIZE]; //BMH needed
; 1950 :     unsigned char ch; //BMH needed
; 1951 : //    unsigned char lastch, firstch; //BMH needed
; 1952 : 
; 1953 :     if (cbPattern > cbTarget)

  01414	8b ac 24 38 04
	00 00		 mov	 ebp, DWORD PTR _cbPattern$[esp+1060]
  0141b	56		 push	 esi
  0141c	8b b4 24 34 04
	00 00		 mov	 esi, DWORD PTR _pbPattern$[esp+1064]
  01423	8d 04 13	 lea	 eax, DWORD PTR [ebx+edx]
  01426	89 74 24 14	 mov	 DWORD PTR _pbPattern$GSCopy$[esp+1068], esi
  0142a	89 44 24 24	 mov	 DWORD PTR _pbTargetMax$[esp+1068], eax
  0142e	3b ea		 cmp	 ebp, edx
  01430	76 1a		 jbe	 SHORT $LN36@Railgun_Qu

; 1954 :         return(NULL);

  01432	5e		 pop	 esi
  01433	5d		 pop	 ebp
  01434	33 c0		 xor	 eax, eax
  01436	5b		 pop	 ebx

; 2077 : } //if (cbTarget<961)
; 2078 : } //if ( cbPattern<4)
; 2079 : }

  01437	8b 8c 24 1c 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1056]
  0143e	33 cc		 xor	 ecx, esp
  01440	e8 00 00 00 00	 call	 @__security_check_cookie@4
  01445	81 c4 20 04 00
	00		 add	 esp, 1056		; 00000420H
  0144b	c3		 ret	 0
$LN36@Railgun_Qu:
  0144c	57		 push	 edi

; 1955 : 
; 1956 : // Doesn't work when cbPattern = 1
; 1957 : // The next IF-fragment works very well with cbPattern>1, OBVIOUSLY IT MUST BE UNROLLED(but crippled with less functionality) SINCE either cbPattern=2 or cbPattern=3!
; 1958 : if ( cbPattern<4) { // This IF makes me unhappy: it slows down from 390KB/clock to 367KB/clock for 'fast' pattern. This fragment(for 2..3 pattern lengths) is needed because I need a function different than strchr but sticking to strstr i.e. lengths above 1 are to be handled.

  0144d	83 fd 04	 cmp	 ebp, 4
  01450	0f 83 8b 00 00
	00		 jae	 $LN35@Railgun_Qu

; 1959 :         pbTarget = pbTarget+cbPattern;
; 1960 :         ulHashPattern = ( (*(char *)(pbPattern))<<8 ) + *(pbPattern+(cbPattern-1));

  01456	0f be 0e	 movsx	 ecx, BYTE PTR [esi]
  01459	0f be 7c 2e ff	 movsx	 edi, BYTE PTR [esi+ebp-1]

; 2009 :     }

  0145e	b8 02 00 00 00	 mov	 eax, 2
  01463	2b c5		 sub	 eax, ebp
  01465	c1 e1 08	 shl	 ecx, 8
  01468	89 44 24 1c	 mov	 DWORD PTR tv698[esp+1072], eax
  0146c	b8 01 00 00 00	 mov	 eax, 1
  01471	03 dd		 add	 ebx, ebp
  01473	03 f9		 add	 edi, ecx
  01475	2b c5		 sub	 eax, ebp
  01477	89 44 24 10	 mov	 DWORD PTR tv701[esp+1072], eax
  0147b	eb 03 8d 49 00	 npad	 5
$LL34@Railgun_Qu:

; 1961 :         countSTATIC = cbPattern-2;
; 1962 : 
; 1963 :     for ( ;; )
; 1964 :     {
; 1965 :         // The line below gives for 'cbPattern'>=1:
; 1966 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 1967 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 1968 : /*
; 1969 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 1970 :             return((long)(pbTarget-cbPattern));
; 1971 : */
; 1972 : 
; 1973 :         // The fragment below gives for 'cbPattern'>=2:
; 1974 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 1975 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 1976 : 
; 1977 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {

  01480	0f be 54 18 ff	 movsx	 edx, BYTE PTR [eax+ebx-1]
  01485	0f be 4b ff	 movsx	 ecx, BYTE PTR [ebx-1]
  01489	c1 e2 08	 shl	 edx, 8
  0148c	03 d1		 add	 edx, ecx
  0148e	3b fa		 cmp	 edi, edx
  01490	75 2d		 jne	 SHORT $LN64@Railgun_Qu

; 1978 :          count = countSTATIC;

  01492	8d 45 fe	 lea	 eax, DWORD PTR [ebp-2]

; 1979 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {

  01495	85 c0		 test	 eax, eax
  01497	74 14		 je	 SHORT $LN58@Railgun_Qu

; 1978 :          count = countSTATIC;

  01499	8b 54 24 1c	 mov	 edx, DWORD PTR tv698[esp+1072]
  0149d	46		 inc	 esi
  0149e	8d 4c 1a ff	 lea	 ecx, DWORD PTR [edx+ebx-1]
$LL31@Railgun_Qu:

; 1979 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {

  014a2	8a 16		 mov	 dl, BYTE PTR [esi]
  014a4	3a 11		 cmp	 dl, BYTE PTR [ecx]
  014a6	75 0b		 jne	 SHORT $LN30@Railgun_Qu

; 1980 :                count--;

  014a8	41		 inc	 ecx
  014a9	46		 inc	 esi
  014aa	48		 dec	 eax
  014ab	75 f5		 jne	 SHORT $LL31@Railgun_Qu
$LN58@Railgun_Qu:

; 1981 :          }
; 1982 :          if ( count == 0) return((pbTarget-cbPattern));

  014ad	8b c3		 mov	 eax, ebx
  014af	2b c5		 sub	 eax, ebp

; 2008 :             return(NULL);

  014b1	eb 15		 jmp	 SHORT $LN65@Railgun_Qu
$LN30@Railgun_Qu:

; 1981 :          }
; 1982 :          if ( count == 0) return((pbTarget-cbPattern));

  014b3	85 c0		 test	 eax, eax
  014b5	74 f6		 je	 SHORT $LN58@Railgun_Qu
  014b7	8b 74 24 18	 mov	 esi, DWORD PTR _pbPattern$GSCopy$[esp+1072]
  014bb	8b 44 24 10	 mov	 eax, DWORD PTR tv701[esp+1072]
$LN64@Railgun_Qu:

; 1983 :         }
; 1984 : 
; 1985 :         // The fragment below gives for 'cbPattern'>=2:
; 1986 : 	// Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/554
; 1987 : 	// Karp_Rabin_Kaze_4_OCTETS performance: 364KB/clock
; 1988 : /*
; 1989 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 1990 :          count = countSTATIC>>2;
; 1991 :          countRemainder = countSTATIC % 4;
; 1992 : 
; 1993 :          while ( count && *(unsigned long *)(pbPattern+1+((count-1)<<2)) == *(unsigned long *)(pbTarget-cbPattern+1+((count-1)<<2)) ) {
; 1994 :                count--;
; 1995 :          }
; 1996 : 	 //if (count == 0) {  // Disastrous degradation only from this line(317KB/clock when 1+2x4+2+1 bytes pattern: 'skillessness'; 312KB/clock when 1+1x4+2+1 bytes pattern: 'underdog'), otherwise 368KB/clock.
; 1997 :          while ( countRemainder && *(char *)(pbPattern+1+(countSTATIC-countRemainder)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-countRemainder)) ) {
; 1998 :                countRemainder--;
; 1999 :          }
; 2000 :          //if ( countRemainder == 0) return((long)(pbTarget-cbPattern));
; 2001 :          if ( count+countRemainder == 0) return((long)(pbTarget-cbPattern));
; 2002 :          //}
; 2003 :         }
; 2004 : */
; 2005 : 
; 2006 :         pbTarget++;

  014bf	43		 inc	 ebx

; 2007 :         if (pbTarget > pbTargetMax)

  014c0	3b 5c 24 28	 cmp	 ebx, DWORD PTR _pbTargetMax$[esp+1072]
  014c4	76 ba		 jbe	 SHORT $LL34@Railgun_Qu
$LN5@Railgun_Qu:

; 2075 :     }
; 2076 :     return(NULL);

  014c6	33 c0		 xor	 eax, eax
$LN65@Railgun_Qu:

; 2077 : } //if (cbTarget<961)
; 2078 : } //if ( cbPattern<4)
; 2079 : }

  014c8	8b 8c 24 2c 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1072]
  014cf	5f		 pop	 edi
  014d0	5e		 pop	 esi
  014d1	5d		 pop	 ebp
  014d2	5b		 pop	 ebx
  014d3	33 cc		 xor	 ecx, esp
  014d5	e8 00 00 00 00	 call	 @__security_check_cookie@4
  014da	81 c4 20 04 00
	00		 add	 esp, 1056		; 00000420H
  014e0	c3		 ret	 0
$LN35@Railgun_Qu:

; 2010 : } else { //if ( cbPattern<4)
; 2011 : if (cbTarget<961) // This value is arbitrary(don't know how exactly), it ensures(at least must) better performance than 'Boyer_Moore_Horspool'.

  014e1	81 fa c1 03 00
	00		 cmp	 edx, 961		; 000003c1H
  014e7	0f 83 dd 00 00
	00		 jae	 $LN26@Railgun_Qu

; 2012 : {
; 2013 :         pbTarget = pbTarget+cbPattern;
; 2014 :         ulHashPattern = *(unsigned long *)(pbPattern);

  014ed	8b 16		 mov	 edx, DWORD PTR [esi]

; 2015 :         countSTATIC = cbPattern-1;
; 2016 : 
; 2017 :     //SINGLET = *(char *)(pbPattern);
; 2018 :     SINGLET = ulHashPattern & 0xFF;
; 2019 :     Quadruplet2nd = SINGLET<<8;

  014ef	0f b6 c2	 movzx	 eax, dl
  014f2	8b c8		 mov	 ecx, eax
  014f4	c1 e1 08	 shl	 ecx, 8
  014f7	89 4c 24 1c	 mov	 DWORD PTR _Quadruplet2nd$[esp+1072], ecx

; 2020 :     Quadruplet3rd = SINGLET<<16;

  014fb	8b c8		 mov	 ecx, eax
  014fd	03 dd		 add	 ebx, ebp
  014ff	c1 e1 10	 shl	 ecx, 16			; 00000010H
  01502	89 44 24 10	 mov	 DWORD PTR tv544[esp+1072], eax

; 2021 :     Quadruplet4th = SINGLET<<24;

  01506	c1 e0 18	 shl	 eax, 24			; 00000018H
  01509	89 9c 24 34 04
	00 00		 mov	 DWORD PTR _pbTarget$[esp+1068], ebx
  01510	89 54 24 20	 mov	 DWORD PTR _ulHashPattern$[esp+1072], edx
  01514	89 4c 24 14	 mov	 DWORD PTR _Quadruplet3rd$[esp+1072], ecx
  01518	89 44 24 24	 mov	 DWORD PTR _Quadruplet4th$[esp+1072], eax
  0151c	8d 64 24 00	 npad	 4
$LL25@Railgun_Qu:

; 2022 : 
; 2023 :     for ( ;; )
; 2024 :     {
; 2025 : 	AdvanceHopperGrass = 0;
; 2026 : 	ulHashTarget = *(unsigned long *)(pbTarget-cbPattern);

  01520	8b cb		 mov	 ecx, ebx
  01522	2b cd		 sub	 ecx, ebp
  01524	8b 01		 mov	 eax, DWORD PTR [ecx]
  01526	33 f6		 xor	 esi, esi

; 2027 : 
; 2028 :         if ( ulHashPattern == ulHashTarget ) { // Three unnecessary comparisons here, but 'AdvanceHopperGrass' must be calculated - it has a higher priority.

  01528	3b d0		 cmp	 edx, eax
  0152a	75 4a		 jne	 SHORT $LN23@Railgun_Qu

; 2029 :          count = countSTATIC;

  0152c	8d 45 ff	 lea	 eax, DWORD PTR [ebp-1]

; 2030 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {

  0152f	85 c0		 test	 eax, eax
  01531	0f 84 76 ff ff
	ff		 je	 $LN58@Railgun_Qu

; 2029 :          count = countSTATIC;

  01537	8b 54 24 18	 mov	 edx, DWORD PTR _pbPattern$GSCopy$[esp+1072]
  0153b	42		 inc	 edx
  0153c	8d 79 01	 lea	 edi, DWORD PTR [ecx+1]
  0153f	90		 npad	 1
$LL22@Railgun_Qu:

; 2030 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {

  01540	8a 0f		 mov	 cl, BYTE PTR [edi]
  01542	38 0a		 cmp	 BYTE PTR [edx], cl
  01544	75 26		 jne	 SHORT $LN21@Railgun_Qu

; 2031 : 	       if ( countSTATIC==AdvanceHopperGrass+count && SINGLET != *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) AdvanceHopperGrass++;

  01546	8d 1c 06	 lea	 ebx, DWORD PTR [esi+eax]
  01549	8d 4d ff	 lea	 ecx, DWORD PTR [ebp-1]
  0154c	3b cb		 cmp	 ecx, ebx
  0154e	75 0a		 jne	 SHORT $LN62@Railgun_Qu
  01550	0f be 0f	 movsx	 ecx, BYTE PTR [edi]
  01553	39 4c 24 10	 cmp	 DWORD PTR tv544[esp+1072], ecx
  01557	74 01		 je	 SHORT $LN62@Railgun_Qu
  01559	46		 inc	 esi
$LN62@Railgun_Qu:

; 2030 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {

  0155a	8b 9c 24 34 04
	00 00		 mov	 ebx, DWORD PTR _pbTarget$[esp+1068]

; 2032 :                count--;

  01561	42		 inc	 edx
  01562	47		 inc	 edi
  01563	48		 dec	 eax
  01564	0f 84 43 ff ff
	ff		 je	 $LN58@Railgun_Qu

; 2030 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {

  0156a	eb d4		 jmp	 SHORT $LL22@Railgun_Qu
$LN21@Railgun_Qu:

; 2033 :          }
; 2034 :          if ( count == 0) return((pbTarget-cbPattern));

  0156c	85 c0		 test	 eax, eax
  0156e	0f 84 39 ff ff
	ff		 je	 $LN58@Railgun_Qu

; 2035 :         } else { // The goal here: to avoid memory accesses by stressing the registers.

  01574	eb 36		 jmp	 SHORT $LN15@Railgun_Qu
$LN23@Railgun_Qu:

; 2036 :     if ( Quadruplet2nd != (ulHashTarget & 0x0000FF00) ) {

  01576	8b d0		 mov	 edx, eax
  01578	81 e2 00 ff 00
	00		 and	 edx, 65280		; 0000ff00H
  0157e	39 54 24 1c	 cmp	 DWORD PTR _Quadruplet2nd$[esp+1072], edx
  01582	74 28		 je	 SHORT $LN15@Railgun_Qu

; 2037 :          AdvanceHopperGrass++;
; 2038 :          if ( Quadruplet3rd != (ulHashTarget & 0x00FF0000) ) {

  01584	8b c8		 mov	 ecx, eax
  01586	81 e1 00 00 ff
	00		 and	 ecx, 16711680		; 00ff0000H
  0158c	be 01 00 00 00	 mov	 esi, 1
  01591	39 4c 24 14	 cmp	 DWORD PTR _Quadruplet3rd$[esp+1072], ecx
  01595	74 15		 je	 SHORT $LN15@Railgun_Qu

; 2039 :               AdvanceHopperGrass++;
; 2040 :               if ( Quadruplet4th != (ulHashTarget & 0xFF000000) ) AdvanceHopperGrass++;;

  01597	25 00 00 00 ff	 and	 eax, -16777216		; ff000000H
  0159c	be 02 00 00 00	 mov	 esi, 2
  015a1	39 44 24 24	 cmp	 DWORD PTR _Quadruplet4th$[esp+1072], eax
  015a5	74 05		 je	 SHORT $LN15@Railgun_Qu
  015a7	be 03 00 00 00	 mov	 esi, 3
$LN15@Railgun_Qu:

; 2041 :          }
; 2042 :     }
; 2043 : 	}
; 2044 : 
; 2045 : 	AdvanceHopperGrass++;
; 2046 : 
; 2047 : 	pbTarget = pbTarget + AdvanceHopperGrass;

  015ac	8d 5c 33 01	 lea	 ebx, DWORD PTR [ebx+esi+1]
  015b0	89 9c 24 34 04
	00 00		 mov	 DWORD PTR _pbTarget$[esp+1068], ebx

; 2048 :         if (pbTarget > pbTargetMax)

  015b7	3b 5c 24 28	 cmp	 ebx, DWORD PTR _pbTargetMax$[esp+1072]
  015bb	0f 87 05 ff ff
	ff		 ja	 $LN5@Railgun_Qu

; 2049 :             return(NULL);
; 2050 :     }

  015c1	8b 54 24 20	 mov	 edx, DWORD PTR _ulHashPattern$[esp+1072]
  015c5	e9 56 ff ff ff	 jmp	 $LL25@Railgun_Qu
$LN26@Railgun_Qu:

; 2051 : } else { //if (cbTarget<961)
; 2052 :         countSTATIC = cbPattern-2;

  015ca	8d 45 fe	 lea	 eax, DWORD PTR [ebp-2]
  015cd	89 44 24 14	 mov	 DWORD PTR _countSTATIC$[esp+1072], eax

; 2053 :     /* Preprocessing */
; 2054 :     for (a=0; a < ASIZE; a++) bm_bc[a]=cbPattern;

  015d1	8b c5		 mov	 eax, ebp
  015d3	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  015d8	8d 7c 24 2c	 lea	 edi, DWORD PTR _bm_bc$[esp+1072]
  015dc	f3 ab		 rep stosd

; 2055 :     for (j=0; j < cbPattern-1; j++) bm_bc[pbPattern[j]]=cbPattern-j-1;

  015de	8d 4d ff	 lea	 ecx, DWORD PTR [ebp-1]
  015e1	33 c0		 xor	 eax, eax
  015e3	85 c9		 test	 ecx, ecx
  015e5	74 1a		 je	 SHORT $LN7@Railgun_Qu
  015e7	8d 7d ff	 lea	 edi, DWORD PTR [ebp-1]
  015ea	8d 9b 00 00 00
	00		 npad	 6
$LL9@Railgun_Qu:
  015f0	0f be 0c 06	 movsx	 ecx, BYTE PTR [esi+eax]
  015f4	89 7c 8c 2c	 mov	 DWORD PTR _bm_bc$[esp+ecx*4+1072], edi
  015f8	40		 inc	 eax
  015f9	8d 4d ff	 lea	 ecx, DWORD PTR [ebp-1]
  015fc	4f		 dec	 edi
  015fd	3b c1		 cmp	 eax, ecx
  015ff	72 ef		 jb	 SHORT $LL9@Railgun_Qu
$LN7@Railgun_Qu:

; 2056 : 
; 2057 :     /* Searching */
; 2058 :     //lastch=pbPattern[cbPattern-1];
; 2059 :     //firstch=pbPattern[0];
; 2060 :     i=0;
; 2061 :     while (i <= cbTarget-cbPattern) {

  01601	0f be 44 2e ff	 movsx	 eax, BYTE PTR [esi+ebp-1]
  01606	33 ff		 xor	 edi, edi
  01608	2b d5		 sub	 edx, ebp
  0160a	89 54 24 10	 mov	 DWORD PTR $T6785[esp+1072], edx
  0160e	8d 54 2b ff	 lea	 edx, DWORD PTR [ebx+ebp-1]
  01612	89 54 24 20	 mov	 DWORD PTR tv569[esp+1072], edx
  01616	89 44 24 24	 mov	 DWORD PTR tv392[esp+1072], eax
  0161a	8d 9b 00 00 00
	00		 npad	 6
$LL6@Railgun_Qu:

; 2062 :        ch=pbTarget[i+cbPattern-1];
; 2063 :        //if (ch ==lastch)
; 2064 :           //if (memcmp(&pbTarget[i],pbPattern,cbPattern-1) == 0) OUTPUT(i);
; 2065 :           //if (ch == lastch && pbTarget[i] == firstch && memcmp(&pbTarget[i],pbPattern,cbPattern-1) == 0) return(i);  // Kaze: The idea(to prevent execution of slower 'memcmp') is borrowed from Karp-Rabin i.e. to perform a slower check only when the target "looks like".
; 2066 :           if (ch == pbPattern[cbPattern-1] && pbTarget[i] == pbPattern[0])

  01620	8b 4c 24 20	 mov	 ecx, DWORD PTR tv569[esp+1072]
  01624	0f b6 2c 39	 movzx	 ebp, BYTE PTR [ecx+edi]
  01628	3b 6c 24 24	 cmp	 ebp, DWORD PTR tv392[esp+1072]
  0162c	75 2f		 jne	 SHORT $LN1@Railgun_Qu
  0162e	8a 14 1f	 mov	 dl, BYTE PTR [edi+ebx]
  01631	3a 16		 cmp	 dl, BYTE PTR [esi]
  01633	75 28		 jne	 SHORT $LN1@Railgun_Qu

; 2067 :              {
; 2068 :          count = countSTATIC;

  01635	8b 44 24 14	 mov	 eax, DWORD PTR _countSTATIC$[esp+1072]

; 2069 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+(countSTATIC-count)) ) {

  01639	85 c0		 test	 eax, eax
  0163b	74 10		 je	 SHORT $LN51@Railgun_Qu

; 2067 :              {
; 2068 :          count = countSTATIC;

  0163d	46		 inc	 esi
  0163e	8d 4c 1f 01	 lea	 ecx, DWORD PTR [edi+ebx+1]
$LL3@Railgun_Qu:

; 2069 :          while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+(countSTATIC-count)) ) {

  01642	8a 16		 mov	 dl, BYTE PTR [esi]
  01644	3a 11		 cmp	 dl, BYTE PTR [ecx]
  01646	75 0d		 jne	 SHORT $LN2@Railgun_Qu

; 2070 :                count--;

  01648	41		 inc	 ecx
  01649	46		 inc	 esi
  0164a	48		 dec	 eax
  0164b	75 f5		 jne	 SHORT $LL3@Railgun_Qu
$LN51@Railgun_Qu:

; 2071 :          }
; 2072 :          if ( count == 0) return(pbTarget+i);

  0164d	8d 04 1f	 lea	 eax, DWORD PTR [edi+ebx]
  01650	e9 73 fe ff ff	 jmp	 $LN65@Railgun_Qu
$LN2@Railgun_Qu:
  01655	85 c0		 test	 eax, eax
  01657	74 f4		 je	 SHORT $LN51@Railgun_Qu
  01659	8b 74 24 18	 mov	 esi, DWORD PTR _pbPattern$GSCopy$[esp+1072]
$LN1@Railgun_Qu:

; 2073 : 	     }
; 2074 :        i+=bm_bc[ch];

  0165d	03 7c ac 2c	 add	 edi, DWORD PTR _bm_bc$[esp+ebp*4+1072]
  01661	3b 7c 24 10	 cmp	 edi, DWORD PTR $T6785[esp+1072]
  01665	76 b9		 jbe	 SHORT $LL6@Railgun_Qu

; 2056 : 
; 2057 :     /* Searching */
; 2058 :     //lastch=pbPattern[cbPattern-1];
; 2059 :     //firstch=pbPattern[0];
; 2060 :     i=0;
; 2061 :     while (i <= cbTarget-cbPattern) {

  01667	e9 5a fe ff ff	 jmp	 $LN5@Railgun_Qu
_Railgun_Quadruplet ENDP
_TEXT	ENDS
PUBLIC	_strip_ext
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_str$ = 8						; size = 4
_strip_ext PROC

; 2084 :    int i;
; 2085 :    for(i = strlen(str)-1; str[i] != '.' && i >= 0; i--)

  01670	8b 4c 24 04	 mov	 ecx, DWORD PTR _str$[esp-4]
  01674	8b c1		 mov	 eax, ecx
  01676	56		 push	 esi
  01677	8d 70 01	 lea	 esi, DWORD PTR [eax+1]
  0167a	8d 9b 00 00 00
	00		 npad	 6
$LL9@strip_ext:
  01680	8a 10		 mov	 dl, BYTE PTR [eax]
  01682	40		 inc	 eax
  01683	84 d2		 test	 dl, dl
  01685	75 f9		 jne	 SHORT $LL9@strip_ext
  01687	2b c6		 sub	 eax, esi
  01689	48		 dec	 eax
  0168a	80 3c 08 2e	 cmp	 BYTE PTR [eax+ecx], 46	; 0000002eH
  0168e	5e		 pop	 esi
  0168f	74 0b		 je	 SHORT $LN2@strip_ext
$LL4@strip_ext:
  01691	85 c0		 test	 eax, eax
  01693	78 09		 js	 SHORT $LN10@strip_ext
  01695	48		 dec	 eax
  01696	80 3c 08 2e	 cmp	 BYTE PTR [eax+ecx], 46	; 0000002eH
  0169a	75 f5		 jne	 SHORT $LL4@strip_ext
$LN2@strip_ext:

; 2086 :       ;
; 2087 :    if(i > 0)

  0169c	85 c0		 test	 eax, eax
$LN10@strip_ext:
  0169e	7e 04		 jle	 SHORT $LN1@strip_ext

; 2088 :       str[i] = '\0';

  016a0	c6 04 08 00	 mov	 BYTE PTR [eax+ecx], 0
$LN1@strip_ext:

; 2089 : }

  016a4	c3		 ret	 0
_strip_ext ENDP
_TEXT	ENDS
PUBLIC	__real@408f400000000000
PUBLIC	__real@3ff0000000000000
PUBLIC	_argv$GSCopy$
PUBLIC	__$ArrayPad$
PUBLIC	_main
EXTRN	_putc:PROC
EXTRN	_fprintf:PROC
EXTRN	_ftell:PROC
EXTRN	_fseek:PROC
EXTRN	_free:PROC
EXTRN	_fclose:PROC
EXTRN	_fwrite:PROC
EXTRN	_fread:PROC
EXTRN	_toupper:PROC
EXTRN	_clock:PROC
EXTRN	_puts:PROC
EXTRN	_malloc:PROC
EXTRN	_fopen:PROC
EXTRN	_printf:PROC
EXTRN	__fltused:DWORD
EXTRN	__ftol2_sse:PROC
EXTRN	_memcpy:PROC
;	COMDAT __real@408f400000000000
CONST	SEGMENT
__real@408f400000000000 DQ 0408f400000000000r	; 1000
CONST	ENDS
;	COMDAT __real@3ff0000000000000
CONST	SEGMENT
__real@3ff0000000000000 DQ 03ff0000000000000r	; 1
; Function compile flags: /Ogtpy
CONST	ENDS
_TEXT	SEGMENT
_Strnglen$ = -360					; size = 4
_GainOrder$ = -356					; size = 4
tv1993 = -352						; size = 4
tv1980 = -352						; size = 4
tv1970 = -352						; size = 4
tv1472 = -352						; size = 4
_bufEXTENSION$ = -352					; size = 4
_GainMax$ = -352					; size = 4
_Strng$ = -348						; size = 4
_PivotPointBS$ = -344					; size = 4
_linecounterRL$ = -344					; size = 4
tv2248 = -340						; size = 4
_fp_outLINE$ = -340					; size = 4
_linecounterNotRL$ = -336				; size = 4
_BB$ = -336						; size = 4
_RightPointBS$ = -332					; size = 4
_fp_inLINE$ = -332					; size = 4
tv1795 = -328						; size = 4
tv1788 = -328						; size = 4
tv1641 = -328						; size = 4
_argv$GSCopy$ = -328					; size = 4
$T6834 = -324						; size = 4
_ThunderwithR$ = -324					; size = 4
_LeftPointBS$ = -320					; size = 4
_j$ = -320						; size = 4
_BuildingBlocksBox$ = -316				; size = 10
_llTOaDigits$ = -304					; size = 27
_SSheader$ = -276					; size = 270
__$ArrayPad$ = -4					; size = 4
_argc$ = 8						; size = 4
_argv$ = 12						; size = 4
_main	PROC

; 2093 :   {

  016b0	81 ec 68 01 00
	00		 sub	 esp, 360		; 00000168H
  016b6	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  016bb	33 c4		 xor	 eax, esp
  016bd	89 84 24 64 01
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+360], eax

; 2094 : FILE *fp_inLINE;
; 2095 : FILE *fp_outLINE;
; 2096 : int Bozan;
; 2097 : long ThunderwithL, ThunderwithR;
; 2098 : char *Strng;
; 2099 : char *BB;
; 2100 : long Strnglen;
; 2101 : long StrnglenTRAVERSED;
; 2102 : char Pattern[20+2000]; // skillessness=12 human consciousness=19 I should have known=19
; 2103 : // In the East, enlightenment is described as a state of ultimate=62
; 2104 : //int Patternlen;      // Make it global in sake of QSORT
; 2105 : long LinesEncountered=0;
; 2106 : long BruteForceDummyhits=0;
; 2107 : long KarpRabinKazehits=0;
; 2108 : long KarpRabinKaze_BOOSTEDhits=0;
; 2109 : long Karp_Rabin_Kaze_4_OCTETShits=0;
; 2110 : long KarpRabinhits=0;
; 2111 : long HORSPOOLhits=0;
; 2112 : long HORSPOOL_Kazehits=0;
; 2113 : long strstrMicrosofthits=0;
; 2114 : long strstrGNUCLibraryhits=0;
; 2115 : 
; 2116 :    unsigned char *bufEXTENSION;
; 2117 : 
; 2118 : //int i, j;
; 2119 : int i,j;
; 2120 : register int iREGISTER;
; 2121 : register int jREGISTER;
; 2122 : 
; 2123 : char *DumboBox[8][2] = { "an\0", "to\0",
; 2124 :                          "TDK\0", "the\0",
; 2125 :                          "fast\0", "easy\0",
; 2126 :                          "grmbl\0", "email\0",
; 2127 :                          "pasting\0", "amazing\0",
; 2128 :                          "underdog\0", "superdog\0",
; 2129 :                          "participants\0", "skillessness\0",
; 2130 :                          "I should have known\0", "human consciousness\0"
; 2131 : };
; 2132 : 
; 2133 : long FoundIn;
; 2134 : char *FoundInPTR,*FoundInPTRNEW;
; 2135 : char llTOaDigits[27]; // 9,223,372,036,854,775,807: 1(sign or carry)+19(digits)+1('\0')+6(,)
; 2136 : char BuildingBlocksBox[10] = "BB---.txt\0";

  016c4	a1 00 00 00 00	 mov	 eax, DWORD PTR $SG5965
  016c9	8b 0d 04 00 00
	00		 mov	 ecx, DWORD PTR $SG5965+4
  016cf	66 8b 15 08 00
	00 00		 mov	 dx, WORD PTR $SG5965+8
  016d6	56		 push	 esi
  016d7	8b b4 24 74 01
	00 00		 mov	 esi, DWORD PTR _argv$[esp+360]

; 2137 : 
; 2138 :    int nlines = 0;
; 2139 :    string basep, cur, next;
; 2140 :    string *ASbackup;
; 2141 : 
; 2142 :    unsigned long nlines1, linecounterNotRL, linecounterRL, jPrevLine, jFirst;
; 2143 : 
; 2144 : signed long GainMax=0x80000000; //-2147483648
; 2145 : int GainOrder=0; register int GainOrderREGISTER;
; 2146 : signed int NataliaKills;
; 2147 : int YabbaYabba = 0;
; 2148 : long LeftPointBS, RightPointBS, PivotPointBS;
; 2149 : char SSheader[270];
; 2150 : 
; 2151 : printf("Simplicius_Simplicissimus_Septupleton rev.2-, written by Kaze.\n");

  016de	68 00 00 00 00	 push	 OFFSET $SG5985
  016e3	89 74 24 28	 mov	 DWORD PTR _argv$GSCopy$[esp+368], esi
  016e7	89 44 24 34	 mov	 DWORD PTR _BuildingBlocksBox$[esp+368], eax
  016eb	89 4c 24 38	 mov	 DWORD PTR _BuildingBlocksBox$[esp+372], ecx
  016ef	66 89 54 24 3c	 mov	 WORD PTR _BuildingBlocksBox$[esp+376], dx
  016f4	c7 44 24 10 00
	00 00 80	 mov	 DWORD PTR _GainMax$[esp+368], -2147483648 ; 80000000H
  016fc	c7 44 24 0c 00
	00 00 00	 mov	 DWORD PTR _GainOrder$[esp+368], 0
  01704	e8 00 00 00 00	 call	 _printf

; 2152 : printf("Note1: This is the precursor of Simplicius Simplicissimus - a superfast-low-performance TEXT decompressor.\n");

  01709	68 00 00 00 00	 push	 OFFSET $SG5986
  0170e	e8 00 00 00 00	 call	 _printf

; 2153 : printf("Note2: The niftiness lies in readiness for multi-threading and mostly in boosting the search by having the BBs.\n");

  01713	68 00 00 00 00	 push	 OFFSET $SG5987
  01718	e8 00 00 00 00	 call	 _printf

; 2154 : printf("       The decompressor would upload (at burst speed) the BB data and then read-and-decode one-by-one the\n");

  0171d	68 00 00 00 00	 push	 OFFSET $SG5988
  01722	e8 00 00 00 00	 call	 _printf

; 2155 : printf("       triads (BB pool/array indexes), that is a simple copying. The pool houses up to 256*256*256 BBs/elements.\n");

  01727	68 00 00 00 00	 push	 OFFSET $SG5989
  0172c	e8 00 00 00 00	 call	 _printf

; 2156 : printf("Note3: Compiler used: Intel(R) C++ Compiler XE for applications running on IA-32, Version 12.0.4.196 Build 20110427.\n");

  01731	68 00 00 00 00	 push	 OFFSET $SG5990
  01736	e8 00 00 00 00	 call	 _printf

; 2157 : printf("Note4: Compile line: icl /Ox /TcBuilding-Blocks_DUMPER.c /FaBuilding-Blocks_DUMPER /w /FAcs\n");

  0173b	68 00 00 00 00	 push	 OFFSET $SG5991
  01740	e8 00 00 00 00	 call	 _printf

; 2158 : printf("Note5: Maximum size of input text file is arbitrary - 384MB, in fact 384MB+4*384MB must be less than 19??MB.\n");

  01745	68 00 00 00 00	 push	 OFFSET $SG5992
  0174a	e8 00 00 00 00	 call	 _printf

; 2159 : printf("Note6: The file format is given by typing the compressed file e.g. D:\\>type OSHO.TXT.SS.\n");

  0174f	68 00 00 00 00	 push	 OFFSET $SG5993
  01754	e8 00 00 00 00	 call	 _printf

; 2160 : printf("       The header is 270 bytes long followed by BBs and triads/indexes and the eventual remainder/literals.\n");

  01759	68 00 00 00 00	 push	 OFFSET $SG5994
  0175e	e8 00 00 00 00	 call	 _printf

; 2161 : printf("Note7: My benchmark text file OSHO.TXT 206,908,949 bytes where OSHO.TXT.SS 116,871,584 bytes for order 6:\n");

  01763	68 00 00 00 00	 push	 OFFSET $SG5995
  01768	e8 00 00 00 00	 call	 _printf

; 2162 : printf("       Decompressing OSHO.TXT.SS to RAM without Dumping to DRIVE time: 1704 clocks or 118579 KB/s, an awful result.\n");

  0176d	68 00 00 00 00	 push	 OFFSET $SG5996
  01772	e8 00 00 00 00	 call	 _printf

; 2163 : printf("       For order 4 enforced: 156,174,067 OSHO.TXT.SS is being decompressed at 192804 KB/s.\n");

  01777	68 00 00 00 00	 push	 OFFSET $SG5997
  0177c	e8 00 00 00 00	 call	 _printf

; 2164 : printf("       For order 7 enforced: 122,297,608 OSHO.TXT.SS is being decompressed at 85618 KB/s.\n");

  01781	68 00 00 00 00	 push	 OFFSET $SG5998
  01786	e8 00 00 00 00	 call	 _printf

; 2165 : printf("       For order 8 enforced: 149,243,106 OSHO.TXT.SS is being decompressed at 115396 KB/s.\n");

  0178b	68 00 00 00 00	 push	 OFFSET $SG5999
  01790	e8 00 00 00 00	 call	 _printf

; 2166 : printf("       Obviously the fastest cache size is crucial, for OSHO.TXT 12MB BB pool vs 1MB L2 cache disbalance is the\n");

  01795	68 00 00 00 00	 push	 OFFSET $SG6000
  0179a	e8 00 00 00 00	 call	 _printf
  0179f	83 c4 40	 add	 esp, 64			; 00000040H

; 2167 : printf("       cause for this badly inferior performance compared to LZ L1 (32KB) cache-friendly variants.\n");

  017a2	68 00 00 00 00	 push	 OFFSET $SG6001
  017a7	e8 00 00 00 00	 call	 _printf

; 2168 : printf("       The test machine is Toshiba Satellite with Intel Merom 2166MHz, with rough 'memcpy' performance: 1646 MB/s.\n");

  017ac	68 00 00 00 00	 push	 OFFSET $SG6002
  017b1	e8 00 00 00 00	 call	 _printf

; 2169 : printf("Note8: Compile line: cl /Ox /TcBuilding-Blocks_DUMPER.c /FaBuilding-Blocks_DUMPER /w /FAcs\n");

  017b6	68 00 00 00 00	 push	 OFFSET $SG6003
  017bb	e8 00 00 00 00	 call	 _printf

; 2170 : printf("Note9: Major (but still inferior) decompressing tweak since r.1+++, this time Microsoft v16 excels:\n");

  017c0	68 00 00 00 00	 push	 OFFSET $SG6004
  017c5	e8 00 00 00 00	 call	 _printf

; 2171 : printf("       For order 7 enforced: 122,297,608 OSHO.TXT.SS is being decompressed at 170083 KB/s.\n");

  017ca	68 00 00 00 00	 push	 OFFSET $SG6005
  017cf	e8 00 00 00 00	 call	 _printf

; 2172 : printf("NoteA: Simplicius_Simplicissimus stands up for his name, the decompressing fragment is 13 instructions small:\n");

  017d4	68 00 00 00 00	 push	 OFFSET $SG6006
  017d9	e8 00 00 00 00	 call	 _printf

; 2173 : printf("       $LL74@main:\n");

  017de	68 00 00 00 00	 push	 OFFSET $SG6007
  017e3	e8 00 00 00 00	 call	 _printf

; 2174 : printf("       a1 00 00 00 00   mov     eax, DWORD PTR _Patternlen\n");

  017e8	68 00 00 00 00	 push	 OFFSET $SG6008
  017ed	e8 00 00 00 00	 call	 _printf

; 2175 : printf("       03 c2            add     eax, edx\n");

  017f2	68 00 00 00 00	 push	 OFFSET $SG6009
  017f7	e8 00 00 00 00	 call	 _printf

; 2176 : printf("       8b 04 30         mov     eax, DWORD PTR [eax+esi]\n");

  017fc	68 00 00 00 00	 push	 OFFSET $SG6010
  01801	e8 00 00 00 00	 call	 _printf

; 2177 : printf("       25 ff ff ff 00   and     eax, 16777215\n");

  01806	68 00 00 00 00	 push	 OFFSET $SG6011
  0180b	e8 00 00 00 00	 call	 _printf

; 2178 : printf("       0f af c7         imul    eax, edi\n");

  01810	68 00 00 00 00	 push	 OFFSET $SG6012
  01815	e8 00 00 00 00	 call	 _printf

; 2179 : printf("       8b 1c 30         mov     ebx, DWORD PTR [eax+esi]\n");

  0181a	68 00 00 00 00	 push	 OFFSET $SG6013
  0181f	e8 00 00 00 00	 call	 _printf

; 2180 : printf("       89 19            mov     DWORD PTR [ecx], ebx\n");

  01824	68 00 00 00 00	 push	 OFFSET $SG6014
  01829	e8 00 00 00 00	 call	 _printf

; 2181 : printf("       8b 44 30 04      mov     eax, DWORD PTR [eax+esi+4]\n");

  0182e	68 00 00 00 00	 push	 OFFSET $SG6015
  01833	e8 00 00 00 00	 call	 _printf

; 2182 : printf("       89 41 04         mov     DWORD PTR [ecx+4], eax\n");

  01838	68 00 00 00 00	 push	 OFFSET $SG6016
  0183d	e8 00 00 00 00	 call	 _printf
  01842	83 c4 40	 add	 esp, 64			; 00000040H

; 2183 : printf("       83 c2 03         add     edx, 3\n");

  01845	68 00 00 00 00	 push	 OFFSET $SG6017
  0184a	e8 00 00 00 00	 call	 _printf

; 2184 : printf("       03 cf            add     ecx, edi\n");

  0184f	68 00 00 00 00	 push	 OFFSET $SG6018
  01854	e8 00 00 00 00	 call	 _printf

; 2185 : printf("       ff 4c 24 1c      dec     DWORD PTR tv977[esp+376]\n");

  01859	68 00 00 00 00	 push	 OFFSET $SG6019
  0185e	e8 00 00 00 00	 call	 _printf

; 2186 : printf("       75 d7            jne     SHORT $LL74@main\n");

  01863	68 00 00 00 00	 push	 OFFSET $SG6020
  01868	e8 00 00 00 00	 call	 _printf

; 2187 : printf("NoteB: For more fast decompressing idea(s) you may contact me at sanmayce@sanmayce.com freely.\n");

  0186d	68 00 00 00 00	 push	 OFFSET $SG6021
  01872	e8 00 00 00 00	 call	 _printf

; 2188 : printf("NoteC: Got it? The B note has two meanings: 1] for faster 2] for additional/other fast.\n");

  01877	68 00 00 00 00	 push	 OFFSET $SG6022
  0187c	e8 00 00 00 00	 call	 _printf

; 2189 : printf("NoteD: Got it? The C note has two meanings: 1] for quicker/tighter 2] for additional/other quick/tight.\n");

  01881	68 00 00 00 00	 push	 OFFSET $SG6023
  01886	e8 00 00 00 00	 call	 _printf

; 2190 : printf("NoteE: Since r.2- a new Quicksort function is in use due to the bugginess of the old.\n");

  0188b	68 00 00 00 00	 push	 OFFSET $SG6024
  01890	e8 00 00 00 00	 call	 _printf

; 2191 : printf("NoteF: A stupid bug (one triad was missing) was crushed also.\n");

  01895	68 00 00 00 00	 push	 OFFSET $SG6025
  0189a	e8 00 00 00 00	 call	 _printf
  0189f	83 c4 24	 add	 esp, 36			; 00000024H

; 2192 : 
; 2193 : 
; 2194 : Pattern[0]=0x00;
; 2195 : 
; 2196 : if( argc != 2 )

  018a2	83 bc 24 70 01
	00 00 02	 cmp	 DWORD PTR _argc$[esp+360], 2
  018aa	74 46		 je	 SHORT $LN93@main

; 2197 : { printf( "\nUsage: Building-Blocks_DUMPER textfilename\n" );

  018ac	68 00 00 00 00	 push	 OFFSET $SG6027
  018b1	e8 00 00 00 00	 call	 _printf

; 2198 :   printf( "Example1: Building-Blocks_DUMPER The_Little_Match_Girl.txt\n" );

  018b6	68 00 00 00 00	 push	 OFFSET $SG6028
  018bb	e8 00 00 00 00	 call	 _printf

; 2199 :   printf( "Example2: Building-Blocks_DUMPER The_Little_Match_Girl.txt.SS\n" );

  018c0	68 00 00 00 00	 push	 OFFSET $SG6029
  018c5	e8 00 00 00 00	 call	 _printf

; 2200 :   printf( "Note: When the extension is not .SS then compression is commenced otherwise decompression.\n" );

  018ca	68 00 00 00 00	 push	 OFFSET $SG6030
  018cf	e8 00 00 00 00	 call	 _printf
  018d4	83 c4 10	 add	 esp, 16			; 00000010H

; 2201 :   return( 1 ); }

  018d7	b8 01 00 00 00	 mov	 eax, 1
  018dc	5e		 pop	 esi

; 2817 :   }

  018dd	8b 8c 24 64 01
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+360]
  018e4	33 cc		 xor	 ecx, esp
  018e6	e8 00 00 00 00	 call	 @__security_check_cookie@4
  018eb	81 c4 68 01 00
	00		 add	 esp, 360		; 00000168H
  018f1	c3		 ret	 0
$LN93@main:

; 2202 : 
; 2203 : if( ( fp_inLINE = fopen( argv[1], "rb" ) ) == NULL )

  018f2	8b 46 04	 mov	 eax, DWORD PTR [esi+4]
  018f5	55		 push	 ebp
  018f6	68 00 00 00 00	 push	 OFFSET $SG6033
  018fb	50		 push	 eax
  018fc	e8 00 00 00 00	 call	 _fopen
  01901	8b e8		 mov	 ebp, eax
  01903	83 c4 08	 add	 esp, 8
  01906	89 6c 24 24	 mov	 DWORD PTR _fp_inLINE$[esp+368], ebp
  0190a	85 ed		 test	 ebp, ebp
  0190c	75 2b		 jne	 SHORT $LN92@main

; 2204 : { printf( "Building-Blocks_DUMPER: Can't open file %s \n", argv[1] ); return( 1 ); }

  0190e	8b 4e 04	 mov	 ecx, DWORD PTR [esi+4]
  01911	51		 push	 ecx
  01912	68 00 00 00 00	 push	 OFFSET $SG6034
  01917	e8 00 00 00 00	 call	 _printf
  0191c	83 c4 08	 add	 esp, 8
  0191f	8d 45 01	 lea	 eax, DWORD PTR [ebp+1]
  01922	5d		 pop	 ebp
  01923	5e		 pop	 esi

; 2817 :   }

  01924	8b 8c 24 64 01
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+360]
  0192b	33 cc		 xor	 ecx, esp
  0192d	e8 00 00 00 00	 call	 @__security_check_cookie@4
  01932	81 c4 68 01 00
	00		 add	 esp, 360		; 00000168H
  01938	c3		 ret	 0
$LN92@main:
  01939	53		 push	 ebx

; 2205 : 
; 2206 : printf( "\nAllocating 384MB ... " );

  0193a	68 00 00 00 00	 push	 OFFSET $SG6035
  0193f	e8 00 00 00 00	 call	 _printf

; 2207 : Strng = (char *)malloc( 384*1024*1024 +1); // +1 because one byte is read beyond pool!

  01944	68 01 00 00 18	 push	 402653185		; 18000001H
  01949	e8 00 00 00 00	 call	 _malloc
  0194e	8b d8		 mov	 ebx, eax
  01950	83 c4 08	 add	 esp, 8
  01953	89 5c 24 18	 mov	 DWORD PTR _Strng$[esp+372], ebx

; 2208 : if( Strng == NULL )

  01957	85 db		 test	 ebx, ebx
  01959	75 28		 jne	 SHORT $LN91@main

; 2209 : { puts( "Building-Blocks_DUMPER: Needed memory allocation denied!\n" ); return( 1 ); }

  0195b	68 00 00 00 00	 push	 OFFSET $SG6039
  01960	e8 00 00 00 00	 call	 _puts
  01965	83 c4 04	 add	 esp, 4
  01968	8d 43 01	 lea	 eax, DWORD PTR [ebx+1]
  0196b	5b		 pop	 ebx
  0196c	5d		 pop	 ebp
  0196d	5e		 pop	 esi

; 2817 :   }

  0196e	8b 8c 24 64 01
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+360]
  01975	33 cc		 xor	 ecx, esp
  01977	e8 00 00 00 00	 call	 @__security_check_cookie@4
  0197c	81 c4 68 01 00
	00		 add	 esp, 360		; 00000168H
  01982	c3		 ret	 0
$LN91@main:
  01983	57		 push	 edi

; 2210 : printf( "OK\n" );

  01984	68 00 00 00 00	 push	 OFFSET $SG6040
  01989	e8 00 00 00 00	 call	 _printf
  0198e	83 c4 04	 add	 esp, 4

; 2211 : 
; 2212 : clocks3 = clock();

  01991	e8 00 00 00 00	 call	 _clock
  01996	a3 00 00 00 00	 mov	 DWORD PTR _clocks3, eax

; 2213 : 
; 2214 : // DECOMPRESSOR [
; 2215 : if(toupper(argv[1][strlen(argv[1])-1]) == 'S' && toupper(argv[1][strlen(argv[1])-2]) == 'S' && argv[1][strlen(argv[1])-3] == '.') {

  0199b	8b 56 04	 mov	 edx, DWORD PTR [esi+4]
  0199e	8b c2		 mov	 eax, edx
  019a0	8d 78 01	 lea	 edi, DWORD PTR [eax+1]
$LL170@main:
  019a3	8a 08		 mov	 cl, BYTE PTR [eax]
  019a5	40		 inc	 eax
  019a6	84 c9		 test	 cl, cl
  019a8	75 f9		 jne	 SHORT $LL170@main
  019aa	2b c7		 sub	 eax, edi
  019ac	0f be 54 02 ff	 movsx	 edx, BYTE PTR [edx+eax-1]
  019b1	52		 push	 edx
  019b2	e8 00 00 00 00	 call	 _toupper
  019b7	83 c4 04	 add	 esp, 4
  019ba	83 f8 53	 cmp	 eax, 83			; 00000053H
  019bd	0f 85 95 04 00
	00		 jne	 $LN90@main
  019c3	8b 56 04	 mov	 edx, DWORD PTR [esi+4]
  019c6	8b c2		 mov	 eax, edx
  019c8	8d 78 01	 lea	 edi, DWORD PTR [eax+1]
  019cb	eb 03 8d 49 00	 npad	 5
$LL171@main:
  019d0	8a 08		 mov	 cl, BYTE PTR [eax]
  019d2	40		 inc	 eax
  019d3	84 c9		 test	 cl, cl
  019d5	75 f9		 jne	 SHORT $LL171@main
  019d7	2b c7		 sub	 eax, edi
  019d9	0f be 44 02 fe	 movsx	 eax, BYTE PTR [edx+eax-2]
  019de	50		 push	 eax
  019df	e8 00 00 00 00	 call	 _toupper
  019e4	83 c4 04	 add	 esp, 4
  019e7	83 f8 53	 cmp	 eax, 83			; 00000053H
  019ea	0f 85 68 04 00
	00		 jne	 $LN90@main
  019f0	8b 7e 04	 mov	 edi, DWORD PTR [esi+4]
  019f3	8b c7		 mov	 eax, edi
  019f5	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
$LL172@main:
  019f8	8a 08		 mov	 cl, BYTE PTR [eax]
  019fa	40		 inc	 eax
  019fb	84 c9		 test	 cl, cl
  019fd	75 f9		 jne	 SHORT $LL172@main
  019ff	2b c2		 sub	 eax, edx
  01a01	80 7c 07 fd 2e	 cmp	 BYTE PTR [edi+eax-3], 46 ; 0000002eH
  01a06	0f 85 4c 04 00
	00		 jne	 $LN90@main

; 2216 : 	bufEXTENSION = (unsigned char *) malloc(sizeof (unsigned char) * (strlen(argv[1])+1)); //when checking for .SS

  01a0c	8b c7		 mov	 eax, edi
  01a0e	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
$LL173@main:
  01a11	8a 08		 mov	 cl, BYTE PTR [eax]
  01a13	40		 inc	 eax
  01a14	84 c9		 test	 cl, cl
  01a16	75 f9		 jne	 SHORT $LL173@main
  01a18	2b c2		 sub	 eax, edx
  01a1a	40		 inc	 eax
  01a1b	50		 push	 eax
  01a1c	e8 00 00 00 00	 call	 _malloc
  01a21	8b f0		 mov	 esi, eax
  01a23	83 c4 04	 add	 esp, 4

; 2217 : 	strcpy(bufEXTENSION, argv[1]);

  01a26	8b cf		 mov	 ecx, edi
  01a28	8b d6		 mov	 edx, esi
  01a2a	8d 9b 00 00 00
	00		 npad	 6
$LL96@main:
  01a30	8a 01		 mov	 al, BYTE PTR [ecx]
  01a32	88 02		 mov	 BYTE PTR [edx], al
  01a34	41		 inc	 ecx
  01a35	42		 inc	 edx
  01a36	84 c0		 test	 al, al
  01a38	75 f6		 jne	 SHORT $LL96@main

; 2218 : 	strip_ext(bufEXTENSION);

  01a3a	56		 push	 esi
  01a3b	e8 00 00 00 00	 call	 _strip_ext

; 2219 : printf ("\nSimplicius Simplicissimus is decompressing %s ...\n",bufEXTENSION);

  01a40	56		 push	 esi
  01a41	68 00 00 00 00	 push	 OFFSET $SG6045
  01a46	e8 00 00 00 00	 call	 _printf

; 2220 : if( ( fp_outLINE = fopen( bufEXTENSION, "wb" ) ) == NULL )

  01a4b	68 00 00 00 00	 push	 OFFSET $SG6048
  01a50	56		 push	 esi
  01a51	e8 00 00 00 00	 call	 _fopen
  01a56	83 c4 14	 add	 esp, 20			; 00000014H
  01a59	89 44 24 24	 mov	 DWORD PTR _fp_outLINE$[esp+376], eax
  01a5d	85 c0		 test	 eax, eax
  01a5f	75 18		 jne	 SHORT $LN89@main

; 2221 : { printf( "Building-Blocks_DUMPER: Can't open file %s \n", bufEXTENSION ); return( 1 ); }

  01a61	56		 push	 esi
  01a62	68 00 00 00 00	 push	 OFFSET $SG6049
  01a67	e8 00 00 00 00	 call	 _printf
  01a6c	83 c4 08	 add	 esp, 8
  01a6f	b8 01 00 00 00	 mov	 eax, 1
  01a74	e9 84 0c 00 00	 jmp	 $LN202@main
$LN89@main:

; 2222 : 
; 2223 : printf( "Allocating 256MB for BBs pool + 384MB for RAM-to-RAM decompression ... " ); // 16order*16,777,216BBs + (384MB/3order)*3bytes

  01a79	68 00 00 00 00	 push	 OFFSET $SG6050
  01a7e	e8 00 00 00 00	 call	 _printf

; 2224 : BB = (char *)malloc( 256*1024*1024 + 384*1024*1024 +1); // +1 because one byte is read beyond pool!

  01a83	68 01 00 00 28	 push	 671088641		; 28000001H
  01a88	e8 00 00 00 00	 call	 _malloc
  01a8d	8b f0		 mov	 esi, eax
  01a8f	83 c4 08	 add	 esp, 8

; 2225 : if( BB == NULL )

  01a92	85 f6		 test	 esi, esi
  01a94	75 15		 jne	 SHORT $LN88@main

; 2226 : { puts( "Building-Blocks_DUMPER: Needed memory allocation denied!\n" ); return( 1 ); }

  01a96	68 00 00 00 00	 push	 OFFSET $SG6054
  01a9b	e8 00 00 00 00	 call	 _puts
  01aa0	83 c4 04	 add	 esp, 4
  01aa3	8d 46 01	 lea	 eax, DWORD PTR [esi+1]
  01aa6	e9 52 0c 00 00	 jmp	 $LN202@main
$LN88@main:

; 2227 : printf( "OK\n" );

  01aab	68 00 00 00 00	 push	 OFFSET $SG6055
  01ab0	e8 00 00 00 00	 call	 _printf

; 2228 : 
; 2229 : // Uploading BB file to BB pool: 
; 2230 : 
; 2231 : fread(SSheader, 1, 270, fp_inLINE);

  01ab5	55		 push	 ebp
  01ab6	68 0e 01 00 00	 push	 270			; 0000010eH
  01abb	8d 4c 24 70	 lea	 ecx, DWORD PTR _SSheader$[esp+388]
  01abf	6a 01		 push	 1
  01ac1	51		 push	 ecx
  01ac2	e8 00 00 00 00	 call	 _fread

; 2232 : fread((unsigned char *)&GainOrder+0, 1, 1, fp_inLINE);

  01ac7	55		 push	 ebp
  01ac8	6a 01		 push	 1
  01aca	8d 54 24 30	 lea	 edx, DWORD PTR _GainOrder$[esp+404]
  01ace	6a 01		 push	 1
  01ad0	52		 push	 edx
  01ad1	e8 00 00 00 00	 call	 _fread

; 2233 : fread((unsigned char *)&Strnglen+0, 1, 4, fp_inLINE);

  01ad6	55		 push	 ebp
  01ad7	6a 04		 push	 4
  01ad9	8d 44 24 3c	 lea	 eax, DWORD PTR _Strnglen$[esp+420]
  01add	6a 01		 push	 1
  01adf	50		 push	 eax
  01ae0	e8 00 00 00 00	 call	 _fread

; 2234 : fread((unsigned char *)&Patternlen+0, 1, 4, fp_inLINE);

  01ae5	55		 push	 ebp
  01ae6	6a 04		 push	 4
  01ae8	6a 01		 push	 1
  01aea	68 00 00 00 00	 push	 OFFSET _Patternlen
  01aef	e8 00 00 00 00	 call	 _fread

; 2235 : fread(BB, 1, Patternlen, fp_inLINE);

  01af4	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR _Patternlen
  01afa	83 c4 44	 add	 esp, 68			; 00000044H
  01afd	55		 push	 ebp
  01afe	51		 push	 ecx
  01aff	6a 01		 push	 1
  01b01	56		 push	 esi
  01b02	e8 00 00 00 00	 call	 _fread

; 2236 : 
; 2237 : printf ("BBs order: %lu\nOriginal file size: %lu\nBBs pool size: %lu\n",GainOrder,Strnglen,Patternlen);

  01b07	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _Patternlen
  01b0d	8b 44 24 20	 mov	 eax, DWORD PTR _Strnglen$[esp+392]
  01b11	8b 4c 24 24	 mov	 ecx, DWORD PTR _GainOrder$[esp+392]
  01b15	52		 push	 edx
  01b16	50		 push	 eax
  01b17	51		 push	 ecx
  01b18	68 00 00 00 00	 push	 OFFSET $SG6059
  01b1d	e8 00 00 00 00	 call	 _printf

; 2238 : 
; 2239 : /*
; 2240 : // Not buffered input, slow slow slow - SHOULD BE quickened! No need of 384MB RAM-to-RAM block! [
; 2241 :       for( j = 0; j < Strnglen / GainOrder; j++ )
; 2242 :    {
; 2243 : ThunderwithL=0; // Zeroing the highest byte i.e. the fourth
; 2244 : fread((unsigned char *)&ThunderwithL+0, 1, 3, fp_inLINE);
; 2245 : fwrite((unsigned char *)BB+GainOrder*ThunderwithL, 1, GainOrder, fp_outLINE);
; 2246 :    }
; 2247 : ThunderwithL=Strnglen % GainOrder;
; 2248 : while (ThunderwithL) {
; 2249 : fread((unsigned char *)&ThunderwithR+0, 1, 1, fp_inLINE);
; 2250 : fwrite((unsigned char *)&ThunderwithR+0, 1, 1, fp_outLINE);
; 2251 : ThunderwithL--;
; 2252 : }
; 2253 : // Not buffered input, slow slow slow - SHOULD BE quickened! No need of 384MB RAM-to-RAM block! ]
; 2254 : */
; 2255 : 
; 2256 : // Buffered input, just for OSHO.TXT because for max order 16 and max BBs 16,777,216 the BB pool cannot house the triads for bigger files! [
; 2257 : fread((unsigned char *)BB+Patternlen, 1, 3*(Strnglen / GainOrder), fp_inLINE);

  01b22	8b 44 24 30	 mov	 eax, DWORD PTR _Strnglen$[esp+408]
  01b26	99		 cdq
  01b27	f7 7c 24 34	 idiv	 DWORD PTR _GainOrder$[esp+408]
  01b2b	55		 push	 ebp
  01b2c	8d 14 40	 lea	 edx, DWORD PTR [eax+eax*2]
  01b2f	a1 00 00 00 00	 mov	 eax, DWORD PTR _Patternlen
  01b34	52		 push	 edx
  01b35	03 c6		 add	 eax, esi
  01b37	6a 01		 push	 1
  01b39	50		 push	 eax
  01b3a	e8 00 00 00 00	 call	 _fread

; 2258 : 
; 2259 : 
; 2260 : goto SubUGLYSLOW;
; 2261 : // UGLY SLOW !!! [
; 2262 : iREGISTER=Strnglen / GainOrder;
; 2263 : GainOrderREGISTER=GainOrder;
; 2264 : 
; 2265 : if (Strnglen % GainOrderREGISTER)
; 2266 : fread((unsigned char *)BB+Patternlen+3*(Strnglen / GainOrderREGISTER), 1, Strnglen % GainOrderREGISTER, fp_inLINE);
; 2267 :       for( jREGISTER = 0; jREGISTER < iREGISTER; jREGISTER++ )
; 2268 :    {
; 2269 : //ThunderwithL=0; // Zeroing the highest byte i.e. the fourth
; 2270 : //memcpy (&ThunderwithL, BB+Patternlen+jREGISTER*3, 3);
; 2271 : memcpy (Strng+GainOrderREGISTER*jREGISTER, BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ), GainOrderREGISTER);
; 2272 :    }
; 2273 : if (Strnglen % GainOrderREGISTER)
; 2274 : memcpy (Strng+GainOrderREGISTER*(Strnglen / GainOrderREGISTER), BB+Patternlen+3*(Strnglen / GainOrderREGISTER), Strnglen % GainOrderREGISTER);
; 2275 : 
; 2276 : // UGLY SLOW !!! ]
; 2277 : 
; 2278 : // Microsoft compiler 16 gives:
; 2279 : /*
; 2280 : ; 1740 :       for( jREGISTER = 0; jREGISTER < iREGISTER; jREGISTER++ )
; 2281 : 
; 2282 :   016f1	85 db		 test	 ebx, ebx
; 2283 :   016f3	7e 4e		 jle	 SHORT $LN69@main
; 2284 :   016f5	8b 44 24 2c	 mov	 eax, DWORD PTR _Strng$[esp+376]
; 2285 :   016f9	8b 4c 24 1c	 mov	 ecx, DWORD PTR tv1216[esp+376]
; 2286 :   016fd	33 db		 xor	 ebx, ebx
; 2287 :   016ff	89 44 24 14	 mov	 DWORD PTR tv1897[esp+376], eax
; 2288 :   01703	89 4c 24 24	 mov	 DWORD PTR tv1057[esp+376], ecx
; 2289 :   01707	eb 07 8d a4 24
; 2290 : 	00 00 00 00	 npad	 9
; 2291 : $LL71@main:
; 2292 : 
; 2293 : ; 1741 :    {
; 2294 : ; 1742 : //ThunderwithL=0; // Zeroing the highest byte i.e. the fourth
; 2295 : ; 1743 : //memcpy (&ThunderwithL, BB+Patternlen+jREGISTER*3, 3);
; 2296 : ; 1744 : memcpy (Strng+GainOrderREGISTER*jREGISTER, BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ), GainOrderREGISTER);
; 2297 : 
; 2298 :   01710	8b 15 00 00 00
; 2299 : 	00		 mov	 edx, DWORD PTR _Patternlen
; 2300 :   01716	8d 04 13	 lea	 eax, DWORD PTR [ebx+edx]
; 2301 :   01719	8b 0c 30	 mov	 ecx, DWORD PTR [eax+esi]
; 2302 :   0171c	8b 54 24 14	 mov	 edx, DWORD PTR tv1897[esp+376]
; 2303 :   01720	81 e1 ff ff ff
; 2304 : 	00		 and	 ecx, 16777215		; 00ffffffH
; 2305 :   01726	0f af cf	 imul	 ecx, edi
; 2306 :   01729	57		 push	 edi
; 2307 :   0172a	03 ce		 add	 ecx, esi
; 2308 :   0172c	51		 push	 ecx
; 2309 :   0172d	52		 push	 edx
; 2310 :   0172e	e8 00 00 00 00	 call	 _memcpy
; 2311 :   01733	01 7c 24 20	 add	 DWORD PTR tv1897[esp+388], edi
; 2312 :   01737	83 c4 0c	 add	 esp, 12			; 0000000cH
; 2313 :   0173a	83 c3 03	 add	 ebx, 3
; 2314 :   0173d	ff 4c 24 24	 dec	 DWORD PTR tv1057[esp+376]
; 2315 :   01741	75 cd		 jne	 SHORT $LL71@main
; 2316 : $LN69@main:
; 2317 : 
; 2318 : ; 1745 :    }
; 2319 : */
; 2320 : 
; 2321 : SubUGLYSLOW:
; 2322 : goto SubSubUGLYSLOW;
; 2323 : // SUB UGLY SLOW !!! [
; 2324 : iREGISTER=Strnglen / GainOrder;
; 2325 : GainOrderREGISTER=GainOrder;
; 2326 : 
; 2327 : if (Strnglen % GainOrderREGISTER)
; 2328 : fread((unsigned char *)BB+Patternlen+3*(Strnglen / GainOrderREGISTER), 1, Strnglen % GainOrderREGISTER, fp_inLINE);
; 2329 :       for( jREGISTER = 0; jREGISTER < iREGISTER; jREGISTER++ ) // Unroll by 4 triads in next r.1++++, that is, read into 3 32bit registers 4 triads i.e. 12bytes and >> << &.
; 2330 :    {
; 2331 : //ThunderwithL=0; // Zeroing the highest byte i.e. the fourth
; 2332 : //memcpy (&ThunderwithL, BB+Patternlen+jREGISTER*3, 3);
; 2333 : //memcpy (Strng+GainOrderREGISTER*jREGISTER, BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ), GainOrderREGISTER);
; 2334 : 
; 2335 : // r.1+++ [
; 2336 : //Dumbo64REGISTER = *(long long *)(BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ));
; 2337 : //*(long long *)(Strng+GainOrderREGISTER*jREGISTER)=Dumbo64REGISTER;
; 2338 : *(long long *)(Strng+GainOrderREGISTER*jREGISTER) = *(long long *)(BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ));
; 2339 : // r.1+++ ]
; 2340 :    }
; 2341 : if (Strnglen % GainOrderREGISTER)
; 2342 : memcpy (Strng+GainOrderREGISTER*(Strnglen / GainOrderREGISTER), BB+Patternlen+3*(Strnglen / GainOrderREGISTER), Strnglen % GainOrderREGISTER);
; 2343 : 
; 2344 : // SUB UGLY SLOW !!! ]
; 2345 : 
; 2346 : // Microsoft compiler 16 gives:
; 2347 : /*
; 2348 : ; 1811 :       for( jREGISTER = 0; jREGISTER < iREGISTER; jREGISTER++ ) // Unroll by 4 triads in next r.1++++, that is, read into 3 32bit registers 4 triads i.e. 12bytes and >> << &.
; 2349 : 
; 2350 :   0173d	85 db		 test	 ebx, ebx
; 2351 :   0173f	7e 38		 jle	 SHORT $LN72@main
; 2352 :   01741	8b 4c 24 18	 mov	 ecx, DWORD PTR _Strng$[esp+376]
; 2353 :   01745	33 d2		 xor	 edx, edx
; 2354 :   01747	89 5c 24 1c	 mov	 DWORD PTR tv977[esp+376], ebx
; 2355 :   0174b	eb 03 8d 49 00	 npad	 5
; 2356 : $LL74@main:
; 2357 : 
; 2358 : ; 1812 :    {
; 2359 : ; 1813 : //ThunderwithL=0; // Zeroing the highest byte i.e. the fourth
; 2360 : ; 1814 : //memcpy (&ThunderwithL, BB+Patternlen+jREGISTER*3, 3);
; 2361 : ; 1815 : //memcpy (Strng+GainOrderREGISTER*jREGISTER, BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ), GainOrderREGISTER);
; 2362 : ; 1816 : 
; 2363 : ; 1817 : // r.1+++ [
; 2364 : ; 1818 : //Dumbo64REGISTER = *(long long *)(BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ));
; 2365 : ; 1819 : //*(long long *)(Strng+GainOrderREGISTER*jREGISTER)=Dumbo64REGISTER;
; 2366 : ; 1820 : *(long long *)(Strng+GainOrderREGISTER*jREGISTER) = *(long long *)(BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ));
; 2367 : 
; 2368 :   01750	a1 00 00 00 00	 mov	 eax, DWORD PTR _Patternlen
; 2369 :   01755	03 c2		 add	 eax, edx
; 2370 :   01757	8b 04 30	 mov	 eax, DWORD PTR [eax+esi]
; 2371 :   0175a	25 ff ff ff 00	 and	 eax, 16777215		; 00ffffffH
; 2372 :   0175f	0f af c7	 imul	 eax, edi
; 2373 :   01762	8b 1c 30	 mov	 ebx, DWORD PTR [eax+esi]
; 2374 :   01765	89 19		 mov	 DWORD PTR [ecx], ebx
; 2375 :   01767	8b 44 30 04	 mov	 eax, DWORD PTR [eax+esi+4]
; 2376 :   0176b	89 41 04	 mov	 DWORD PTR [ecx+4], eax
; 2377 :   0176e	83 c2 03	 add	 edx, 3
; 2378 :   01771	03 cf		 add	 ecx, edi
; 2379 :   01773	ff 4c 24 1c	 dec	 DWORD PTR tv977[esp+376]
; 2380 :   01777	75 d7		 jne	 SHORT $LL74@main
; 2381 : $LN72@main:
; 2382 : 
; 2383 : ; 1821 : // r.1+++ ]
; 2384 : ; 1822 :    }
; 2385 : */
; 2386 : 
; 2387 : SubSubUGLYSLOW: //// Notice that 42<64, but the threefold unrolling boosts (despite of exceeding 64) from 16300KB/s to 17000KB/s.
; 2388 : // SUB SUB UGLY SLOW !!! [
; 2389 : iREGISTER=Strnglen / GainOrder; //iREGISTER=iREGISTER-(iREGISTER%3); Fixed BUG here, how stupid!

  01b3f	8b 44 24 40	 mov	 eax, DWORD PTR _Strnglen$[esp+424]
  01b43	8b 7c 24 44	 mov	 edi, DWORD PTR _GainOrder$[esp+424]
  01b47	99		 cdq
  01b48	f7 ff		 idiv	 edi
  01b4a	83 c4 30	 add	 esp, 48			; 00000030H
$SubUGLYSLOW$6061:
$SubSubUGLYSLOW$6069:
  01b4d	8b d8		 mov	 ebx, eax
  01b4f	89 5c 24 18	 mov	 DWORD PTR tv1472[esp+376], ebx

; 2390 : GainOrderREGISTER=GainOrder;
; 2391 : 
; 2392 : if (Strnglen % GainOrderREGISTER)

  01b53	85 d2		 test	 edx, edx
  01b55	74 1a		 je	 SHORT $LN77@main

; 2393 : fread((unsigned char *)BB+Patternlen+3*(Strnglen / GainOrderREGISTER), 1, Strnglen % GainOrderREGISTER, fp_inLINE);

  01b57	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR _Patternlen
  01b5d	55		 push	 ebp
  01b5e	52		 push	 edx
  01b5f	8d 14 59	 lea	 edx, DWORD PTR [ecx+ebx*2]
  01b62	03 d3		 add	 edx, ebx
  01b64	03 d6		 add	 edx, esi
  01b66	6a 01		 push	 1
  01b68	52		 push	 edx
  01b69	e8 00 00 00 00	 call	 _fread
  01b6e	83 c4 10	 add	 esp, 16			; 00000010H
$LN77@main:

; 2394 :       for( jREGISTER = 0; jREGISTER < iREGISTER; jREGISTER++ )

  01b71	33 c9		 xor	 ecx, ecx
  01b73	85 db		 test	 ebx, ebx
  01b75	0f 8e 80 00 00
	00		 jle	 $LN192@main
  01b7b	8b 44 24 1c	 mov	 eax, DWORD PTR _Strng$[esp+376]
  01b7f	33 d2		 xor	 edx, edx
$LL179@main:

; 2395 :    {
; 2396 : //ThunderwithL=0; // Zeroing the highest byte i.e. the fourth
; 2397 : //memcpy (&ThunderwithL, BB+Patternlen+jREGISTER*3, 3);
; 2398 : //memcpy (Strng+GainOrderREGISTER*jREGISTER, BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ), GainOrderREGISTER);
; 2399 : 
; 2400 : // r.1++++ [
; 2401 : //Dumbo64REGISTER = *(long long *)(BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ));
; 2402 : //*(long long *)(Strng+GainOrderREGISTER*jREGISTER)=Dumbo64REGISTER;
; 2403 : *(long long *)(Strng+GainOrderREGISTER*jREGISTER) = *(long long *)(BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ));

  01b81	8b 1d 00 00 00
	00		 mov	 ebx, DWORD PTR _Patternlen
  01b87	03 da		 add	 ebx, edx
  01b89	8b 1c 33	 mov	 ebx, DWORD PTR [ebx+esi]
  01b8c	81 e3 ff ff ff
	00		 and	 ebx, 16777215		; 00ffffffH
  01b92	0f af df	 imul	 ebx, edi
  01b95	8b 2c 33	 mov	 ebp, DWORD PTR [ebx+esi]
  01b98	89 28		 mov	 DWORD PTR [eax], ebp
  01b9a	8b 5c 33 04	 mov	 ebx, DWORD PTR [ebx+esi+4]
  01b9e	89 58 04	 mov	 DWORD PTR [eax+4], ebx

; 2404 : jREGISTER++;
; 2405 : *(long long *)(Strng+GainOrderREGISTER*jREGISTER) = *(long long *)(BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ));

  01ba1	8b 1d 00 00 00
	00		 mov	 ebx, DWORD PTR _Patternlen
  01ba7	83 c2 03	 add	 edx, 3
  01baa	03 da		 add	 ebx, edx
  01bac	8b 1c 33	 mov	 ebx, DWORD PTR [ebx+esi]
  01baf	81 e3 ff ff ff
	00		 and	 ebx, 16777215		; 00ffffffH
  01bb5	0f af df	 imul	 ebx, edi
  01bb8	8b 2c 33	 mov	 ebp, DWORD PTR [ebx+esi]
  01bbb	89 2c 38	 mov	 DWORD PTR [eax+edi], ebp
  01bbe	8b 5c 33 04	 mov	 ebx, DWORD PTR [ebx+esi+4]
  01bc2	89 5c 38 04	 mov	 DWORD PTR [eax+edi+4], ebx

; 2406 : jREGISTER++;
; 2407 : *(long long *)(Strng+GainOrderREGISTER*jREGISTER) = *(long long *)(BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ));

  01bc6	8b 1d 00 00 00
	00		 mov	 ebx, DWORD PTR _Patternlen
  01bcc	03 c7		 add	 eax, edi
  01bce	83 c2 03	 add	 edx, 3
  01bd1	03 da		 add	 ebx, edx
  01bd3	8b 1c 33	 mov	 ebx, DWORD PTR [ebx+esi]
  01bd6	81 e3 ff ff ff
	00		 and	 ebx, 16777215		; 00ffffffH
  01bdc	0f af df	 imul	 ebx, edi
  01bdf	8b 2c 33	 mov	 ebp, DWORD PTR [ebx+esi]
  01be2	03 c7		 add	 eax, edi
  01be4	89 28		 mov	 DWORD PTR [eax], ebp
  01be6	8b 5c 33 04	 mov	 ebx, DWORD PTR [ebx+esi+4]
  01bea	89 58 04	 mov	 DWORD PTR [eax+4], ebx
  01bed	83 c1 03	 add	 ecx, 3
  01bf0	83 c2 03	 add	 edx, 3
  01bf3	03 c7		 add	 eax, edi
  01bf5	3b 4c 24 18	 cmp	 ecx, DWORD PTR tv1472[esp+376]
  01bf9	7c 86		 jl	 SHORT $LL179@main
$LN192@main:

; 2408 : // r.1++++ ]
; 2409 :    }
; 2410 : if ((Strnglen / GainOrder)%3==1) 

  01bfb	8b 44 24 10	 mov	 eax, DWORD PTR _Strnglen$[esp+376]
  01bff	99		 cdq
  01c00	f7 7c 24 14	 idiv	 DWORD PTR _GainOrder$[esp+376]
  01c04	bb 03 00 00 00	 mov	 ebx, 3
  01c09	99		 cdq
  01c0a	f7 fb		 idiv	 ebx

; 2411 : {
; 2412 : jREGISTER++;
; 2413 : *(long long *)(Strng+GainOrderREGISTER*jREGISTER) = *(long long *)(BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ));

  01c0c	8b 5c 24 1c	 mov	 ebx, DWORD PTR _Strng$[esp+376]
  01c10	83 fa 01	 cmp	 edx, 1
  01c13	75 29		 jne	 SHORT $LN73@main
  01c15	a1 00 00 00 00	 mov	 eax, DWORD PTR _Patternlen
  01c1a	41		 inc	 ecx
  01c1b	8d 14 48	 lea	 edx, DWORD PTR [eax+ecx*2]
  01c1e	03 d1		 add	 edx, ecx
  01c20	8b 04 32	 mov	 eax, DWORD PTR [edx+esi]
  01c23	25 ff ff ff 00	 and	 eax, 16777215		; 00ffffffH
  01c28	0f af c7	 imul	 eax, edi
  01c2b	8b 2c 30	 mov	 ebp, DWORD PTR [eax+esi]
  01c2e	8b d1		 mov	 edx, ecx
  01c30	0f af d7	 imul	 edx, edi
  01c33	89 2c 1a	 mov	 DWORD PTR [edx+ebx], ebp
  01c36	8b 44 30 04	 mov	 eax, DWORD PTR [eax+esi+4]
  01c3a	89 44 1a 04	 mov	 DWORD PTR [edx+ebx+4], eax
$LN73@main:

; 2414 : }
; 2415 : if ((Strnglen / GainOrder)%3==2) 

  01c3e	8b 44 24 10	 mov	 eax, DWORD PTR _Strnglen$[esp+376]
  01c42	99		 cdq
  01c43	f7 7c 24 14	 idiv	 DWORD PTR _GainOrder$[esp+376]
  01c47	bd 03 00 00 00	 mov	 ebp, 3
  01c4c	99		 cdq
  01c4d	f7 fd		 idiv	 ebp
  01c4f	83 fa 02	 cmp	 edx, 2
  01c52	75 52		 jne	 SHORT $LN185@main

; 2416 : {
; 2417 : jREGISTER++;
; 2418 : *(long long *)(Strng+GainOrderREGISTER*jREGISTER) = *(long long *)(BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ));

  01c54	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _Patternlen
  01c5a	41		 inc	 ecx
  01c5b	8d 04 4a	 lea	 eax, DWORD PTR [edx+ecx*2]
  01c5e	03 c1		 add	 eax, ecx
  01c60	8b 04 30	 mov	 eax, DWORD PTR [eax+esi]
  01c63	25 ff ff ff 00	 and	 eax, 16777215		; 00ffffffH
  01c68	0f af c7	 imul	 eax, edi
  01c6b	8b 2c 30	 mov	 ebp, DWORD PTR [eax+esi]
  01c6e	8b d1		 mov	 edx, ecx
  01c70	0f af d7	 imul	 edx, edi
  01c73	89 2c 1a	 mov	 DWORD PTR [edx+ebx], ebp
  01c76	8b 44 30 04	 mov	 eax, DWORD PTR [eax+esi+4]
  01c7a	89 44 1a 04	 mov	 DWORD PTR [edx+ebx+4], eax

; 2419 : jREGISTER++;
; 2420 : *(long long *)(Strng+GainOrderREGISTER*jREGISTER) = *(long long *)(BB+GainOrderREGISTER*( 0x00FFFFFF & *(unsigned long *)(BB+Patternlen+jREGISTER*3) ));

  01c7e	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _Patternlen
  01c84	41		 inc	 ecx
  01c85	8d 04 4a	 lea	 eax, DWORD PTR [edx+ecx*2]
  01c88	03 c1		 add	 eax, ecx
  01c8a	8b 04 30	 mov	 eax, DWORD PTR [eax+esi]
  01c8d	25 ff ff ff 00	 and	 eax, 16777215		; 00ffffffH
  01c92	0f af c7	 imul	 eax, edi
  01c95	0f af cf	 imul	 ecx, edi
  01c98	8b 14 30	 mov	 edx, DWORD PTR [eax+esi]
  01c9b	89 14 19	 mov	 DWORD PTR [ecx+ebx], edx
  01c9e	8b 44 30 04	 mov	 eax, DWORD PTR [eax+esi+4]
  01ca2	89 44 19 04	 mov	 DWORD PTR [ecx+ebx+4], eax
$LN185@main:

; 2421 : }
; 2422 : 
; 2423 : if (Strnglen % GainOrderREGISTER)

  01ca6	8b 44 24 10	 mov	 eax, DWORD PTR _Strnglen$[esp+376]
  01caa	99		 cdq
  01cab	f7 ff		 idiv	 edi
  01cad	85 d2		 test	 edx, edx
  01caf	74 1d		 je	 SHORT $LN71@main

; 2424 : memcpy (Strng+GainOrderREGISTER*(Strnglen / GainOrderREGISTER), BB+Patternlen+3*(Strnglen / GainOrderREGISTER), Strnglen % GainOrderREGISTER);

  01cb1	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR _Patternlen
  01cb7	52		 push	 edx
  01cb8	8d 14 41	 lea	 edx, DWORD PTR [ecx+eax*2]
  01cbb	03 d0		 add	 edx, eax
  01cbd	0f af c7	 imul	 eax, edi
  01cc0	03 d6		 add	 edx, esi
  01cc2	52		 push	 edx
  01cc3	03 c3		 add	 eax, ebx
  01cc5	50		 push	 eax
  01cc6	e8 00 00 00 00	 call	 _memcpy
  01ccb	83 c4 0c	 add	 esp, 12			; 0000000cH
$LN71@main:

; 2425 : 
; 2426 : // SUB SUB UGLY SLOW !!! ]
; 2427 : 
; 2428 : 
; 2429 : clocks1 = clock();

  01cce	e8 00 00 00 00	 call	 _clock
  01cd3	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 2430 : TotalRoughSearchTime2 = clocks1 - clocks3; TotalRoughSearchTime2++;

  01cd8	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  01cde	89 44 24 18	 mov	 DWORD PTR tv1993[esp+376], eax
  01ce2	db 44 24 18	 fild	 DWORD PTR tv1993[esp+376]
  01ce6	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  01cec	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime2

; 2431 : printf( "\nDecompression to RAM without Dumping to DRIVE time: %lu clocks\n", (long)(TotalRoughSearchTime2));

  01cf2	e8 00 00 00 00	 call	 __ftol2_sse
  01cf7	50		 push	 eax
  01cf8	68 00 00 00 00	 push	 OFFSET $SG6106
  01cfd	e8 00 00 00 00	 call	 _printf

; 2432 : printf( "Decompression to RAM without Dumping to DRIVE performance: %lu KB/s or %lu MB/s\n", (long)((Strnglen/TotalRoughSearchTime2)*1000)>>10, ((long)((Strnglen/TotalRoughSearchTime2)*1000)>>10)>>10);

  01d02	db 44 24 18	 fild	 DWORD PTR _Strnglen$[esp+384]
  01d06	dc 35 00 00 00
	00		 fdiv	 QWORD PTR _TotalRoughSearchTime2
  01d0c	dc 0d 00 00 00
	00		 fmul	 QWORD PTR __real@408f400000000000
  01d12	e8 00 00 00 00	 call	 __ftol2_sse
  01d17	8b c8		 mov	 ecx, eax
  01d19	c1 f9 14	 sar	 ecx, 20			; 00000014H
  01d1c	51		 push	 ecx
  01d1d	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  01d20	50		 push	 eax
  01d21	68 00 00 00 00	 push	 OFFSET $SG6109
  01d26	e8 00 00 00 00	 call	 _printf

; 2433 : fwrite(Strng, 1, Strnglen, fp_outLINE);

  01d2b	8b 6c 24 38	 mov	 ebp, DWORD PTR _fp_outLINE$[esp+396]
  01d2f	8b 54 24 24	 mov	 edx, DWORD PTR _Strnglen$[esp+396]
  01d33	55		 push	 ebp
  01d34	52		 push	 edx
  01d35	6a 01		 push	 1
  01d37	53		 push	 ebx
  01d38	e8 00 00 00 00	 call	 _fwrite

; 2434 : // Buffered input, just for OSHO.TXT because for max order 16 and max BBs 16,777,216 the BB pool cannot house the triads for bigger files! ]
; 2435 : 
; 2436 : clocks2 = clock();

  01d3d	e8 00 00 00 00	 call	 _clock
  01d42	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax

; 2437 : TotalRoughSearchTime = clocks2 - clocks3; TotalRoughSearchTime++;

  01d47	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  01d4d	89 44 24 3c	 mov	 DWORD PTR tv1980[esp+412], eax
  01d51	db 44 24 3c	 fild	 DWORD PTR tv1980[esp+412]
  01d55	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  01d5b	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 2438 : printf( "Total time: %lu clocks\n", (long)(TotalRoughSearchTime));

  01d61	e8 00 00 00 00	 call	 __ftol2_sse
  01d66	50		 push	 eax
  01d67	68 00 00 00 00	 push	 OFFSET $SG6111
  01d6c	e8 00 00 00 00	 call	 _printf

; 2439 : 
; 2440 : printf ("\nBenchmarking 'memcpy' by copying 197MB (OSHO.TXT size) ten times ...\n");

  01d71	68 00 00 00 00	 push	 OFFSET $SG6112
  01d76	e8 00 00 00 00	 call	 _printf
  01d7b	83 c4 30	 add	 esp, 48			; 00000030H

; 2441 : 	clocks3 = clock();

  01d7e	e8 00 00 00 00	 call	 _clock
  01d83	a3 00 00 00 00	 mov	 DWORD PTR _clocks3, eax
  01d88	bf 0a 00 00 00	 mov	 edi, 10			; 0000000aH
  01d8d	8d 49 00	 npad	 3
$LL70@main:

; 2442 : 	for (i=0; i<10; i++)
; 2443 : 	memcpy (Strng, BB, 197*1024*1024);

  01d90	68 00 00 50 0c	 push	 206569472		; 0c500000H
  01d95	56		 push	 esi
  01d96	53		 push	 ebx
  01d97	e8 00 00 00 00	 call	 _memcpy
  01d9c	83 c4 0c	 add	 esp, 12			; 0000000cH
  01d9f	4f		 dec	 edi
  01da0	75 ee		 jne	 SHORT $LL70@main

; 2444 : 	clocks2 = clock();

  01da2	e8 00 00 00 00	 call	 _clock
  01da7	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax

; 2445 : 	clocks2 = clock();

  01dac	e8 00 00 00 00	 call	 _clock
  01db1	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax

; 2446 : TotalRoughSearchTime = clocks2 - clocks3; TotalRoughSearchTime++;

  01db6	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  01dbc	89 44 24 18	 mov	 DWORD PTR tv1970[esp+376], eax
  01dc0	db 44 24 18	 fild	 DWORD PTR tv1970[esp+376]
  01dc4	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  01dca	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 2447 : printf( "Simplicius says for 'memcpy' performance: %lu MB/s\n", 1970000/(long)(TotalRoughSearchTime));

  01dd0	e8 00 00 00 00	 call	 __ftol2_sse
  01dd5	8b c8		 mov	 ecx, eax
  01dd7	b8 50 0f 1e 00	 mov	 eax, 1970000		; 001e0f50H
  01ddc	99		 cdq
  01ddd	f7 f9		 idiv	 ecx
  01ddf	50		 push	 eax
  01de0	68 00 00 00 00	 push	 OFFSET $SG6117
  01de5	e8 00 00 00 00	 call	 _printf

; 2448 : printf( "Simplicius says for Decompression Ratio: %lu%%\n", (((long)((Strnglen/TotalRoughSearchTime2)*1000)>>10)*100)/((1970000/(long)(TotalRoughSearchTime))*1024) );

  01dea	db 44 24 18	 fild	 DWORD PTR _Strnglen$[esp+384]
  01dee	dc 35 00 00 00
	00		 fdiv	 QWORD PTR _TotalRoughSearchTime2
  01df4	dc 0d 00 00 00
	00		 fmul	 QWORD PTR __real@408f400000000000
  01dfa	e8 00 00 00 00	 call	 __ftol2_sse
  01dff	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  01e05	8b f8		 mov	 edi, eax
  01e07	c1 ff 0a	 sar	 edi, 10			; 0000000aH
  01e0a	6b ff 64	 imul	 edi, 100		; 00000064H
  01e0d	e8 00 00 00 00	 call	 __ftol2_sse
  01e12	8b c8		 mov	 ecx, eax
  01e14	b8 50 0f 1e 00	 mov	 eax, 1970000		; 001e0f50H
  01e19	99		 cdq
  01e1a	f7 f9		 idiv	 ecx
  01e1c	8b c8		 mov	 ecx, eax
  01e1e	8b c7		 mov	 eax, edi
  01e20	99		 cdq
  01e21	c1 e1 0a	 shl	 ecx, 10			; 0000000aH
  01e24	f7 f9		 idiv	 ecx
  01e26	50		 push	 eax
  01e27	68 00 00 00 00	 push	 OFFSET $SG6120
  01e2c	e8 00 00 00 00	 call	 _printf

; 2449 : 
; 2450 : fclose (fp_inLINE);

  01e31	8b 54 24 3c	 mov	 edx, DWORD PTR _fp_inLINE$[esp+392]
  01e35	52		 push	 edx
  01e36	e8 00 00 00 00	 call	 _fclose

; 2451 : fclose (fp_outLINE);

  01e3b	55		 push	 ebp
  01e3c	e8 00 00 00 00	 call	 _fclose

; 2452 : free (BB);

  01e41	56		 push	 esi
  01e42	e8 00 00 00 00	 call	 _free

; 2453 : free (Strng);

  01e47	53		 push	 ebx
  01e48	e8 00 00 00 00	 call	 _free
  01e4d	83 c4 20	 add	 esp, 32			; 00000020H

; 2454 : return -1;

  01e50	83 c8 ff	 or	 eax, -1
  01e53	e9 a5 08 00 00	 jmp	 $LN202@main
$LN90@main:

; 2455 : }
; 2456 : // DECOMPRESSOR ]
; 2457 : 
; 2458 :    fseek(fp_inLINE, 0, SEEK_END);

  01e58	6a 02		 push	 2
  01e5a	6a 00		 push	 0
  01e5c	55		 push	 ebp
  01e5d	e8 00 00 00 00	 call	 _fseek

; 2459 :    Strnglen = ftell(fp_inLINE);

  01e62	55		 push	 ebp
  01e63	e8 00 00 00 00	 call	 _ftell

; 2460 :    fseek(fp_inLINE, 0, SEEK_SET);

  01e68	6a 00		 push	 0
  01e6a	6a 00		 push	 0
  01e6c	55		 push	 ebp
  01e6d	89 44 24 2c	 mov	 DWORD PTR _Strnglen$[esp+404], eax
  01e71	e8 00 00 00 00	 call	 _fseek

; 2461 : if (Strnglen>384*1024*1024)

  01e76	8b 44 24 2c	 mov	 eax, DWORD PTR _Strnglen$[esp+404]
  01e7a	83 c4 1c	 add	 esp, 28			; 0000001cH
  01e7d	3d 00 00 00 18	 cmp	 eax, 402653184		; 18000000H
  01e82	7e 17		 jle	 SHORT $LN67@main

; 2462 : { printf( "Building-Blocks_DUMPER: File cannot be loaded, it exceeds 384MB limit.\n" ); return( 1 ); }

  01e84	68 00 00 00 00	 push	 OFFSET $SG6122
  01e89	e8 00 00 00 00	 call	 _printf
  01e8e	83 c4 04	 add	 esp, 4
  01e91	b8 01 00 00 00	 mov	 eax, 1
  01e96	e9 62 08 00 00	 jmp	 $LN202@main
$LN67@main:

; 2463 :    fread(Strng, 1, Strnglen, fp_inLINE);

  01e9b	55		 push	 ebp
  01e9c	50		 push	 eax
  01e9d	6a 01		 push	 1
  01e9f	53		 push	 ebx
  01ea0	e8 00 00 00 00	 call	 _fread

; 2464 :    fclose(fp_inLINE);

  01ea5	55		 push	 ebp
  01ea6	e8 00 00 00 00	 call	 _fclose

; 2465 : 
; 2466 : //printf("Input Pattern(up to 19 chars): "); gets(Pattern); // char * __cdecl gets(char *);
; 2467 : //printf( "%s\n", _ui64toaKAZEzerocomma (7, llTOaDigits, 16)+(26-2));
; 2468 : //printf( "%s\n", _ui64toaKAZEzerocomma (Pattern[0], llTOaDigits, 16) +(26-2));
; 2469 : //printf( "%s\n", _ui64toaKAZEzerocomma (Pattern[1], llTOaDigits, 16) +(26-2));
; 2470 : //printf( "%s\n", _ui64toaKAZEzerocomma (Pattern[2], llTOaDigits, 16) +(26-2));
; 2471 : //exit(0);
; 2472 : //Patternlen = strlen(&Pattern[0]);
; 2473 : 
; 2474 : // Replacing CR with NULL i.e. 13->0
; 2475 : //	for (ThunderwithL=0; ThunderwithL<Strnglen; ThunderwithL++)
; 2476 : //		if (Strng[ThunderwithL] == 13) Strng[ThunderwithL] = 0;
; 2477 : //ThunderwithL=0;ThunderwithR=0;
; 2478 : //printf( "Doing Search for Pattern(%dbytes) into String(%dbytes) line-by-line ...\n", Patternlen, Strnglen);
; 2479 : 
; 2480 : //Patternlen=3; // 3..31
; 2481 : //printf( "\nExamining BB orders 3 to 16 whether they are codeable within 3bytes i.e. 16,777,216 ...\n");
; 2482 : printf( "\nEnforcing BB order 7 ...\n");

  01eab	68 00 00 00 00	 push	 OFFSET $SG6123
  01eb0	e8 00 00 00 00	 call	 _printf

; 2483 : printf("Size of incoming file or Strnglen: %d\n",Strnglen);

  01eb5	8b 44 24 28	 mov	 eax, DWORD PTR _Strnglen$[esp+400]
  01eb9	50		 push	 eax
  01eba	68 00 00 00 00	 push	 OFFSET $SG6124
  01ebf	e8 00 00 00 00	 call	 _printf

; 2484 : //for( Patternlen = 3; Patternlen <=16; Patternlen++ )
; 2485 : for( Patternlen = 7; Patternlen <=7; Patternlen++ )

  01ec4	b8 07 00 00 00	 mov	 eax, 7
  01ec9	83 c4 20	 add	 esp, 32			; 00000020H
  01ecc	a3 00 00 00 00	 mov	 DWORD PTR _Patternlen, eax
  01ed1	eb 04		 jmp	 SHORT $LN66@main
$LL191@main:
  01ed3	8b 5c 24 1c	 mov	 ebx, DWORD PTR _Strng$[esp+376]
$LN66@main:

; 2486 : { // MAIN CYCLE [
; 2487 : 
; 2488 : memcpy(&BuildingBlocksBox[2],_ui64toaKAZEzerocomma (Patternlen, llTOaDigits, 10) +(26-3),3);

  01ed7	6a 0a		 push	 10			; 0000000aH
  01ed9	8d 4c 24 4c	 lea	 ecx, DWORD PTR _llTOaDigits$[esp+380]
  01edd	99		 cdq
  01ede	51		 push	 ecx
  01edf	52		 push	 edx
  01ee0	50		 push	 eax
  01ee1	e8 00 00 00 00	 call	 __ui64toaKAZEzerocomma
  01ee6	66 8b 50 17	 mov	 dx, WORD PTR [eax+23]

; 2489 : 
; 2490 : printf( "\nSorting %lu Pointers to Building-Blocks %lu chars in size ...\n", Strnglen-Patternlen+1, Patternlen);

  01eea	8b 4c 24 20	 mov	 ecx, DWORD PTR _Strnglen$[esp+392]
  01eee	66 89 54 24 4e	 mov	 WORD PTR _BuildingBlocksBox$[esp+394], dx
  01ef3	8a 40 19	 mov	 al, BYTE PTR [eax+25]
  01ef6	88 44 24 50	 mov	 BYTE PTR _BuildingBlocksBox$[esp+396], al
  01efa	a1 00 00 00 00	 mov	 eax, DWORD PTR _Patternlen
  01eff	2b c8		 sub	 ecx, eax
  01f01	50		 push	 eax
  01f02	41		 inc	 ecx
  01f03	51		 push	 ecx
  01f04	68 00 00 00 00	 push	 OFFSET $SG6128
  01f09	e8 00 00 00 00	 call	 _printf

; 2491 : 
; 2492 : nlines = Strnglen-Patternlen+1;

  01f0e	8b 6c 24 2c	 mov	 ebp, DWORD PTR _Strnglen$[esp+404]
  01f12	2b 2d 00 00 00
	00		 sub	 ebp, DWORD PTR _Patternlen
  01f18	45		 inc	 ebp

; 2493 : ASbackup = (string *)malloc( nlines*sizeof(string) ); // sizeof(string) is 4

  01f19	8d 34 ad 00 00
	00 00		 lea	 esi, DWORD PTR [ebp*4]
  01f20	56		 push	 esi
  01f21	e8 00 00 00 00	 call	 _malloc
  01f26	8b f8		 mov	 edi, eax
  01f28	83 c4 20	 add	 esp, 32			; 00000020H

; 2494 : if( ASbackup == NULL )

  01f2b	85 ff		 test	 edi, edi
  01f2d	0f 84 a1 02 00
	00		 je	 $LN146@main

; 2496 : printf( "Allocated memory for pointers-to-words in MB: %lu\n", ((nlines*sizeof(string))>>20)+1 );

  01f33	c1 ee 14	 shr	 esi, 20			; 00000014H
  01f36	46		 inc	 esi
  01f37	56		 push	 esi
  01f38	68 00 00 00 00	 push	 OFFSET $SG6135
  01f3d	e8 00 00 00 00	 call	 _printf
  01f42	83 c4 08	 add	 esp, 8

; 2497 : 
; 2498 : 
; 2499 : // ASSIGNING POINTERS ... [
; 2500 :    cur = Strng;
; 2501 :       for( j = 0; j < nlines; j++ )

  01f45	33 c0		 xor	 eax, eax
  01f47	85 ed		 test	 ebp, ebp
  01f49	7e 10		 jle	 SHORT $LN60@main
  01f4b	eb 03 8d 49 00	 npad	 5
$LL62@main:

; 2502 :    {
; 2503 :       ASbackup[j] = cur;

  01f50	8d 14 18	 lea	 edx, DWORD PTR [eax+ebx]
  01f53	89 14 87	 mov	 DWORD PTR [edi+eax*4], edx
  01f56	40		 inc	 eax
  01f57	3b c5		 cmp	 eax, ebp
  01f59	7c f5		 jl	 SHORT $LL62@main
$LN60@main:

; 2504 : //printf("%d %d %d\n",*(ASbackup[j]+0),*(ASbackup[j]+1),*(ASbackup[j]+2));
; 2505 :       cur = cur + 1;
; 2506 :    }
; 2507 : // ASSIGNING POINTERS ... ]
; 2508 : 
; 2509 : 
; 2510 : // SORTING POINTERS ... [
; 2511 : #if defined(QuickS)
; 2512 : //void mkqsort_main(unsigned char **a, int n) { mkqsort(a, n, 0); }
; 2513 : //mkqsort_main(ASbackup, nlines); // Buggy!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
; 2514 : qsortVS2003(ASbackup, nlines,4, compVS2003);

  01f5b	68 00 00 00 00	 push	 OFFSET _compVS2003
  01f60	6a 04		 push	 4
  01f62	55		 push	 ebp
  01f63	57		 push	 edi
  01f64	e8 00 00 00 00	 call	 _qsortVS2003

; 2515 : 
; 2516 : #else
; 2517 : //simplesortFIXEDLength(string a[], int n, int b, int FIXEDLength)
; 2518 : simplesortFIXEDLength(ASbackup, nlines, 0, Patternlen);
; 2519 : #endif
; 2520 : // SORTING POINTERS ... ]
; 2521 : 
; 2522 : 
; 2523 : // WRITING SORTED ... [
; 2524 :       if( ( fp_inLINE = fopen( &BuildingBlocksBox[0], "wb+" ) ) == NULL )

  01f69	8d 44 24 4c	 lea	 eax, DWORD PTR _BuildingBlocksBox$[esp+392]
  01f6d	68 00 00 00 00	 push	 OFFSET $SG6141
  01f72	50		 push	 eax
  01f73	e8 00 00 00 00	 call	 _fopen
  01f78	8b d8		 mov	 ebx, eax
  01f7a	83 c4 18	 add	 esp, 24			; 00000018H

; 2526 : printf( "Writing Sorted Building-Blocks to %s ...\n", &BuildingBlocksBox[0]);

  01f7d	8d 4c 24 3c	 lea	 ecx, DWORD PTR _BuildingBlocksBox$[esp+376]
  01f81	89 5c 24 2c	 mov	 DWORD PTR _fp_inLINE$[esp+376], ebx
  01f85	51		 push	 ecx
  01f86	85 db		 test	 ebx, ebx
  01f88	0f 84 5d 02 00
	00		 je	 $LN147@main
  01f8e	68 00 00 00 00	 push	 OFFSET $SG6143
  01f93	e8 00 00 00 00	 call	 _printf

; 2527 : goto SORTED_witout_DUPLICATES;
; 2528 : 
; 2529 :       for( j = 0; j < nlines; j++ )
; 2530 :       { //Slot = KuxHash3plus(ASbackup[j]);
; 2531 :         //fprintf(fp_out, "Hashcode: %s - ", _ui64toaKAZEzerocomma(Slot, llTOaDigits, 10)+(26-5));
; 2532 :         //fprintf(fp_inLINE, "%s\n", ASbackup[j]);
; 2533 : 	    for ( i=0;i<Patternlen; i++)
; 2534 : 	    fprintf(fp_inLINE, "%c", *(ASbackup[j]+i));
; 2535 : 	    //fprintf(fp_inLINE, "%s", _ui64toaKAZEzerocomma (*(ASbackup[j]+i), llTOaDigits, 16) +(26-2));
; 2536 : 	    fprintf(fp_inLINE, "\n");
; 2537 : //        fwrite(CRdLFa, 2, 1, fp_out );
; 2538 : //if (strlen(backup[j]) >=3) {
; 2539 : //        fprintf(fp_out2, "%s", backup[j]);
; 2540 : //        fwrite(CRdLFa, 2, 1, fp_out2 );
; 2541 : //}
; 2542 :       }
; 2543 : // WRITING SORTED ... ]
; 2544 : SORTED_witout_DUPLICATES:
; 2545 : 
; 2546 : // REMOVING DUPLICATES ... [
; 2547 :       linecounterNotRL = nlines;
; 2548 :       nlines1 = linecounterNotRL;
; 2549 :       linecounterRL = 0;
; 2550 : 
; 2551 :       jFirst = 0;
; 2552 :                                       if (linecounterNotRL == 1) {
; 2553 :                                           //fprintf(fp_inLINE, "%s\n", ASbackup[jFirst]);
; 2554 : #if defined(DumboDUMP)
; 2555 : 					    for ( i=0;i<Patternlen; i++)

  01f98	a1 00 00 00 00	 mov	 eax, DWORD PTR _Patternlen
  01f9d	33 f6		 xor	 esi, esi
  01f9f	83 c4 08	 add	 esp, 8
$SORTED_witout_DUPLICATES$6144:
  01fa2	89 74 24 20	 mov	 DWORD PTR _linecounterRL$[esp+376], esi
  01fa6	83 fd 01	 cmp	 ebp, 1
  01fa9	75 2d		 jne	 SHORT $LN52@main
  01fab	85 c0		 test	 eax, eax
  01fad	7e 20		 jle	 SHORT $LN49@main
  01faf	90		 npad	 1
$LL51@main:

; 2556 : 					    fprintf(fp_inLINE, "%c", *(ASbackup[jFirst]+i));

  01fb0	8b 17		 mov	 edx, DWORD PTR [edi]
  01fb2	0f b6 04 32	 movzx	 eax, BYTE PTR [edx+esi]
  01fb6	50		 push	 eax
  01fb7	68 00 00 00 00	 push	 OFFSET $SG6157
  01fbc	53		 push	 ebx
  01fbd	e8 00 00 00 00	 call	 _fprintf
  01fc2	a1 00 00 00 00	 mov	 eax, DWORD PTR _Patternlen
  01fc7	46		 inc	 esi
  01fc8	83 c4 0c	 add	 esp, 12			; 0000000cH
  01fcb	3b f0		 cmp	 esi, eax
  01fcd	7c e1		 jl	 SHORT $LL51@main
$LN49@main:

; 2557 : 					    //fprintf(fp_inLINE, "\n");
; 2558 : #endif
; 2559 :                                           linecounterRL++;

  01fcf	be 01 00 00 00	 mov	 esi, 1
  01fd4	89 74 24 20	 mov	 DWORD PTR _linecounterRL$[esp+376], esi
$LN52@main:

; 2562 :                 linecounterNotRL--;

  01fd8	8d 4d ff	 lea	 ecx, DWORD PTR [ebp-1]
  01fdb	89 4c 24 28	 mov	 DWORD PTR _linecounterNotRL$[esp+376], ecx

; 2563 :       for( j = jFirst + 1; j < nlines1; j++ )

  01fdf	c7 44 24 38 01
	00 00 00	 mov	 DWORD PTR _j$[esp+376], 1
  01fe7	83 fd 01	 cmp	 ebp, 1
  01fea	0f 86 d9 00 00
	00		 jbe	 $LN193@main

; 2560 :                                       }
; 2561 :       jPrevLine = jFirst;

  01ff0	8d 57 04	 lea	 edx, DWORD PTR [edi+4]
  01ff3	33 db		 xor	 ebx, ebx
  01ff5	89 54 24 24	 mov	 DWORD PTR tv2248[esp+376], edx
  01ff9	8d a4 24 00 00
	00 00		 npad	 7
$LL199@main:

; 2564 :       {
; 2565 :                 if (linecounterNotRL != 0) {

  02000	83 7c 24 28 00	 cmp	 DWORD PTR _linecounterNotRL$[esp+376], 0
  02005	0f 84 a4 00 00
	00		 je	 $LN47@main

; 2566 :                 linecounterNotRL--;
; 2567 : 
; 2568 : 
; 2569 :                 //if ( strcmpKAZE(ASbackup[jPrevLine], ASbackup[j]) != 0 ) {
; 2570 :                 if ( memcmpKAZE(ASbackup[jPrevLine], ASbackup[j], Patternlen) != 0 ) {

  0200b	8b 4c 24 24	 mov	 ecx, DWORD PTR tv2248[esp+376]
  0200f	ff 4c 24 28	 dec	 DWORD PTR _linecounterNotRL$[esp+376]
  02013	8b 31		 mov	 esi, DWORD PTR [ecx]
  02015	8b 0c 1f	 mov	 ecx, DWORD PTR [edi+ebx]
  02018	85 c0		 test	 eax, eax
  0201a	74 51		 je	 SHORT $LN187@main
  0201c	8d 50 ff	 lea	 edx, DWORD PTR [eax-1]
  0201f	89 54 24 34	 mov	 DWORD PTR $T6834[esp+376], edx
  02023	85 d2		 test	 edx, edx
  02025	74 0e		 je	 SHORT $LN120@main
$LL121@main:
  02027	8a 11		 mov	 dl, BYTE PTR [ecx]
  02029	3a 16		 cmp	 dl, BYTE PTR [esi]
  0202b	75 08		 jne	 SHORT $LN120@main
  0202d	41		 inc	 ecx
  0202e	46		 inc	 esi
  0202f	ff 4c 24 34	 dec	 DWORD PTR $T6834[esp+376]
  02033	75 f2		 jne	 SHORT $LL121@main
$LN120@main:
  02035	0f b6 09	 movzx	 ecx, BYTE PTR [ecx]
  02038	0f b6 16	 movzx	 edx, BYTE PTR [esi]
  0203b	2b ca		 sub	 ecx, edx
  0203d	74 2e		 je	 SHORT $LN187@main

; 2571 :                      //fprintf(fp_inLINE, "%s\n", ASbackup[jPrevLine]);
; 2572 : #if defined(DumboDUMP)
; 2573 : 					    for ( i=0;i<Patternlen; i++)

  0203f	33 f6		 xor	 esi, esi
  02041	85 c0		 test	 eax, eax
  02043	7e 24		 jle	 SHORT $LN41@main
$LL43@main:

; 2574 : 					    fprintf(fp_inLINE, "%c", *(ASbackup[jPrevLine]+i));

  02045	8b 04 1f	 mov	 eax, DWORD PTR [edi+ebx]
  02048	0f b6 0c 30	 movzx	 ecx, BYTE PTR [eax+esi]
  0204c	8b 54 24 2c	 mov	 edx, DWORD PTR _fp_inLINE$[esp+376]
  02050	51		 push	 ecx
  02051	68 00 00 00 00	 push	 OFFSET $SG6166
  02056	52		 push	 edx
  02057	e8 00 00 00 00	 call	 _fprintf
  0205c	a1 00 00 00 00	 mov	 eax, DWORD PTR _Patternlen
  02061	46		 inc	 esi
  02062	83 c4 0c	 add	 esp, 12			; 0000000cH
  02065	3b f0		 cmp	 esi, eax
  02067	7c dc		 jl	 SHORT $LL43@main
$LN41@main:

; 2575 : 					    //fprintf(fp_inLINE, "\n");
; 2576 : #endif
; 2577 :                      linecounterRL++;

  02069	ff 44 24 20	 inc	 DWORD PTR _linecounterRL$[esp+376]
$LN187@main:

; 2578 :                 }
; 2579 : 
; 2580 :                 if (linecounterNotRL == 0) {

  0206d	83 7c 24 28 00	 cmp	 DWORD PTR _linecounterNotRL$[esp+376], 0
  02072	75 33		 jne	 SHORT $LN40@main

; 2581 :                                           //fprintf(fp_inLINE, "%s\n", ASbackup[j]);
; 2582 : #if defined(DumboDUMP)
; 2583 : 					    for ( i=0;i<Patternlen; i++)

  02074	33 f6		 xor	 esi, esi
  02076	85 c0		 test	 eax, eax
  02078	7e 29		 jle	 SHORT $LN37@main
  0207a	8b 5c 24 24	 mov	 ebx, DWORD PTR tv2248[esp+376]
  0207e	8b ff		 npad	 2
$LL39@main:

; 2584 : 					    fprintf(fp_inLINE, "%c", *(ASbackup[j]+i));

  02080	8b 03		 mov	 eax, DWORD PTR [ebx]
  02082	0f b6 0c 06	 movzx	 ecx, BYTE PTR [esi+eax]
  02086	8b 54 24 2c	 mov	 edx, DWORD PTR _fp_inLINE$[esp+376]
  0208a	51		 push	 ecx
  0208b	68 00 00 00 00	 push	 OFFSET $SG6171
  02090	52		 push	 edx
  02091	e8 00 00 00 00	 call	 _fprintf
  02096	a1 00 00 00 00	 mov	 eax, DWORD PTR _Patternlen
  0209b	46		 inc	 esi
  0209c	83 c4 0c	 add	 esp, 12			; 0000000cH
  0209f	3b f0		 cmp	 esi, eax
  020a1	7c dd		 jl	 SHORT $LL39@main
$LN37@main:

; 2585 : 					    //fprintf(fp_inLINE, "\n");
; 2586 : #endif
; 2587 :                                           linecounterRL++;

  020a3	ff 44 24 20	 inc	 DWORD PTR _linecounterRL$[esp+376]
$LN40@main:

; 2563 :       for( j = jFirst + 1; j < nlines1; j++ )

  020a7	8b 5c 24 38	 mov	 ebx, DWORD PTR _j$[esp+376]
  020ab	03 db		 add	 ebx, ebx
  020ad	03 db		 add	 ebx, ebx
$LN47@main:
  020af	8b 4c 24 38	 mov	 ecx, DWORD PTR _j$[esp+376]
  020b3	83 44 24 24 04	 add	 DWORD PTR tv2248[esp+376], 4
  020b8	41		 inc	 ecx
  020b9	89 4c 24 38	 mov	 DWORD PTR _j$[esp+376], ecx
  020bd	3b cd		 cmp	 ecx, ebp
  020bf	0f 82 3b ff ff
	ff		 jb	 $LL199@main
  020c5	8b 74 24 20	 mov	 esi, DWORD PTR _linecounterRL$[esp+376]
$LN193@main:

; 2588 :                 }
; 2589 :                 jPrevLine = j;
; 2590 :                 }
; 2591 :       }
; 2592 : // REMOVING DUPLICATES ... ]
; 2593 : 
; 2594 : printf("Patternlen:%d|%d-%d+1|linecounterRL:%d|%d\n",Patternlen,Strnglen,Patternlen,linecounterRL,Strnglen-Patternlen+1-linecounterRL);

  020c9	8b 4c 24 10	 mov	 ecx, DWORD PTR _Strnglen$[esp+376]
  020cd	8b d1		 mov	 edx, ecx
  020cf	2b d6		 sub	 edx, esi
  020d1	2b d0		 sub	 edx, eax
  020d3	42		 inc	 edx
  020d4	52		 push	 edx
  020d5	56		 push	 esi
  020d6	50		 push	 eax
  020d7	51		 push	 ecx
  020d8	50		 push	 eax
  020d9	68 00 00 00 00	 push	 OFFSET $SG6172
  020de	e8 00 00 00 00	 call	 _printf
  020e3	83 c4 18	 add	 esp, 24			; 00000018H

; 2595 : if (linecounterRL>256*256*256) { //3 bytes encode 2^24=256*256*256 B-Blocks.

  020e6	81 fe 00 00 00
	01		 cmp	 esi, 16777216		; 01000000H
  020ec	0f 87 10 01 00
	00		 ja	 $LN148@main

; 2600 : }
; 2601 : printf("Gain(reduced-size) or Strnglen-(Patternlen*linecounterRL+3*(Strnglen/Patternlen)+(Strnglen%%Patternlen)): %d\n",Strnglen-(Patternlen*linecounterRL+3*(Strnglen/Patternlen)+(Strnglen%Patternlen)));

  020f2	8b 4c 24 10	 mov	 ecx, DWORD PTR _Strnglen$[esp+376]
  020f6	8b 2d 00 00 00
	00		 mov	 ebp, DWORD PTR _Patternlen
  020fc	8b c1		 mov	 eax, ecx
  020fe	99		 cdq
  020ff	f7 fd		 idiv	 ebp
  02101	8b de		 mov	 ebx, esi
  02103	0f af dd	 imul	 ebx, ebp
  02106	6b c0 fd	 imul	 eax, -3			; fffffffdH
  02109	2b c3		 sub	 eax, ebx
  0210b	2b c2		 sub	 eax, edx
  0210d	03 c1		 add	 eax, ecx
  0210f	50		 push	 eax
  02110	68 00 00 00 00	 push	 OFFSET $SG6175
  02115	e8 00 00 00 00	 call	 _printf

; 2602 : 
; 2603 : if ( (signed long)(Strnglen-(Patternlen*linecounterRL+3*(Strnglen/Patternlen)+(Strnglen%Patternlen)))>GainMax) {GainMax=(signed long)(Strnglen-(Patternlen*linecounterRL+3*(Strnglen/Patternlen)+(Strnglen%Patternlen))); GainOrder=Patternlen;}

  0211a	8b 5c 24 18	 mov	 ebx, DWORD PTR _Strnglen$[esp+384]
  0211e	8b 0d 00 00 00
	00		 mov	 ecx, DWORD PTR _Patternlen
  02124	8b c3		 mov	 eax, ebx
  02126	0f af f1	 imul	 esi, ecx
  02129	99		 cdq
  0212a	f7 f9		 idiv	 ecx
  0212c	83 c4 08	 add	 esp, 8
  0212f	8d 2c 85 00 00
	00 00		 lea	 ebp, DWORD PTR [eax*4]
  02136	2b e8		 sub	 ebp, eax
  02138	f7 dd		 neg	 ebp
  0213a	2b ee		 sub	 ebp, esi
  0213c	2b ea		 sub	 ebp, edx
  0213e	8d 04 2b	 lea	 eax, DWORD PTR [ebx+ebp]
  02141	3b 44 24 18	 cmp	 eax, DWORD PTR _GainMax$[esp+376]
  02145	7e 08		 jle	 SHORT $LN35@main
  02147	89 44 24 18	 mov	 DWORD PTR _GainMax$[esp+376], eax
  0214b	89 4c 24 14	 mov	 DWORD PTR _GainOrder$[esp+376], ecx
$LN35@main:

; 2604 : 
; 2605 : free(ASbackup);

  0214f	57		 push	 edi
  02150	e8 00 00 00 00	 call	 _free

; 2606 : fclose(fp_inLINE);

  02155	8b 44 24 30	 mov	 eax, DWORD PTR _fp_inLINE$[esp+380]
  02159	50		 push	 eax
  0215a	e8 00 00 00 00	 call	 _fclose
  0215f	a1 00 00 00 00	 mov	 eax, DWORD PTR _Patternlen
  02164	40		 inc	 eax
  02165	83 c4 08	 add	 esp, 8
  02168	a3 00 00 00 00	 mov	 DWORD PTR _Patternlen, eax
  0216d	83 f8 07	 cmp	 eax, 7
  02170	0f 8e 5d fd ff
	ff		 jle	 $LL191@main

; 2607 : } // MAIN CYCLE ]
; 2608 : //clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;
; 2609 : //printf( "Railgun_hits/Railgun_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);
; 2610 : //printf( "\nBuilding-Blocks_DUMPER total time: %lu clocks\n", (long)(TotalRoughSearchTime));
; 2611 : printf( "\nMaximum compression (or minimum expansion) for order: %lu\n", GainOrder);

  02176	8b 44 24 14	 mov	 eax, DWORD PTR _GainOrder$[esp+376]
  0217a	50		 push	 eax
  0217b	68 00 00 00 00	 push	 OFFSET $SG6179
  02180	e8 00 00 00 00	 call	 _printf
  02185	83 c4 08	 add	 esp, 8

; 2612 : 
; 2613 : clocks3 = clock();

  02188	e8 00 00 00 00	 call	 _clock

; 2614 : // [ SS file creating:
; 2615 : 
; 2616 : bufEXTENSION = (unsigned char *) malloc(sizeof (unsigned char) * (strlen(argv[1])+1+3)); //when creating .SS

  0218d	8b 4c 24 30	 mov	 ecx, DWORD PTR _argv$GSCopy$[esp+376]
  02191	a3 00 00 00 00	 mov	 DWORD PTR _clocks3, eax
  02196	8b 71 04	 mov	 esi, DWORD PTR [ecx+4]
  02199	8b c6		 mov	 eax, esi
  0219b	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
  0219e	8b ff		 npad	 2
$LL174@main:
  021a0	8a 08		 mov	 cl, BYTE PTR [eax]
  021a2	40		 inc	 eax
  021a3	84 c9		 test	 cl, cl
  021a5	75 f9		 jne	 SHORT $LL174@main
  021a7	2b c2		 sub	 eax, edx
  021a9	83 c0 04	 add	 eax, 4
  021ac	50		 push	 eax
  021ad	e8 00 00 00 00	 call	 _malloc
  021b2	8b e8		 mov	 ebp, eax
  021b4	83 c4 04	 add	 esp, 4
  021b7	89 6c 24 18	 mov	 DWORD PTR _bufEXTENSION$[esp+376], ebp

; 2617 : 
; 2618 : if(bufEXTENSION == NULL)

  021bb	85 ed		 test	 ebp, ebp
  021bd	75 68		 jne	 SHORT $LN34@main

; 2619 : { printf( "Building-Blocks_DUMPER: Can't allocate memory.\n"); return( 1 ); }

  021bf	68 00 00 00 00	 push	 OFFSET $SG6184
  021c4	e8 00 00 00 00	 call	 _printf
  021c9	83 c4 04	 add	 esp, 4
  021cc	8d 45 01	 lea	 eax, DWORD PTR [ebp+1]
  021cf	e9 29 05 00 00	 jmp	 $LN202@main
$LN146@main:

; 2495 : { puts( "Building-Blocks_DUMPER: Needed memory allocation denied!\n" ); return( 1 ); }

  021d4	68 00 00 00 00	 push	 OFFSET $SG6133
  021d9	e8 00 00 00 00	 call	 _puts
  021de	83 c4 04	 add	 esp, 4
  021e1	b8 01 00 00 00	 mov	 eax, 1
  021e6	e9 12 05 00 00	 jmp	 $LN202@main
$LN147@main:

; 2525 :       { printf( "Building-Blocks_DUMPER: Can't create file %s\n", &BuildingBlocksBox[0] ); return( 1 ); }

  021eb	68 00 00 00 00	 push	 OFFSET $SG6142
  021f0	e8 00 00 00 00	 call	 _printf
  021f5	83 c4 08	 add	 esp, 8
  021f8	b8 01 00 00 00	 mov	 eax, 1
  021fd	e9 fb 04 00 00	 jmp	 $LN202@main
$LN148@main:

; 2596 : 	printf( "\nBuilding-Blocks_DUMPER: Overflow! BBs exceed the 16,777,216 limit.\n");

  02202	68 00 00 00 00	 push	 OFFSET $SG6174
  02207	e8 00 00 00 00	 call	 _printf

; 2597 : 	free(ASbackup);

  0220c	57		 push	 edi
  0220d	e8 00 00 00 00	 call	 _free

; 2598 : 	free (Strng);

  02212	8b 54 24 24	 mov	 edx, DWORD PTR _Strng$[esp+384]
  02216	52		 push	 edx
  02217	e8 00 00 00 00	 call	 _free
  0221c	83 c4 0c	 add	 esp, 12			; 0000000cH

; 2599 : 	return -1;

  0221f	83 c8 ff	 or	 eax, -1
  02222	e9 d6 04 00 00	 jmp	 $LN202@main
$LN34@main:

; 2620 : 
; 2621 : strcpy(bufEXTENSION, argv[1]);

  02227	8b ce		 mov	 ecx, esi
  02229	8b d5		 mov	 edx, ebp
  0222b	eb 03 8d 49 00	 npad	 5
$LL97@main:
  02230	8a 01		 mov	 al, BYTE PTR [ecx]
  02232	88 02		 mov	 BYTE PTR [edx], al
  02234	41		 inc	 ecx
  02235	42		 inc	 edx
  02236	84 c0		 test	 al, al
  02238	75 f6		 jne	 SHORT $LL97@main

; 2622 : strcat(bufEXTENSION, ".SS");

  0223a	b8 00 00 00 00	 mov	 eax, OFFSET $SG6185
  0223f	8b d0		 mov	 edx, eax
$LL175@main:
  02241	8a 08		 mov	 cl, BYTE PTR [eax]
  02243	40		 inc	 eax
  02244	84 c9		 test	 cl, cl
  02246	75 f9		 jne	 SHORT $LL175@main
  02248	2b c2		 sub	 eax, edx
  0224a	8d 7d ff	 lea	 edi, DWORD PTR [ebp-1]
  0224d	8d 49 00	 npad	 3
$LL176@main:
  02250	8a 4f 01	 mov	 cl, BYTE PTR [edi+1]
  02253	47		 inc	 edi
  02254	84 c9		 test	 cl, cl
  02256	75 f8		 jne	 SHORT $LL176@main
  02258	8b c8		 mov	 ecx, eax
  0225a	c1 e9 02	 shr	 ecx, 2
  0225d	8b f2		 mov	 esi, edx
  0225f	f3 a5		 rep movsd
  02261	8b c8		 mov	 ecx, eax
  02263	83 e1 03	 and	 ecx, 3

; 2623 : 
; 2624 : printf( "\nCreating %s ...\n", bufEXTENSION);

  02266	55		 push	 ebp
  02267	68 00 00 00 00	 push	 OFFSET $SG6186
  0226c	f3 a4		 rep movsb
  0226e	e8 00 00 00 00	 call	 _printf

; 2625 : if( ( fp_outLINE = fopen( bufEXTENSION, "wb" ) ) == NULL )

  02273	68 00 00 00 00	 push	 OFFSET $SG6189
  02278	55		 push	 ebp
  02279	e8 00 00 00 00	 call	 _fopen
  0227e	8b d8		 mov	 ebx, eax
  02280	83 c4 10	 add	 esp, 16			; 00000010H
  02283	89 5c 24 24	 mov	 DWORD PTR _fp_outLINE$[esp+376], ebx
  02287	85 db		 test	 ebx, ebx
  02289	75 16		 jne	 SHORT $LN33@main

; 2626 : { printf( "Building-Blocks_DUMPER: Can't open file %s \n", bufEXTENSION ); return( 1 ); }

  0228b	55		 push	 ebp
  0228c	68 00 00 00 00	 push	 OFFSET $SG6190
  02291	e8 00 00 00 00	 call	 _printf
  02296	83 c4 08	 add	 esp, 8
  02299	8d 43 01	 lea	 eax, DWORD PTR [ebx+1]
  0229c	e9 5c 04 00 00	 jmp	 $LN202@main
$LN33@main:

; 2627 : 
; 2628 : fprintf (fp_outLINE, "[Simplicius_Simplicissimus_revision_1]\n"); // 0x1A = 026 ASCIICODE TEXT EOF

  022a1	68 00 00 00 00	 push	 OFFSET $SG6191
  022a6	53		 push	 ebx
  022a7	e8 00 00 00 00	 call	 _fprintf

; 2629 : fprintf (fp_outLINE, "The file format after the ASCII code 026: \n1 byte for BB_Order, \n4bytes for Original_Size, \n4bytes for BB length, \nBB itself, \n3*(Original_Size/BB_Order) bytes of indexes followed by the (Original_Size%%BB_Order) bytes of literals.%c",0x1A); // 0x1A = 026 ASCIICODE TEXT EOF

  022ac	6a 1a		 push	 26			; 0000001aH
  022ae	68 00 00 00 00	 push	 OFFSET $SG6192
  022b3	53		 push	 ebx
  022b4	e8 00 00 00 00	 call	 _fprintf

; 2630 : 
; 2631 : // Uploading BB file to BB pool: 
; 2632 : memcpy(&BuildingBlocksBox[2],_ui64toaKAZEzerocomma (GainOrder, llTOaDigits, 10) +(26-3),3);

  022b9	8b 44 24 28	 mov	 eax, DWORD PTR _GainOrder$[esp+396]
  022bd	6a 0a		 push	 10			; 0000000aH
  022bf	8d 54 24 60	 lea	 edx, DWORD PTR _llTOaDigits$[esp+400]
  022c3	52		 push	 edx
  022c4	99		 cdq
  022c5	52		 push	 edx
  022c6	50		 push	 eax
  022c7	e8 00 00 00 00	 call	 __ui64toaKAZEzerocomma
  022cc	66 8b 48 17	 mov	 cx, WORD PTR [eax+23]
  022d0	66 89 4c 24 62	 mov	 WORD PTR _BuildingBlocksBox$[esp+414], cx
  022d5	8a 50 19	 mov	 dl, BYTE PTR [eax+25]

; 2633 : if( ( fp_inLINE = fopen( &BuildingBlocksBox[0], "rb" ) ) == NULL )

  022d8	8d 44 24 60	 lea	 eax, DWORD PTR _BuildingBlocksBox$[esp+412]
  022dc	68 00 00 00 00	 push	 OFFSET $SG6195
  022e1	50		 push	 eax
  022e2	88 54 24 6c	 mov	 BYTE PTR _BuildingBlocksBox$[esp+424], dl
  022e6	e8 00 00 00 00	 call	 _fopen
  022eb	8b f0		 mov	 esi, eax
  022ed	83 c4 2c	 add	 esp, 44			; 0000002cH
  022f0	85 f6		 test	 esi, esi
  022f2	75 1a		 jne	 SHORT $LN32@main

; 2634 : { printf( "Building-Blocks_DUMPER: Can't upload file %s\n", &BuildingBlocksBox[0] ); return( 1 ); }

  022f4	8d 4c 24 3c	 lea	 ecx, DWORD PTR _BuildingBlocksBox$[esp+376]
  022f8	51		 push	 ecx
  022f9	68 00 00 00 00	 push	 OFFSET $SG6196
  022fe	e8 00 00 00 00	 call	 _printf
  02303	83 c4 08	 add	 esp, 8
  02306	8d 46 01	 lea	 eax, DWORD PTR [esi+1]
  02309	e9 ef 03 00 00	 jmp	 $LN202@main
$LN32@main:

; 2635 : 
; 2636 :    fseek(fp_inLINE, 0, SEEK_END);

  0230e	6a 02		 push	 2
  02310	6a 00		 push	 0
  02312	56		 push	 esi
  02313	e8 00 00 00 00	 call	 _fseek

; 2637 :    Patternlen = ftell(fp_inLINE);

  02318	56		 push	 esi
  02319	e8 00 00 00 00	 call	 _ftell

; 2638 :    fseek(fp_inLINE, 0, SEEK_SET);

  0231e	6a 00		 push	 0
  02320	6a 00		 push	 0
  02322	56		 push	 esi
  02323	a3 00 00 00 00	 mov	 DWORD PTR _Patternlen, eax
  02328	e8 00 00 00 00	 call	 _fseek

; 2639 : 
; 2640 : BB = (char *)malloc( 768*1024*1024 );

  0232d	68 00 00 00 30	 push	 805306368		; 30000000H
  02332	e8 00 00 00 00	 call	 _malloc
  02337	8b f8		 mov	 edi, eax
  02339	83 c4 20	 add	 esp, 32			; 00000020H
  0233c	89 7c 24 28	 mov	 DWORD PTR _BB$[esp+376], edi

; 2641 : if( BB == NULL )

  02340	85 ff		 test	 edi, edi
  02342	75 15		 jne	 SHORT $LN31@main

; 2642 : { puts( "Building-Blocks_DUMPER: Needed memory allocation denied!\n" ); return( 1 ); }

  02344	68 00 00 00 00	 push	 OFFSET $SG6200
  02349	e8 00 00 00 00	 call	 _puts
  0234e	83 c4 04	 add	 esp, 4
  02351	8d 47 01	 lea	 eax, DWORD PTR [edi+1]
  02354	e9 a4 03 00 00	 jmp	 $LN202@main
$LN31@main:

; 2643 : 
; 2644 : if (Patternlen>768*1024*1024)

  02359	a1 00 00 00 00	 mov	 eax, DWORD PTR _Patternlen
  0235e	3d 00 00 00 30	 cmp	 eax, 805306368		; 30000000H
  02363	7e 17		 jle	 SHORT $LN30@main

; 2645 : { printf( "Building-Blocks_DUMPER: File cannot be loaded, it exceeds 768MB limit.\n" ); return( 1 ); }

  02365	68 00 00 00 00	 push	 OFFSET $SG6202
  0236a	e8 00 00 00 00	 call	 _printf
  0236f	83 c4 04	 add	 esp, 4
  02372	b8 01 00 00 00	 mov	 eax, 1
  02377	e9 81 03 00 00	 jmp	 $LN202@main
$LN30@main:

; 2646 : 
; 2647 : fread(BB, 1, Patternlen, fp_inLINE);

  0237c	56		 push	 esi
  0237d	50		 push	 eax
  0237e	6a 01		 push	 1
  02380	57		 push	 edi
  02381	e8 00 00 00 00	 call	 _fread

; 2648 : fclose(fp_inLINE);

  02386	56		 push	 esi
  02387	e8 00 00 00 00	 call	 _fclose

; 2649 : 
; 2650 : putc(*((unsigned char *)&GainOrder+0), fp_outLINE);

  0238c	0f b6 54 24 28	 movzx	 edx, BYTE PTR _GainOrder$[esp+396]
  02391	53		 push	 ebx
  02392	52		 push	 edx
  02393	e8 00 00 00 00	 call	 _putc

; 2651 : 
; 2652 : putc(*((unsigned char *)&Strnglen+0), fp_outLINE);

  02398	0f b6 44 24 2c	 movzx	 eax, BYTE PTR _Strnglen$[esp+404]
  0239d	53		 push	 ebx
  0239e	50		 push	 eax
  0239f	e8 00 00 00 00	 call	 _putc

; 2653 : putc(*((unsigned char *)&Strnglen+1), fp_outLINE);

  023a4	0f b6 4c 24 35	 movzx	 ecx, BYTE PTR _Strnglen$[esp+413]
  023a9	53		 push	 ebx
  023aa	51		 push	 ecx
  023ab	e8 00 00 00 00	 call	 _putc

; 2654 : putc(*((unsigned char *)&Strnglen+2), fp_outLINE);

  023b0	0f b6 54 24 3e	 movzx	 edx, BYTE PTR _Strnglen$[esp+422]
  023b5	53		 push	 ebx
  023b6	52		 push	 edx
  023b7	e8 00 00 00 00	 call	 _putc

; 2655 : putc(*((unsigned char *)&Strnglen+3), fp_outLINE);

  023bc	0f b6 44 24 47	 movzx	 eax, BYTE PTR _Strnglen$[esp+431]
  023c1	53		 push	 ebx
  023c2	50		 push	 eax
  023c3	e8 00 00 00 00	 call	 _putc

; 2656 : 
; 2657 : putc(*((unsigned char *)&Patternlen+0), fp_outLINE);

  023c8	0f b6 0d 00 00
	00 00		 movzx	 ecx, BYTE PTR _Patternlen
  023cf	53		 push	 ebx
  023d0	51		 push	 ecx
  023d1	e8 00 00 00 00	 call	 _putc

; 2658 : putc(*((unsigned char *)&Patternlen+1), fp_outLINE);

  023d6	0f b6 15 01 00
	00 00		 movzx	 edx, BYTE PTR _Patternlen+1
  023dd	83 c4 44	 add	 esp, 68			; 00000044H
  023e0	53		 push	 ebx
  023e1	52		 push	 edx
  023e2	e8 00 00 00 00	 call	 _putc

; 2659 : putc(*((unsigned char *)&Patternlen+2), fp_outLINE);

  023e7	0f b6 05 02 00
	00 00		 movzx	 eax, BYTE PTR _Patternlen+2
  023ee	53		 push	 ebx
  023ef	50		 push	 eax
  023f0	e8 00 00 00 00	 call	 _putc

; 2660 : putc(*((unsigned char *)&Patternlen+3), fp_outLINE);

  023f5	0f b6 0d 03 00
	00 00		 movzx	 ecx, BYTE PTR _Patternlen+3
  023fc	53		 push	 ebx
  023fd	51		 push	 ecx
  023fe	e8 00 00 00 00	 call	 _putc

; 2661 : 
; 2662 : fwrite(BB, 1, Patternlen, fp_outLINE);

  02403	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _Patternlen
  02409	53		 push	 ebx
  0240a	52		 push	 edx
  0240b	6a 01		 push	 1
  0240d	57		 push	 edi
  0240e	e8 00 00 00 00	 call	 _fwrite

; 2663 : 
; 2664 : // Must dump triads and the eventual remainder/literals.
; 2665 : // 'BB' pool with length 'Patternlen' has 'Patternlen/GainOrder' BBs.
; 2666 : // 'Strng' pool with length 'Strnglen' must be traversed with step 'GainOrder' assigning indexes/triads to BBs ...
; 2667 : 
; 2668 : // [ Triads dumping
; 2669 : 
; 2670 : // Maximum slow search:
; 2671 : //Creating googlebooks-eng-us-all-4gram-20090715-graffith_K_distinct.txt.SS ...
; 2672 : //Building-Blocks_DUMPER .SS dumping time: 1558673 clocks
; 2673 : //Building-Blocks_DUMPER total time: 1685829 clocks
; 2674 : goto NextNextInLine;
; 2675 : for (ThunderwithR=0; ThunderwithR<Strnglen/GainOrder; ThunderwithR++)
; 2676 : for (ThunderwithL=0; ThunderwithL<Patternlen/GainOrder; ThunderwithL++)
; 2677 : {
; 2678 :         if (memcmp(&BB[ThunderwithL*GainOrder+0],&Strng[ThunderwithR*GainOrder+0],GainOrder) == 0) {
; 2679 : 	putc(*((unsigned char *)&ThunderwithL+0), fp_outLINE);
; 2680 : 	putc(*((unsigned char *)&ThunderwithL+1), fp_outLINE);
; 2681 : 	putc(*((unsigned char *)&ThunderwithL+2), fp_outLINE);
; 2682 : 	// Notice that only 3 lower Little-Endian bytes are dumped!
; 2683 : 	break;
; 2684 : 	}
; 2685 : }
; 2686 : goto LAstLine;
; 2687 : NextInLine:
; 2688 : // Brute-force slow search: Railgun_Quadruplet
; 2689 : //Creating googlebooks-eng-us-all-4gram-20090715-graffith_K_distinct.txt.SS ...
; 2690 : //Building-Blocks_DUMPER .SS dumping time: 573392 clocks
; 2691 : //Building-Blocks_DUMPER total time: 700579 clocks
; 2692 : for (ThunderwithR=0; ThunderwithR<Strnglen/GainOrder; ThunderwithR++)
; 2693 : {
; 2694 :         FoundInPTR=BB;
; 2695 : 	while ( FoundInPTRNEW = Railgun_Quadruplet(FoundInPTR,&Strng[ThunderwithR*GainOrder+0],Patternlen,GainOrder) ) {
; 2696 : 	        if ( (FoundInPTRNEW-BB) % GainOrder == 0 ) {
; 2697 : 		ThunderwithL = (unsigned long)(FoundInPTRNEW-BB) / GainOrder;
; 2698 : 		putc(*((unsigned char *)&ThunderwithL+0), fp_outLINE);
; 2699 : 		putc(*((unsigned char *)&ThunderwithL+1), fp_outLINE);
; 2700 : 		putc(*((unsigned char *)&ThunderwithL+2), fp_outLINE);
; 2701 : 		// Notice that only 3 lower Little-Endian bytes are dumped!
; 2702 : 		break;
; 2703 : 		}
; 2704 : 		FoundInPTR = FoundInPTRNEW+1;
; 2705 : 	}
; 2706 : }
; 2707 : goto LAstLine;
; 2708 : NextNextInLine:
; 2709 : // Binary-Search:
; 2710 : //Creating googlebooks-eng-us-all-4gram-20090715-graffith_K_distinct.txt.SS ...
; 2711 : //Building-Blocks_DUMPER .SS dumping time: 1923 clocks
; 2712 : //Building-Blocks_DUMPER total time: 132563 clocks
; 2713 : for (ThunderwithR=0; ThunderwithR<Strnglen/GainOrder; ThunderwithR++)

  02413	8b 4c 24 38	 mov	 ecx, DWORD PTR _Strnglen$[esp+416]
  02417	8b 74 24 3c	 mov	 esi, DWORD PTR _GainOrder$[esp+416]
  0241b	8b c1		 mov	 eax, ecx
  0241d	99		 cdq
  0241e	f7 fe		 idiv	 esi
  02420	33 ed		 xor	 ebp, ebp
  02422	83 c4 28	 add	 esp, 40			; 00000028H
$NextNextInLine$6212:
  02425	89 6c 24 34	 mov	 DWORD PTR _ThunderwithR$[esp+376], ebp
  02429	85 c0		 test	 eax, eax
  0242b	0f 8e 19 02 00
	00		 jle	 $LAstLine$6223
$LL16@main:

; 2714 : {
; 2715 : 	YabbaYabba = 0;
; 2716 :         LeftPointBS = 0;
; 2717 :         RightPointBS = Patternlen/GainOrder - 1;

  02431	a1 00 00 00 00	 mov	 eax, DWORD PTR _Patternlen
  02436	99		 cdq
  02437	f7 fe		 idiv	 esi
  02439	33 c9		 xor	 ecx, ecx
  0243b	89 4c 24 38	 mov	 DWORD PTR _LeftPointBS$[esp+376], ecx
  0243f	48		 dec	 eax
  02440	89 44 24 2c	 mov	 DWORD PTR _RightPointBS$[esp+376], eax

; 2718 :         PivotPointBS = 0;
; 2719 : 	do {
; 2720 : 			if (RightPointBS - LeftPointBS <= 1) {

  02444	83 f8 01	 cmp	 eax, 1
  02447	0f 8e c1 00 00
	00		 jle	 $LN150@main

; 2725 : 				break; }
; 2726 : 	        PivotPointBS = (LeftPointBS + RightPointBS) >> 1;
; 2727 : 		NataliaKills = memcmp(&Strng[ThunderwithR*GainOrder+0],&BB[PivotPointBS*GainOrder+0],GainOrder);

  0244d	0f af ee	 imul	 ebp, esi
  02450	03 6c 24 1c	 add	 ebp, DWORD PTR _Strng$[esp+376]
  02454	89 6c 24 30	 mov	 DWORD PTR tv1641[esp+376], ebp
  02458	eb 06 8d 9b 00
	00 00 00	 npad	 8
$LL13@main:
  02460	8b 7c 24 30	 mov	 edi, DWORD PTR tv1641[esp+376]
  02464	8d 1c 08	 lea	 ebx, DWORD PTR [eax+ecx]
  02467	d1 fb		 sar	 ebx, 1
  02469	8b cb		 mov	 ecx, ebx
  0246b	0f af ce	 imul	 ecx, esi
  0246e	03 4c 24 28	 add	 ecx, DWORD PTR _BB$[esp+376]
  02472	89 5c 24 20	 mov	 DWORD PTR _PivotPointBS$[esp+376], ebx
  02476	8b c6		 mov	 eax, esi
  02478	83 fe 04	 cmp	 esi, 4
  0247b	72 17		 jb	 SHORT $LN149@main
  0247d	8d 49 00	 npad	 3
$LL115@main:
  02480	8b 17		 mov	 edx, DWORD PTR [edi]
  02482	3b 11		 cmp	 edx, DWORD PTR [ecx]
  02484	75 12		 jne	 SHORT $LN116@main
  02486	83 e8 04	 sub	 eax, 4
  02489	83 c1 04	 add	 ecx, 4
  0248c	83 c7 04	 add	 edi, 4
  0248f	83 f8 04	 cmp	 eax, 4
  02492	73 ec		 jae	 SHORT $LL115@main
$LN149@main:
  02494	85 c0		 test	 eax, eax
  02496	74 43		 je	 SHORT $LN181@main
$LN116@main:
  02498	0f b6 17	 movzx	 edx, BYTE PTR [edi]
  0249b	0f b6 29	 movzx	 ebp, BYTE PTR [ecx]
  0249e	2b d5		 sub	 edx, ebp
  024a0	75 31		 jne	 SHORT $LN180@main
  024a2	83 f8 01	 cmp	 eax, 1
  024a5	76 34		 jbe	 SHORT $LN181@main
  024a7	0f b6 57 01	 movzx	 edx, BYTE PTR [edi+1]
  024ab	0f b6 69 01	 movzx	 ebp, BYTE PTR [ecx+1]
  024af	2b d5		 sub	 edx, ebp
  024b1	75 20		 jne	 SHORT $LN180@main
  024b3	83 f8 02	 cmp	 eax, 2
  024b6	76 23		 jbe	 SHORT $LN181@main
  024b8	0f b6 57 02	 movzx	 edx, BYTE PTR [edi+2]
  024bc	0f b6 69 02	 movzx	 ebp, BYTE PTR [ecx+2]
  024c0	2b d5		 sub	 edx, ebp
  024c2	75 0f		 jne	 SHORT $LN180@main
  024c4	83 f8 03	 cmp	 eax, 3
  024c7	76 12		 jbe	 SHORT $LN181@main
  024c9	0f b6 57 03	 movzx	 edx, BYTE PTR [edi+3]
  024cd	0f b6 41 03	 movzx	 eax, BYTE PTR [ecx+3]
  024d1	2b d0		 sub	 edx, eax
$LN180@main:
  024d3	c1 fa 1f	 sar	 edx, 31			; 0000001fH
  024d6	83 ca 01	 or	 edx, 1
  024d9	eb 02		 jmp	 SHORT $LN119@main
$LN181@main:
  024db	33 d2		 xor	 edx, edx
$LN119@main:

; 2728 : 	        if ( NataliaKills == 0) { YabbaYabba = 1; break; }

  024dd	85 d2		 test	 edx, edx
  024df	0f 84 1c 01 00
	00		 je	 $LN151@main

; 2729 : 		else if ( NataliaKills < 0) { RightPointBS = PivotPointBS; }

  024e5	79 0c		 jns	 SHORT $LN5@main
  024e7	8b 4c 24 38	 mov	 ecx, DWORD PTR _LeftPointBS$[esp+376]
  024eb	8b c3		 mov	 eax, ebx
  024ed	89 44 24 2c	 mov	 DWORD PTR _RightPointBS$[esp+376], eax
  024f1	eb 0a		 jmp	 SHORT $LN12@main
$LN5@main:

; 2730 : 		else { LeftPointBS = PivotPointBS; }

  024f3	8b 44 24 2c	 mov	 eax, DWORD PTR _RightPointBS$[esp+376]
  024f7	8b cb		 mov	 ecx, ebx
  024f9	89 4c 24 38	 mov	 DWORD PTR _LeftPointBS$[esp+376], ecx
$LN12@main:

; 2718 :         PivotPointBS = 0;
; 2719 : 	do {
; 2720 : 			if (RightPointBS - LeftPointBS <= 1) {

  024fd	8b d0		 mov	 edx, eax
  024ff	2b d1		 sub	 edx, ecx
  02501	83 fa 01	 cmp	 edx, 1
  02504	0f 8f 56 ff ff
	ff		 jg	 $LL13@main
  0250a	8b 6c 24 34	 mov	 ebp, DWORD PTR _ThunderwithR$[esp+376]
$LN150@main:

; 2721 : 				NataliaKills = memcmp(&Strng[ThunderwithR*GainOrder+0],&BB[LeftPointBS*GainOrder+0],GainOrder);

  0250e	8b 5c 24 1c	 mov	 ebx, DWORD PTR _Strng$[esp+376]
  02512	0f af ce	 imul	 ecx, esi
  02515	0f af ee	 imul	 ebp, esi
  02518	03 4c 24 28	 add	 ecx, DWORD PTR _BB$[esp+376]
  0251c	03 dd		 add	 ebx, ebp
  0251e	8b fe		 mov	 edi, esi
  02520	8b d3		 mov	 edx, ebx
  02522	83 fe 04	 cmp	 esi, 4
  02525	72 14		 jb	 SHORT $LN152@main
$LL103@main:
  02527	8b 02		 mov	 eax, DWORD PTR [edx]
  02529	3b 01		 cmp	 eax, DWORD PTR [ecx]
  0252b	75 12		 jne	 SHORT $LN188@main
  0252d	83 ef 04	 sub	 edi, 4
  02530	83 c1 04	 add	 ecx, 4
  02533	83 c2 04	 add	 edx, 4
  02536	83 ff 04	 cmp	 edi, 4
  02539	73 ec		 jae	 SHORT $LL103@main
$LN152@main:
  0253b	85 ff		 test	 edi, edi
  0253d	74 43		 je	 SHORT $LN195@main
$LN188@main:
  0253f	0f b6 02	 movzx	 eax, BYTE PTR [edx]
  02542	0f b6 29	 movzx	 ebp, BYTE PTR [ecx]
  02545	2b c5		 sub	 eax, ebp
  02547	75 31		 jne	 SHORT $LN189@main
  02549	83 ff 01	 cmp	 edi, 1
  0254c	76 34		 jbe	 SHORT $LN195@main
  0254e	0f b6 42 01	 movzx	 eax, BYTE PTR [edx+1]
  02552	0f b6 69 01	 movzx	 ebp, BYTE PTR [ecx+1]
  02556	2b c5		 sub	 eax, ebp
  02558	75 20		 jne	 SHORT $LN189@main
  0255a	83 ff 02	 cmp	 edi, 2
  0255d	76 23		 jbe	 SHORT $LN195@main
  0255f	0f b6 42 02	 movzx	 eax, BYTE PTR [edx+2]
  02563	0f b6 69 02	 movzx	 ebp, BYTE PTR [ecx+2]
  02567	2b c5		 sub	 eax, ebp
  02569	75 0f		 jne	 SHORT $LN189@main
  0256b	83 ff 03	 cmp	 edi, 3
  0256e	76 12		 jbe	 SHORT $LN195@main
  02570	0f b6 42 03	 movzx	 eax, BYTE PTR [edx+3]
  02574	0f b6 49 03	 movzx	 ecx, BYTE PTR [ecx+3]
  02578	2b c1		 sub	 eax, ecx
$LN189@main:
  0257a	c1 f8 1f	 sar	 eax, 31			; 0000001fH
  0257d	83 c8 01	 or	 eax, 1

; 2722 : 			        if ( NataliaKills == 0) { YabbaYabba = 1; PivotPointBS = LeftPointBS; break; }

  02580	75 06		 jne	 SHORT $LN9@main
$LN195@main:
  02582	8b 5c 24 38	 mov	 ebx, DWORD PTR _LeftPointBS$[esp+376]
  02586	eb 75		 jmp	 SHORT $LN203@main
$LN9@main:

; 2723 : 				NataliaKills = memcmp(&Strng[ThunderwithR*GainOrder+0],&BB[RightPointBS*GainOrder+0],GainOrder);

  02588	8b 6c 24 2c	 mov	 ebp, DWORD PTR _RightPointBS$[esp+376]
  0258c	8b cd		 mov	 ecx, ebp
  0258e	0f af ce	 imul	 ecx, esi
  02591	03 4c 24 28	 add	 ecx, DWORD PTR _BB$[esp+376]
  02595	8b fe		 mov	 edi, esi
  02597	8b d3		 mov	 edx, ebx
  02599	83 fe 04	 cmp	 esi, 4
  0259c	72 16		 jb	 SHORT $LN153@main
  0259e	8b ff		 npad	 2
$LL109@main:
  025a0	8b 02		 mov	 eax, DWORD PTR [edx]
  025a2	3b 01		 cmp	 eax, DWORD PTR [ecx]
  025a4	75 12		 jne	 SHORT $LN110@main
  025a6	83 ef 04	 sub	 edi, 4
  025a9	83 c1 04	 add	 ecx, 4
  025ac	83 c2 04	 add	 edx, 4
  025af	83 ff 04	 cmp	 edi, 4
  025b2	73 ec		 jae	 SHORT $LL109@main
$LN153@main:
  025b4	85 ff		 test	 edi, edi
  025b6	74 43		 je	 SHORT $LN169@main
$LN110@main:
  025b8	0f b6 19	 movzx	 ebx, BYTE PTR [ecx]
  025bb	0f b6 02	 movzx	 eax, BYTE PTR [edx]
  025be	2b c3		 sub	 eax, ebx
  025c0	75 31		 jne	 SHORT $LN112@main
  025c2	83 ff 01	 cmp	 edi, 1
  025c5	76 34		 jbe	 SHORT $LN169@main
  025c7	0f b6 42 01	 movzx	 eax, BYTE PTR [edx+1]
  025cb	0f b6 59 01	 movzx	 ebx, BYTE PTR [ecx+1]
  025cf	2b c3		 sub	 eax, ebx
  025d1	75 20		 jne	 SHORT $LN112@main
  025d3	83 ff 02	 cmp	 edi, 2
  025d6	76 23		 jbe	 SHORT $LN169@main
  025d8	0f b6 42 02	 movzx	 eax, BYTE PTR [edx+2]
  025dc	0f b6 59 02	 movzx	 ebx, BYTE PTR [ecx+2]
  025e0	2b c3		 sub	 eax, ebx
  025e2	75 0f		 jne	 SHORT $LN112@main
  025e4	83 ff 03	 cmp	 edi, 3
  025e7	76 12		 jbe	 SHORT $LN169@main
  025e9	0f b6 42 03	 movzx	 eax, BYTE PTR [edx+3]
  025ed	0f b6 49 03	 movzx	 ecx, BYTE PTR [ecx+3]
  025f1	2b c1		 sub	 eax, ecx
$LN112@main:
  025f3	c1 f8 1f	 sar	 eax, 31			; 0000001fH
  025f6	83 c8 01	 or	 eax, 1

; 2724 : 	        		if ( NataliaKills == 0) { YabbaYabba = 1; PivotPointBS = RightPointBS; break; }

  025f9	75 31		 jne	 SHORT $LN196@main
$LN169@main:
  025fb	8b dd		 mov	 ebx, ebp
$LN203@main:
  025fd	89 5c 24 20	 mov	 DWORD PTR _PivotPointBS$[esp+376], ebx
$LN151@main:

; 2731 : 	} while (1 == 1);
; 2732 : 	        if ( YabbaYabba != 0 ) {
; 2733 : 		ThunderwithL = PivotPointBS;
; 2734 : 		putc(*((unsigned char *)&ThunderwithL+0), fp_outLINE);

  02601	8b 74 24 24	 mov	 esi, DWORD PTR _fp_outLINE$[esp+376]
  02605	0f b6 d3	 movzx	 edx, bl
  02608	56		 push	 esi
  02609	52		 push	 edx
  0260a	e8 00 00 00 00	 call	 _putc

; 2735 : 		putc(*((unsigned char *)&ThunderwithL+1), fp_outLINE);

  0260f	0f b6 c7	 movzx	 eax, bh
  02612	56		 push	 esi
  02613	50		 push	 eax
  02614	e8 00 00 00 00	 call	 _putc

; 2736 : 		putc(*((unsigned char *)&ThunderwithL+2), fp_outLINE);

  02619	0f b6 4c 24 32	 movzx	 ecx, BYTE PTR _PivotPointBS$[esp+394]
  0261e	56		 push	 esi
  0261f	51		 push	 ecx
  02620	e8 00 00 00 00	 call	 _putc
  02625	8b 74 24 2c	 mov	 esi, DWORD PTR _GainOrder$[esp+400]
  02629	83 c4 18	 add	 esp, 24			; 00000018H
$LN196@main:
  0262c	8b 4c 24 10	 mov	 ecx, DWORD PTR _Strnglen$[esp+376]
  02630	8b c1		 mov	 eax, ecx
  02632	99		 cdq
  02633	f7 fe		 idiv	 esi
  02635	8b 6c 24 34	 mov	 ebp, DWORD PTR _ThunderwithR$[esp+376]
  02639	45		 inc	 ebp
  0263a	89 6c 24 34	 mov	 DWORD PTR _ThunderwithR$[esp+376], ebp
  0263e	3b e8		 cmp	 ebp, eax
  02640	0f 8c eb fd ff
	ff		 jl	 $LL16@main

; 2663 : 
; 2664 : // Must dump triads and the eventual remainder/literals.
; 2665 : // 'BB' pool with length 'Patternlen' has 'Patternlen/GainOrder' BBs.
; 2666 : // 'Strng' pool with length 'Strnglen' must be traversed with step 'GainOrder' assigning indexes/triads to BBs ...
; 2667 : 
; 2668 : // [ Triads dumping
; 2669 : 
; 2670 : // Maximum slow search:
; 2671 : //Creating googlebooks-eng-us-all-4gram-20090715-graffith_K_distinct.txt.SS ...
; 2672 : //Building-Blocks_DUMPER .SS dumping time: 1558673 clocks
; 2673 : //Building-Blocks_DUMPER total time: 1685829 clocks
; 2674 : goto NextNextInLine;
; 2675 : for (ThunderwithR=0; ThunderwithR<Strnglen/GainOrder; ThunderwithR++)
; 2676 : for (ThunderwithL=0; ThunderwithL<Patternlen/GainOrder; ThunderwithL++)
; 2677 : {
; 2678 :         if (memcmp(&BB[ThunderwithL*GainOrder+0],&Strng[ThunderwithR*GainOrder+0],GainOrder) == 0) {
; 2679 : 	putc(*((unsigned char *)&ThunderwithL+0), fp_outLINE);
; 2680 : 	putc(*((unsigned char *)&ThunderwithL+1), fp_outLINE);
; 2681 : 	putc(*((unsigned char *)&ThunderwithL+2), fp_outLINE);
; 2682 : 	// Notice that only 3 lower Little-Endian bytes are dumped!
; 2683 : 	break;
; 2684 : 	}
; 2685 : }
; 2686 : goto LAstLine;
; 2687 : NextInLine:
; 2688 : // Brute-force slow search: Railgun_Quadruplet
; 2689 : //Creating googlebooks-eng-us-all-4gram-20090715-graffith_K_distinct.txt.SS ...
; 2690 : //Building-Blocks_DUMPER .SS dumping time: 573392 clocks
; 2691 : //Building-Blocks_DUMPER total time: 700579 clocks
; 2692 : for (ThunderwithR=0; ThunderwithR<Strnglen/GainOrder; ThunderwithR++)
; 2693 : {
; 2694 :         FoundInPTR=BB;
; 2695 : 	while ( FoundInPTRNEW = Railgun_Quadruplet(FoundInPTR,&Strng[ThunderwithR*GainOrder+0],Patternlen,GainOrder) ) {
; 2696 : 	        if ( (FoundInPTRNEW-BB) % GainOrder == 0 ) {
; 2697 : 		ThunderwithL = (unsigned long)(FoundInPTRNEW-BB) / GainOrder;
; 2698 : 		putc(*((unsigned char *)&ThunderwithL+0), fp_outLINE);
; 2699 : 		putc(*((unsigned char *)&ThunderwithL+1), fp_outLINE);
; 2700 : 		putc(*((unsigned char *)&ThunderwithL+2), fp_outLINE);
; 2701 : 		// Notice that only 3 lower Little-Endian bytes are dumped!
; 2702 : 		break;
; 2703 : 		}
; 2704 : 		FoundInPTR = FoundInPTRNEW+1;
; 2705 : 	}
; 2706 : }
; 2707 : goto LAstLine;
; 2708 : NextNextInLine:
; 2709 : // Binary-Search:
; 2710 : //Creating googlebooks-eng-us-all-4gram-20090715-graffith_K_distinct.txt.SS ...
; 2711 : //Building-Blocks_DUMPER .SS dumping time: 1923 clocks
; 2712 : //Building-Blocks_DUMPER total time: 132563 clocks
; 2713 : for (ThunderwithR=0; ThunderwithR<Strnglen/GainOrder; ThunderwithR++)

  02646	8b 5c 24 24	 mov	 ebx, DWORD PTR _fp_outLINE$[esp+376]
$LAstLine$6223:

; 2737 : 		// Notice that only 3 lower Little-Endian bytes are dumped!
; 2738 : 		}
; 2739 : }
; 2740 : 
; 2741 : /* Binary search from 'LOGerINFINITY_COUNTRY_CITY.php':
; 2742 : 			$WRDpresent = 0;
; 2743 :             $LeftPoint = 0;
; 2744 :             $RightPoint = $linecntrC - 1;
; 2745 : 			$q = 0;
; 2746 : 	do {
; 2747 : 			if ($RightPoint - $LeftPoint <= 1) {
; 2748 : 				$SplitIsSTRINGlefta = (float) $array77a[$LeftPoint];
; 2749 : 				$SplitIsSTRINGleftb = (float) $array77b[$LeftPoint];
; 2750 : 				$SplitIsSTRINGrighta = (float) $array77a[$RightPoint];
; 2751 : 				$SplitIsSTRINGrightb = (float) $array77b[$RightPoint];
; 2752 : 				if ($long >= $SplitIsSTRINGlefta && $long <= $SplitIsSTRINGleftb) { $WRDpresent = 1; $q = $LeftPoint; break; }
; 2753 : 				if ($long >= $SplitIsSTRINGrighta && $long <= $SplitIsSTRINGrightb) { $WRDpresent = 1; $q = $RightPoint; break; } 	
; 2754 : 				break; }
; 2755 : 	        $q = ($LeftPoint + $RightPoint) >> 1;
; 2756 : 			$SplitIsSTRINGa = (float) $array77a[$q];
; 2757 : 			$SplitIsSTRINGb = (float) $array77b[$q];
; 2758 : 		   	if (($long >= $SplitIsSTRINGa) && ($long <= $SplitIsSTRINGb)) { $WRDpresent = 1; break; }
; 2759 : 			if ($long > $SplitIsSTRINGb) { $LeftPoint = $q; }
; 2760 : 			if ($long < $SplitIsSTRINGa) { $RightPoint = $q; }
; 2761 : 	} while (1 == 1);
; 2762 : */
; 2763 : LAstLine:
; 2764 : 
; 2765 : // ] Triads dumping
; 2766 : 
; 2767 : // [ Literals dumping
; 2768 : ThunderwithL=Strnglen % GainOrder;

  0264a	8b c1		 mov	 eax, ecx
  0264c	99		 cdq
  0264d	f7 fe		 idiv	 esi
  0264f	8b f2		 mov	 esi, edx

; 2769 : while (ThunderwithL) {

  02651	85 f6		 test	 esi, esi
  02653	74 22		 je	 SHORT $LN1@main
  02655	8b 7c 24 1c	 mov	 edi, DWORD PTR _Strng$[esp+376]
  02659	eb 09		 jmp	 SHORT $LN2@main
  0265b	eb 03 8d 49 00	 npad	 5
$LL178@main:
  02660	8b 4c 24 10	 mov	 ecx, DWORD PTR _Strnglen$[esp+376]
$LN2@main:

; 2770 : putc(*( (unsigned char *)Strng+Strnglen-ThunderwithL ), fp_outLINE);

  02664	2b ce		 sub	 ecx, esi
  02666	0f b6 14 39	 movzx	 edx, BYTE PTR [ecx+edi]
  0266a	53		 push	 ebx
  0266b	52		 push	 edx
  0266c	e8 00 00 00 00	 call	 _putc
  02671	83 c4 08	 add	 esp, 8

; 2771 : ThunderwithL--;

  02674	4e		 dec	 esi
  02675	75 e9		 jne	 SHORT $LL178@main
$LN1@main:

; 2772 : }
; 2773 : // ] Literals dumping
; 2774 : 
; 2775 : // ] SS file creating:
; 2776 : 
; 2777 : clocks2 = clock();

  02677	e8 00 00 00 00	 call	 _clock
  0267c	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax

; 2778 : 
; 2779 : TotalRoughSearchTime = clocks2 - clocks3; TotalRoughSearchTime++;

  02681	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  02687	89 44 24 30	 mov	 DWORD PTR tv1795[esp+376], eax
  0268b	db 44 24 30	 fild	 DWORD PTR tv1795[esp+376]
  0268f	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  02695	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 2780 : printf( "\nBuilding-Blocks_DUMPER .SS dumping time: %lu clocks\n", (long)(TotalRoughSearchTime));

  0269b	e8 00 00 00 00	 call	 __ftol2_sse
  026a0	50		 push	 eax
  026a1	68 00 00 00 00	 push	 OFFSET $SG6258
  026a6	e8 00 00 00 00	 call	 _printf

; 2781 : 
; 2782 : TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  026ab	a1 00 00 00 00	 mov	 eax, DWORD PTR _clocks2
  026b0	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  026b6	89 44 24 38	 mov	 DWORD PTR tv1788[esp+384], eax
  026ba	db 44 24 38	 fild	 DWORD PTR tv1788[esp+384]
  026be	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  026c4	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 2783 : printf( "Building-Blocks_DUMPER total time: %lu clocks\n", (long)(TotalRoughSearchTime));

  026ca	e8 00 00 00 00	 call	 __ftol2_sse
  026cf	50		 push	 eax
  026d0	68 00 00 00 00	 push	 OFFSET $SG6260
  026d5	e8 00 00 00 00	 call	 _printf

; 2784 : 
; 2785 : 
; 2786 : /*
; 2787 : printf( "Searching for Pattern(%dbytes) into String(%dbytes) at each position ...\n", Patternlen, Strnglen);
; 2788 :       if( ( fp_inLINE = fopen( &BuildingBlocksBox[0], "wb+" ) ) == NULL )
; 2789 :       { printf( "Building-Blocks_DUMPER: Can't create file %s\n", &BuildingBlocksBox[0] ); return( 1 ); }
; 2790 : printf( "Writing Building-Blocks with corresponding hits(overlapped) to %s ...\n", &BuildingBlocksBox[0]);
; 2791 : 
; 2792 : Railgunhits=0;
; 2793 : clocks3 = clock();
; 2794 :     for ( i=0;i<=Strnglen-Patternlen; i++)
; 2795 :     {
; 2796 : //	printf( "Searching for ");
; 2797 : //	    for ( j=0;j<Patternlen; j++)
; 2798 : //	    printf( "%s", _ui64toaKAZEzerocomma (Strng[0+i+j], llTOaDigits, 16) +(26-2));
; 2799 : //	printf( " ...\n");
; 2800 : 	printf( "Remain: %lu            \r", Strnglen-Patternlen - i + 1);
; 2801 : 	FoundInPTR = Railgun_totalhits(&Strng[0], &Strng[0+i], Strnglen, Patternlen);
; 2802 : 	    for ( j=0;j<Patternlen; j++)
; 2803 : 	    fprintf(fp_inLINE, "%s", _ui64toaKAZEzerocomma (Strng[0+i+j], llTOaDigits, 16) +(26-2));
; 2804 : 	    fprintf(fp_inLINE, " %d\n", Railgunhits);
; 2805 : 	Railgunhits=0;
; 2806 :     }
; 2807 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;
; 2808 : //printf( "Railgun_hits/Railgun_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);
; 2809 : printf( "\nBuilding-Blocks_DUMPER total time for creating %s: %lu clocks\n", &BuildingBlocksBox[0], (long)(TotalRoughSearchTime));
; 2810 : */
; 2811 : 
; 2812 : 
; 2813 : free(BB);

  026da	8b 4c 24 38	 mov	 ecx, DWORD PTR _BB$[esp+392]
  026de	51		 push	 ecx
  026df	e8 00 00 00 00	 call	 _free

; 2814 : free(bufEXTENSION);

  026e4	8b 54 24 2c	 mov	 edx, DWORD PTR _bufEXTENSION$[esp+396]
  026e8	52		 push	 edx
  026e9	e8 00 00 00 00	 call	 _free

; 2815 : free(Strng);

  026ee	8b 44 24 34	 mov	 eax, DWORD PTR _Strng$[esp+400]
  026f2	50		 push	 eax
  026f3	e8 00 00 00 00	 call	 _free
  026f8	83 c4 1c	 add	 esp, 28			; 0000001cH

; 2816 : return(0);

  026fb	33 c0		 xor	 eax, eax
$LN202@main:

; 2817 :   }

  026fd	8b 8c 24 74 01
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+376]
  02704	5f		 pop	 edi
  02705	5b		 pop	 ebx
  02706	5d		 pop	 ebp
  02707	5e		 pop	 esi
  02708	33 cc		 xor	 ecx, esp
  0270a	e8 00 00 00 00	 call	 @__security_check_cookie@4
  0270f	81 c4 68 01 00
	00		 add	 esp, 360		; 00000168H
  02715	c3		 ret	 0
_main	ENDP
_TEXT	ENDS
END
