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

	TITLE	D:\_KAZE_new-stuff\_KAZE_Simplicius_Simplicissimus_Septupleton_r1+++_strstr_SHORT-SHOWDOWN_r7\strstr_SHORT-SHOWDOWN.c
	.686P
	.XMM
	include listing.inc
	.model	flat

INCLUDELIB LIBCMT
INCLUDELIB OLDNAMES

PUBLIC	_TotalRoughSearchTime
PUBLIC	_Railgunhits
_DATA	SEGMENT
COMM	_clocks2:DWORD
COMM	_clocks4:DWORD
COMM	_clocks1:DWORD
COMM	_clocks3:DWORD
_DATA	ENDS
_BSS	SEGMENT
_TotalRoughSearchTime DQ 01H DUP (?)
_Railgunhits DD	01H DUP (?)
_BSS	ENDS
_DATA	SEGMENT
$SG6278	DB	'an', 00H, 00H
$SG6279	DB	'an', 00H, 00H
$SG6280	DB	'to', 00H, 00H
$SG6281	DB	'to', 00H, 00H
$SG6282	DB	'TDK', 00H, 00H
	ORG $+3
$SG6283	DB	'TDK', 00H, 00H
	ORG $+3
$SG6284	DB	'the', 00H, 00H
	ORG $+3
$SG6285	DB	'the', 00H, 00H
	ORG $+3
$SG6286	DB	'fast', 00H, 00H
	ORG $+2
$SG6287	DB	'fast', 00H, 00H
	ORG $+2
$SG6288	DB	'easy', 00H, 00H
	ORG $+2
$SG6289	DB	'easy', 00H, 00H
	ORG $+2
$SG6290	DB	'grmbl', 00H, 00H
	ORG $+1
$SG6291	DB	'grmbl', 00H, 00H
	ORG $+1
$SG6292	DB	'email', 00H, 00H
	ORG $+1
$SG6293	DB	'email', 00H, 00H
	ORG $+1
$SG6294	DB	'pasting', 00H, 00H
	ORG $+3
$SG6295	DB	'pasting', 00H, 00H
	ORG $+3
$SG6296	DB	'amazing', 00H, 00H
	ORG $+3
$SG6297	DB	'amazing', 00H, 00H
	ORG $+3
$SG6298	DB	'underdog', 00H, 00H
	ORG $+2
$SG6299	DB	'underdog', 00H, 00H
	ORG $+2
$SG6300	DB	'superdog', 00H, 00H
	ORG $+2
$SG6301	DB	'superdog', 00H, 00H
	ORG $+2
$SG6302	DB	'participants', 00H, 00H
	ORG $+2
$SG6303	DB	'participants', 00H, 00H
	ORG $+2
$SG6304	DB	'skillessness', 00H, 00H
	ORG $+2
$SG6305	DB	'skillessness', 00H, 00H
	ORG $+2
$SG6306	DB	'I should have known', 00H, 00H
	ORG $+3
$SG6307	DB	'I should have known', 00H, 00H
	ORG $+3
$SG6308	DB	'human consciousness', 00H, 00H
	ORG $+3
$SG6309	DB	'human consciousness', 00H, 00H
	ORG $+3
$SG6311	DB	'fast', 00H, 00H
	ORG $+2
$SG6312	DB	'fast', 00H, 00H
	ORG $+2
$SG6313	DB	'from', 00H, 00H
	ORG $+2
$SG6314	DB	'from', 00H, 00H
	ORG $+2
$SG6315	DB	'SR71', 00H, 00H
	ORG $+2
$SG6316	DB	'SR71', 00H, 00H
	ORG $+2
$SG6317	DB	'SONY', 00H, 00H
	ORG $+2
$SG6318	DB	'SONY', 00H, 00H
	ORG $+2
$SG6319	DB	'Lexx', 00H, 00H
	ORG $+2
$SG6320	DB	'Lexx', 00H, 00H
	ORG $+2
$SG6321	DB	'Rabea', 00H, 00H
	ORG $+1
$SG6322	DB	'Rabea', 00H, 00H
	ORG $+1
$SG6323	DB	'makes', 00H, 00H
	ORG $+1
$SG6324	DB	'makes', 00H, 00H
	ORG $+1
$SG6325	DB	'punny', 00H, 00H
	ORG $+1
$SG6326	DB	'punny', 00H, 00H
	ORG $+1
$SG6327	DB	'funny', 00H, 00H
	ORG $+1
$SG6328	DB	'funny', 00H, 00H
	ORG $+1
$SG6329	DB	'Orion', 00H, 00H
	ORG $+1
$SG6330	DB	'Orion', 00H, 00H
	ORG $+1
$SG6331	DB	'lemon', 00H, 00H
	ORG $+1
$SG6332	DB	'lemon', 00H, 00H
	ORG $+1
$SG6333	DB	'Hi-Fi', 00H, 00H
	ORG $+1
$SG6334	DB	'Hi-Fi', 00H, 00H
	ORG $+1
$SG6335	DB	'Tesla', 00H, 00H
	ORG $+1
$SG6336	DB	'Tesla', 00H, 00H
	ORG $+1
$SG6337	DB	'Apache', 00H, 00H
$SG6338	DB	'Apache', 00H, 00H
$SG6339	DB	'monkey', 00H, 00H
$SG6340	DB	'monkey', 00H, 00H
$SG6341	DB	'ramjet', 00H, 00H
$SG6342	DB	'ramjet', 00H, 00H
$SG6343	DB	'fallen', 00H, 00H
$SG6344	DB	'fallen', 00H, 00H
$SG6345	DB	'Albert', 00H, 00H
$SG6346	DB	'Albert', 00H, 00H
$SG6347	DB	'Toshiba', 00H, 00H
	ORG $+3
$SG6348	DB	'Toshiba', 00H, 00H
	ORG $+3
$SG6349	DB	'grammar', 00H, 00H
	ORG $+3
$SG6350	DB	'grammar', 00H, 00H
	ORG $+3
$SG6351	DB	'pharaoh', 00H, 00H
	ORG $+3
$SG6352	DB	'pharaoh', 00H, 00H
	ORG $+3
$SG6353	DB	'decades', 00H, 00H
	ORG $+3
$SG6354	DB	'decades', 00H, 00H
	ORG $+3
$SG6355	DB	'#define', 00H, 00H
	ORG $+3
$SG6356	DB	'#define', 00H, 00H
	ORG $+3
$SG6357	DB	'Delerium', 00H, 00H
	ORG $+2
$SG6358	DB	'Delerium', 00H, 00H
	ORG $+2
$SG6359	DB	'numberly', 00H, 00H
	ORG $+2
$SG6360	DB	'numberly', 00H, 00H
	ORG $+2
$SG6361	DB	'stellify', 00H, 00H
	ORG $+2
$SG6362	DB	'stellify', 00H, 00H
	ORG $+2
$SG6363	DB	'elephant', 00H, 00H
	ORG $+2
$SG6364	DB	'elephant', 00H, 00H
	ORG $+2
$SG6365	DB	'Layalina', 00H, 00H
	ORG $+2
$SG6366	DB	'Layalina', 00H, 00H
	ORG $+2
$SG6367	DB	'Fibonacci', 00H, 00H
	ORG $+1
$SG6368	DB	'Fibonacci', 00H, 00H
	ORG $+1
$SG6369	DB	'profanism', 00H, 00H
	ORG $+1
$SG6370	DB	'profanism', 00H, 00H
	ORG $+1
$SG6371	DB	'butterfly', 00H, 00H
	ORG $+1
$SG6372	DB	'butterfly', 00H, 00H
	ORG $+1
$SG6373	DB	'Beth Ditto', 00H, 00H
$SG6374	DB	'Beth Ditto', 00H, 00H
$SG6375	DB	'Got Nuffin', 00H, 00H
$SG6376	DB	'Got Nuffin', 00H, 00H
$SG6377	DB	'fly fly fly', 00H, 00H
	ORG $+3
$SG6378	DB	'fly fly fly', 00H, 00H
	ORG $+3
$SG6379	DB	'quintillion', 00H, 00H
	ORG $+3
$SG6380	DB	'quintillion', 00H, 00H
	ORG $+3
$SG6381	DB	'Sick Of Love', 00H, 00H
	ORG $+2
$SG6382	DB	'Sick Of Love', 00H, 00H
	ORG $+2
$SG6383	DB	'Love Lockdown', 00H, 00H
	ORG $+1
$SG6384	DB	'Love Lockdown', 00H, 00H
	ORG $+1
$SG6385	DB	'Dannii Minogue', 00H, 00H
$SG6386	DB	'Dannii Minogue', 00H, 00H
$SG6387	DB	'299,792,458 m/s', 00H, 00H
	ORG $+3
$SG6388	DB	'299,792,458 m/s', 00H, 00H
	ORG $+3
$SG6389	DB	'Extreme-Fidelity', 00H, 00H
	ORG $+2
$SG6390	DB	'Extreme-Fidelity', 00H, 00H
	ORG $+2
$SG6391	DB	'I should have known', 00H, 00H
	ORG $+3
$SG6392	DB	'I should have known', 00H, 00H
	ORG $+3
$SG6393	DB	'human consciousness', 00H, 00H
	ORG $+3
$SG6394	DB	'human consciousness', 00H, 00H
	ORG $+3
$SG6395	DB	'Truth''s your only fear', 00H, 00H
$SG6396	DB	'Truth''s your only fear', 00H, 00H
$SG6397	DB	'Never thought I''d do it', 00H, 00H
	ORG $+3
$SG6398	DB	'Never thought I''d do it', 00H, 00H
	ORG $+3
$SG6399	DB	'innocence over fading fast', 00H, 00H
$SG6400	DB	'innocence over fading fast', 00H, 00H
$SG6401	DB	'I hit the ground runnin'' free', 00H, 00H
	ORG $+1
$SG6402	DB	'I hit the ground runnin'' free', 00H, 00H
	ORG $+1
$SG6403	DB	'I colour out the darkest clouds', 00H, 00H
	ORG $+3
$SG6404	DB	'I colour out the darkest clouds', 00H, 00H
	ORG $+3
$SG6405	DB	'But he''s looking right through me', 00H, 00H
	ORG $+1
$SG6406	DB	'But he''s looking right through me', 00H, 00H
	ORG $+1
$SG6407	DB	'I''m living in an age that calls darkness light', 00H, 00H
$SG6408	DB	'I''m living in an age that calls darkness light', 00H, 00H
$SG6409	DB	'Following the wanderings of a dream - a dream that keeps'
	DB	' my soul alive', 00H, 00H
$SG6410	DB	'Following the wanderings of a dream - a dream that keeps'
	DB	' my soul alive', 00H, 00H
$SG6411	DB	'I notice what matters and I got nothing to lose but dark'
	DB	'ness and shadows', 00H, 00H
	ORG $+2
$SG6422	DB	'strstr_SHORT-SHOWDOWN: Needed memory allocation denied!', 0aH
	DB	00H
	ORG $+3
$SG6412	DB	'I notice what matters and I got nothing to lose but dark'
	DB	'ness and shadows', 00H, 00H
	ORG $+2
$SG6425	DB	'rb', 00H
	ORG $+1
$SG6413	DB	'Then, singing among the savage branches, it impales itse'
	DB	'lf upon the longest, sharpest spine. And, dying, it rises abo'
	DB	've its own agony to outcarol the lark and the nightingale.', 00H
	DB	00H
	ORG $+3
$SG6426	DB	'OSHO.TXT', 00H
	ORG $+3
$SG6414	DB	'Then, singing among the savage branches, it impales itse'
	DB	'lf upon the longest, sharpest spine. And, dying, it rises abo'
	DB	've its own agony to outcarol the lark and the nightingale.', 00H
	DB	00H
	ORG $+3
$SG6417	DB	'strstr_SHORT-SHOWDOWN, revision 7, written by Kaze.', 0aH
	DB	00H
	ORG $+3
$SG6427	DB	'strstr_SHORT-SHOWDOWN: Can''t open ''OSHO.TXT'' file.', 0aH
	DB	00H
$SG6418	DB	'Note: There is something very inconsistent even wrong wi'
	DB	'th all timings, still can''t figure out the reason!', 0aH, 00H
$SG6429	DB	'Input Pattern(up to 19+2000 chars): ', 00H
	ORG $+3
$SG6441	DB	'TW_hits/TW_clocks: %lu/%lu', 0aH, 00H
$SG6436	DB	0aH, 'Doing Search for Pattern(%dbytes) into String(%dbyt'
	DB	'es) as-one-line ...', 0aH, 00H
	ORG $+3
$SG6443	DB	'TW performance: %luKB/clock', 0aH, 00H
	ORG $+3
$SG6449	DB	'BM_HORSPOOL_hits/BM_HORSPOOL_clocks: %lu/%lu', 0aH, 00H
	ORG $+2
$SG6459	DB	'Railgun performance: %luKB/clock', 0aH, 00H
	ORG $+2
$SG6444	DB	0aH, 'Doing Search for Pattern(%dbytes) into String(%dbyt'
	DB	'es) as-one-line ...', 0aH, 00H
	ORG $+3
$SG6451	DB	'BM_HORSPOOL performance: %luKB/clock', 0aH, 00H
	ORG $+2
$SG6477	DB	'Railgun_Quadruplet_7 performance: %luKB/clock', 0aH, 00H
	ORG $+1
$SG6515	DB	'ReallyTraversed: %s bytes', 0aH, 00H
	ORG $+1
$SG6452	DB	0aH, 'Doing Search for Pattern(%dbytes) into String(%dbyt'
	DB	'es) as-one-line ...', 0aH, 00H
	ORG $+3
$SG6457	DB	'Railgun_hits/Railgun_clocks: %lu/%lu', 0aH, 00H
	ORG $+2
$SG6552	DB	'ReallyTraversed: %s bytes', 0aH, 00H
	ORG $+1
$SG6460	DB	0aH, 'Doing Search for Pattern(%dbytes) into String(%dbyt'
	DB	'es) as-one-line ...', 0aH, 00H
	ORG $+3
$SG6466	DB	'Railgun_6pp_hits/Railgun_6pp_clocks: %lu/%lu', 0aH, 00H
	ORG $+2
$SG6577	DB	'TotalRoughSearchTime: %s clocks', 0aH, 00H
	ORG $+3
$SG6461	DB	'WARNING! The next line works with BMH only for pattern 4'
	DB	'[+] long, otherwise (for 2 and 3) other searcher takes over!', 0aH
	DB	00H
	ORG $+2
$SG6468	DB	'Railgun_6pp performance: %luKB/clock', 0aH, 00H
	ORG $+2
$SG6469	DB	0aH, 'Doing Search for Pattern(%dbytes) into String(%dbyt'
	DB	'es) as-one-line ...', 0aH, 00H
	ORG $+3
$SG6578	DB	'ReallyTraversed: %s bytes', 0aH, 00H
	ORG $+1
$SG6470	DB	'WARNING! The next line works with BMH only for pattern 4'
	DB	'[+] long, otherwise (for 2 and 3) other searcher takes over!', 0aH
	DB	00H
	ORG $+2
$SG6475	DB	'Railgun_Quadruplet_7_hits/Railgun_Quadruplet_7_clocks: %'
	DB	'lu/%lu', 0aH, 00H
$SG6478	DB	0aH, 'Note: Executing the next two tests 256 times i.e. t'
	DB	'he search is for 256x8x2 patterns!', 0aH, 00H
$SG6479	DB	0aH, 'Doing Search for 8x2 Patterns into String(%dbytes) '
	DB	'as-one-line ... Not-Counting-Hits-Just-Returns-First-One', 0aH
	DB	00H
	ORG $+2
$SG6495	DB	'Found (''%s'') at %d position, Railgun_Quadruplet_6pp pe'
	DB	'rformance: %luKB/clock', 0aH, 00H
	ORG $+2
$SG6498	DB	'Found (''%s'') at %d position, Railgun_Quadruplet_6pp pe'
	DB	'rformance: %luKB/clock', 0aH, 00H
	ORG $+2
$SG6508	DB	'Found (''%s'') at %d position, Railgun_Quadruplet_6pp pe'
	DB	'rformance: %luKB/clock', 0aH, 00H
	ORG $+2
$SG6511	DB	'Found (''%s'') at %d position, Railgun_Quadruplet_6pp pe'
	DB	'rformance: %luKB/clock', 0aH, 00H
	ORG $+2
$SG6514	DB	'Railgun_Quadruplet_6pp 8x2 i.e. average performance: %lu'
	DB	'KB/clock', 0aH, 00H
	ORG $+2
$SG6601	DB	'Railgun_Quadruplet_7 52 i.e. average performance: %luKB/'
	DB	'clock', 0aH, 00H
	ORG $+1
$SG6602	DB	'TotalRoughSearchTime: %s clocks', 0aH, 00H
	ORG $+3
$SG6516	DB	0aH, 'Doing Search for 8x2 Patterns into String(%dbytes) '
	DB	'as-one-line ... Not-Counting-Hits-Just-Returns-First-One', 0aH
	DB	00H
	ORG $+2
$SG6532	DB	'Found (''%s'') at %d position, Railgun_Quadruplet_7 perf'
	DB	'ormance: %luKB/clock', 0aH, 00H
$SG6603	DB	'ReallyTraversed: %s bytes', 0aH, 00H
	ORG $+1
$SG6535	DB	'Found (''%s'') at %d position, Railgun_Quadruplet_7 perf'
	DB	'ormance: %luKB/clock', 0aH, 00H
$SG6672	DB	'strstr_Microsoft performance: %luKB/clock', 0aH, 00H
	ORG $+1
$SG6545	DB	'Found (''%s'') at %d position, Railgun_Quadruplet_7 perf'
	DB	'ormance: %luKB/clock', 0aH, 00H
$SG6711	DB	'Railgun performance: %luKB/clock', 0aH, 00H
	ORG $+2
$SG6548	DB	'Found (''%s'') at %d position, Railgun_Quadruplet_7 perf'
	DB	'ormance: %luKB/clock', 0aH, 00H
$SG6729	DB	'Railgun_Quadruplet_hits/Railgun_Quadruplet_clocks: %lu/%'
	DB	'lu', 0aH, 00H
$SG6551	DB	'Railgun_Quadruplet_7 8x2 i.e. average performance: %luKB'
	DB	'/clock', 0aH, 00H
$SG6553	DB	0aH, 'Note: Executing the next two tests 256 times i.e. t'
	DB	'he search is for 256x52 patterns, all utilizing BMH!', 0aH, 00H
	ORG $+2
$SG6613	DB	'Found (''%s'') %d time(s), BM_HORSPOOL performance: %luK'
	DB	'B/clock', 0aH, 00H
	ORG $+1
$SG6670	DB	'strstr_Microsoft_hits/strstr_Microsoft_clocks: %lu/%lu', 0aH
	DB	00H
$SG6751	DB	'Railgun_Quadruplet_6pp performance: %luKB/clock', 0aH, 00H
	ORG $+3
$SG6554	DB	0aH, 'Doing Search for 52 Patterns into String(%dbytes) a'
	DB	's-one-line ... Not-Counting-Hits-Just-Returns-First-One', 0aH
	DB	00H
	ORG $+3
$SG6570	DB	'Found (''%s'') at %d position, Railgun_Quadruplet_6pp pe'
	DB	'rformance: %luKB/clock', 0aH, 00H
	ORG $+2
$SG6573	DB	'Found (''%s'') at %d position, Railgun_Quadruplet_6pp pe'
	DB	'rformance: %luKB/clock', 0aH, 00H
	ORG $+2
$SG6576	DB	'Railgun_Quadruplet_6pp 52 i.e. average performance: %luK'
	DB	'B/clock', 0aH, 00H
	ORG $+3
$SG6616	DB	'Found (''%s'') %d time(s), BM_HORSPOOL performance: %luK'
	DB	'B/clock', 0aH, 00H
	ORG $+1
$SG6771	DB	'KarpRabinKaze_BOOSTED performance: %luKB/clock', 0aH, 00H
$SG6789	DB	'KarpRabinKaze_hits/KarpRabinKaze_clocks: %lu/%lu', 0aH, 00H
	ORG $+2
$SG6579	DB	0aH, 'Doing Search for 52 Patterns into String(%dbytes) a'
	DB	's-one-line ... Not-Counting-Hits-Just-Returns-First-One', 0aH
	DB	00H
	ORG $+3
$SG6595	DB	'Found (''%s'') at %d position, Railgun_Quadruplet_7 perf'
	DB	'ormance: %luKB/clock', 0aH, 00H
$SG6808	DB	'Karp_Rabin_hits/Karp_Rabin_clocks: %lu/%lu', 0aH, 00H
$SG6598	DB	'Found (''%s'') at %d position, Railgun_Quadruplet_7 perf'
	DB	'ormance: %luKB/clock', 0aH, 00H
$SG6827	DB	'Brute_Force_Dummy_hits/Brute_Force_Dummy_clocks: %lu/%lu'
	DB	0aH, 00H
	ORG $+2
$SG6604	DB	0aH, 'Doing Search for 8x2 Patterns into String(%dbytes) '
	DB	'as-one-line ...', 0aH, 00H
	ORG $+3
$SG6619	DB	'BM_HORSPOOL 8x2 i.e. average performance: %luKB/clock', 0aH
	DB	00H
	ORG $+1
$SG6620	DB	0aH, 'Doing Search for 8x2 Patterns into String(%dbytes) '
	DB	'as-one-line ...', 0aH, 00H
	ORG $+3
$SG6629	DB	'Found (''%s'') %d time(s), Railgun_6pp performance: %luK'
	DB	'B/clock', 0aH, 00H
	ORG $+1
$SG6632	DB	'Found (''%s'') %d time(s), Railgun_6pp performance: %luK'
	DB	'B/clock', 0aH, 00H
	ORG $+1
$SG6635	DB	'Railgun_6pp 8x2 i.e. average performance: %luKB/clock', 0aH
	DB	00H
	ORG $+1
$SG6636	DB	0aH, 'Doing Search for 8x2 Patterns into String(%dbytes) '
	DB	'as-one-line ...', 0aH, 00H
	ORG $+3
$SG6645	DB	'Found (''%s'') %d time(s), Railgun_Quadruplet_7 performa'
	DB	'nce: %luKB/clock', 0aH, 00H
$SG6648	DB	'Found (''%s'') %d time(s), Railgun_Quadruplet_7 performa'
	DB	'nce: %luKB/clock', 0aH, 00H
$SG6651	DB	'Railgun_Quadruplet_7 8x2 i.e. average performance: %luKB'
	DB	'/clock', 0aH, 00H
$SG6653	DB	0aH, 'Doing Search for Pattern(%dbytes) into String(%dbyt'
	DB	'es) line-by-line ...', 0aH, 00H
	ORG $+2
$SG6668	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6673	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
	ORG $+2
$SG6687	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6791	DB	'KarpRabinKaze performance: %luKB/clock', 0aH, 00H
$SG6829	DB	'Brute_Force_Dummy performance: %luKB/clock', 0aH, 00H
$SG6689	DB	'strstr_GNU_C_Library_hits/strstr_GNU_C_Library_clocks: %'
	DB	'lu/%lu', 0aH, 00H
$SG6691	DB	'strstr_GNU_C_Library performance: %luKB/clock', 0aH, 00H
	ORG $+1
$SG6692	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
	ORG $+2
$SG6707	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6709	DB	'Railgun_hits/Railgun_clocks: %lu/%lu', 0aH, 00H
	ORG $+2
$SG6712	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
	ORG $+2
$SG6727	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6731	DB	'Railgun_Quadruplet performance: %luKB/clock', 0aH, 00H
	ORG $+3
$SG6732	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
	ORG $+2
$SG6747	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6749	DB	'Railgun_Quadruplet_6pp_hits/Railgun_Quadruplet_6pp_clock'
	DB	's: %lu/%lu', 0aH, 00H
$SG6752	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
	ORG $+2
$SG6767	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6867	DB	'Boyer_Moore_Horspool_Kaze performance: %luKB/clock', 0aH
	DB	00H
$SG6769	DB	'KarpRabinKaze_BOOSTED_hits/KarpRabinKaze_BOOSTED_clocks:'
	DB	' %lu/%lu', 0aH, 00H
	ORG $+2
$SG6772	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
	ORG $+2
$SG6787	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6792	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
	ORG $+2
$SG6806	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6810	DB	'Karp_Rabin performance: %luKB/clock', 0aH, 00H
	ORG $+3
$SG6811	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
	ORG $+2
$SG6825	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6830	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
	ORG $+2
$SG6844	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6869	DB	0aH, 'DUMBO 8x2 ...', 0aH, 00H
$SG6895	DB	'strstr_Microsoft performance: %luKB/clock', 0aH, 00H
	ORG $+1
$SG6846	DB	'Boyer-Moore-Horspool_hits/Boyer-Moore-Horspool_clocks: %'
	DB	'lu/%lu', 0aH, 00H
$SG6848	DB	'Boyer-Moore-Horspool performance: %luKB/clock', 0aH, 00H
	ORG $+1
$SG6849	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
	ORG $+2
$SG6863	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6865	DB	'Boyer_Moore_Horspool_Kaze_hits/Boyer_Moore_Horspool_Kaze'
	DB	'_clocks: %lu/%lu', 0aH, 00H
	ORG $+2
$SG6868	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
	ORG $+2
$SG6891	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6893	DB	'strstr_Microsoft_hits/strstr_Microsoft_clocks: %lu/%lu', 0aH
	DB	00H
$SG6934	DB	'Railgun performance: %luKB/clock', 0aH, 00H
	ORG $+2
$SG6876	DB	0aH, 'Searching for Pattern(''%s'',%dbytes) into String(%'
	DB	'dbytes) line-by-line ...', 0aH, 0aH, 00H
	ORG $+3
$SG6896	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
	ORG $+2
$SG6910	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6912	DB	'strstr_GNU_C_Library_hits/strstr_GNU_C_Library_clocks: %'
	DB	'lu/%lu', 0aH, 00H
$SG6914	DB	'strstr_GNU_C_Library performance: %luKB/clock', 0aH, 00H
	ORG $+1
$SG6915	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
	ORG $+2
$SG6930	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6932	DB	'Railgun_hits/Railgun_clocks: %lu/%lu', 0aH, 00H
	ORG $+2
$SG6935	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
	ORG $+2
$SG6950	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6952	DB	'Railgun_Quadruplet_hits/Railgun_Quadruplet_clocks: %lu/%'
	DB	'lu', 0aH, 00H
$SG6954	DB	'Railgun_Quadruplet performance: %luKB/clock', 0aH, 00H
	ORG $+3
$SG6955	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
	ORG $+2
$SG6970	DB	'LinesEncountered: %lu', 0aH, 00H
	ORG $+1
$SG6974	DB	'Railgun_Quadruplet_6pp performance: %luKB/clock', 0aH, 00H
	ORG $+3
$SG6972	DB	'Railgun_Quadruplet_6pp_hits/Railgun_Quadruplet_6pp_clock'
	DB	's: %lu/%lu', 0aH, 00H
$SG6975	DB	'StrnglenTRAVERSED: %lu bytes', 0aH, 00H
_DATA	ENDS
PUBLIC	_x$GSCopy$
PUBLIC	__$ArrayPad$
PUBLIC	_HORSPOOL
EXTRN	___security_cookie:DWORD
EXTRN	@__security_check_cookie@4:PROC
; Function compile flags: /Ogtpy
; File d:\_kaze_new-stuff\_kaze_simplicius_simplicissimus_septupleton_r1+++_strstr_short-showdown_r7\strstr_short-showdown.c
_TEXT	SEGMENT
_lastch$ = -1041					; size = 1
_x$GSCopy$ = -1040					; size = 4
$T7001 = -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

; 1946 :    {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 e4 f8	 and	 esp, -8			; fffffff8H
  00006	81 ec 14 04 00
	00		 sub	 esp, 1044		; 00000414H
  0000c	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00011	33 c4		 xor	 eax, esp
  00013	89 84 24 10 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1044], eax

; 1947 :     long i;
; 1948 :     int a, j, bm_bc[ASIZE];
; 1949 :     unsigned char ch, lastch;
; 1950 :    
; 1951 :     /* Preprocessing */
; 1952 :     for (a=0; a < ASIZE; a++) bm_bc[a]=m;

  0001a	8b 45 14	 mov	 eax, DWORD PTR _m$[ebp]
  0001d	53		 push	 ebx
  0001e	8b 5d 0c	 mov	 ebx, DWORD PTR _x$[ebp]
  00021	56		 push	 esi
  00022	57		 push	 edi
  00023	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  00028	8d 7c 24 18	 lea	 edi, DWORD PTR _bm_bc$[esp+1056]
  0002c	f3 ab		 rep stosd

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

  0002e	8d 50 ff	 lea	 edx, DWORD PTR [eax-1]
  00031	33 c9		 xor	 ecx, ecx

; 1963 :        i+=bm_bc[ch];

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

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

  0003b	8b f2		 mov	 esi, edx
  0003d	8d 49 00	 npad	 3
$LL7@HORSPOOL:
  00040	0f be 3c 0b	 movsx	 edi, BYTE PTR [ebx+ecx]
  00044	89 74 bc 18	 mov	 DWORD PTR _bm_bc$[esp+edi*4+1056], esi
  00048	41		 inc	 ecx
  00049	4e		 dec	 esi
  0004a	3b ca		 cmp	 ecx, edx
  0004c	7c f2		 jl	 SHORT $LL7@HORSPOOL
$LN5@HORSPOOL:

; 1954 :    
; 1955 :     /* Searching */
; 1956 :     lastch=x[m-1];

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

; 1957 :     i=0;
; 1958 :     while (i <= n-m) {

  00056	8b 4d 10	 mov	 ecx, DWORD PTR _n$[ebp]
  00059	33 ff		 xor	 edi, edi
  0005b	2b c8		 sub	 ecx, eax
  0005d	89 4c 24 14	 mov	 DWORD PTR $T7001[esp+1056], ecx
  00061	78 6e		 js	 SHORT $LN3@HORSPOOL
  00063	8b 75 08	 mov	 esi, DWORD PTR _y$[ebp]
  00066	8d 4c 06 ff	 lea	 ecx, DWORD PTR [esi+eax-1]
$LN4@HORSPOOL:

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

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

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

  00073	8d 48 ff	 lea	 ecx, DWORD PTR [eax-1]
  00076	03 f7		 add	 esi, edi
  00078	8b d3		 mov	 edx, ebx
  0007a	83 f9 04	 cmp	 ecx, 4
  0007d	72 15		 jb	 SHORT $LN22@HORSPOOL
  0007f	90		 npad	 1
$LL14@HORSPOOL:
  00080	8b 1e		 mov	 ebx, DWORD PTR [esi]
  00082	3b 1a		 cmp	 ebx, DWORD PTR [edx]
  00084	75 32		 jne	 SHORT $LN27@HORSPOOL
  00086	83 e9 04	 sub	 ecx, 4
  00089	83 c2 04	 add	 edx, 4
  0008c	83 c6 04	 add	 esi, 4
  0008f	83 f9 04	 cmp	 ecx, 4
  00092	73 ec		 jae	 SHORT $LL14@HORSPOOL
$LN22@HORSPOOL:
  00094	85 c9		 test	 ecx, ecx
  00096	74 51		 je	 SHORT $LN16@HORSPOOL
  00098	8a 1a		 mov	 bl, BYTE PTR [edx]
  0009a	3a 1e		 cmp	 bl, BYTE PTR [esi]
  0009c	75 1a		 jne	 SHORT $LN27@HORSPOOL
  0009e	83 f9 01	 cmp	 ecx, 1
  000a1	76 46		 jbe	 SHORT $LN16@HORSPOOL
  000a3	8a 5a 01	 mov	 bl, BYTE PTR [edx+1]
  000a6	3a 5e 01	 cmp	 bl, BYTE PTR [esi+1]
  000a9	75 0d		 jne	 SHORT $LN27@HORSPOOL
  000ab	83 f9 02	 cmp	 ecx, 2
  000ae	76 39		 jbe	 SHORT $LN16@HORSPOOL
  000b0	8a 4a 02	 mov	 cl, BYTE PTR [edx+2]
  000b3	3a 4e 02	 cmp	 cl, BYTE PTR [esi+2]
  000b6	74 31		 je	 SHORT $LN16@HORSPOOL
$LN27@HORSPOOL:
  000b8	8b 75 08	 mov	 esi, DWORD PTR _y$[ebp]
  000bb	8b 5c 24 10	 mov	 ebx, DWORD PTR _x$GSCopy$[esp+1056]
$LN1@HORSPOOL:

; 1963 :        i+=bm_bc[ch];

  000bf	8d 4c 06 ff	 lea	 ecx, DWORD PTR [esi+eax-1]
  000c3	0f b6 14 39	 movzx	 edx, BYTE PTR [ecx+edi]
  000c7	03 7c 94 18	 add	 edi, DWORD PTR _bm_bc$[esp+edx*4+1056]
  000cb	3b 7c 24 14	 cmp	 edi, DWORD PTR $T7001[esp+1056]
  000cf	7e 99		 jle	 SHORT $LN4@HORSPOOL
$LN3@HORSPOOL:

; 1964 :     }
; 1965 :     return(-1);

  000d1	83 c8 ff	 or	 eax, -1

; 1966 :    }

  000d4	5f		 pop	 edi
  000d5	5e		 pop	 esi
  000d6	5b		 pop	 ebx
  000d7	8b 8c 24 10 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1044]
  000de	33 cc		 xor	 ecx, esp
  000e0	e8 00 00 00 00	 call	 @__security_check_cookie@4
  000e5	8b e5		 mov	 esp, ebp
  000e7	5d		 pop	 ebp
  000e8	c3		 ret	 0
$LN16@HORSPOOL:
  000e9	8b 8c 24 1c 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1056]
  000f0	8b c7		 mov	 eax, edi
  000f2	5f		 pop	 edi
  000f3	5e		 pop	 esi
  000f4	5b		 pop	 ebx
  000f5	33 cc		 xor	 ecx, esp
  000f7	e8 00 00 00 00	 call	 @__security_check_cookie@4
  000fc	8b e5		 mov	 esp, ebp
  000fe	5d		 pop	 ebp
  000ff	c3		 ret	 0
_HORSPOOL ENDP
_TEXT	ENDS
PUBLIC	_x$GSCopy$
PUBLIC	__$ArrayPad$
PUBLIC	_HORSPOOL_hits
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_lastch$ = -1042					; size = 1
_ch$ = -1041						; size = 1
_x$GSCopy$ = -1040					; size = 4
$T7024 = -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_hits PROC

; 1972 :    {

  00100	55		 push	 ebp
  00101	8b ec		 mov	 ebp, esp
  00103	83 e4 f8	 and	 esp, -8			; fffffff8H
  00106	81 ec 14 04 00
	00		 sub	 esp, 1044		; 00000414H
  0010c	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00111	33 c4		 xor	 eax, esp
  00113	89 84 24 10 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1044], eax

; 1973 :     long i;
; 1974 :     int a, j, bm_bc[ASIZE];
; 1975 :     unsigned char ch, lastch;
; 1976 :    
; 1977 :     /* Preprocessing */
; 1978 :     for (a=0; a < ASIZE; a++) bm_bc[a]=m;

  0011a	8b 45 14	 mov	 eax, DWORD PTR _m$[ebp]
  0011d	53		 push	 ebx
  0011e	8b 5d 0c	 mov	 ebx, DWORD PTR _x$[ebp]
  00121	56		 push	 esi
  00122	57		 push	 edi
  00123	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  00128	8d 7c 24 18	 lea	 edi, DWORD PTR _bm_bc$[esp+1056]
  0012c	f3 ab		 rep stosd

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

  0012e	8d 50 ff	 lea	 edx, DWORD PTR [eax-1]
  00131	33 c9		 xor	 ecx, ecx

; 1990 :        i+=bm_bc[ch];

  00133	89 5c 24 10	 mov	 DWORD PTR _x$GSCopy$[esp+1056], ebx
  00137	85 d2		 test	 edx, edx
  00139	7e 13		 jle	 SHORT $LN5@HORSPOOL_h

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

  0013b	8b f2		 mov	 esi, edx
  0013d	8d 49 00	 npad	 3
$LL7@HORSPOOL_h:
  00140	0f be 3c 0b	 movsx	 edi, BYTE PTR [ebx+ecx]
  00144	89 74 bc 18	 mov	 DWORD PTR _bm_bc$[esp+edi*4+1056], esi
  00148	41		 inc	 ecx
  00149	4e		 dec	 esi
  0014a	3b ca		 cmp	 ecx, edx
  0014c	7c f2		 jl	 SHORT $LL7@HORSPOOL_h
$LN5@HORSPOOL_h:

; 1980 :    
; 1981 :     /* Searching */
; 1982 :     lastch=x[m-1];

  0014e	8a 4c 03 ff	 mov	 cl, BYTE PTR [ebx+eax-1]
  00152	88 4c 24 0e	 mov	 BYTE PTR _lastch$[esp+1056], cl

; 1983 :     i=0;
; 1984 :     while (i <= n-m) {

  00156	8b 4d 10	 mov	 ecx, DWORD PTR _n$[ebp]
  00159	33 ff		 xor	 edi, edi
  0015b	2b c8		 sub	 ecx, eax
  0015d	89 4c 24 14	 mov	 DWORD PTR $T7024[esp+1056], ecx
  00161	78 7a		 js	 SHORT $LN27@HORSPOOL_h
  00163	eb 04		 jmp	 SHORT $LN33@HORSPOOL_h
$LL31@HORSPOOL_h:
  00165	8b 5c 24 10	 mov	 ebx, DWORD PTR _x$GSCopy$[esp+1056]
$LN33@HORSPOOL_h:
  00169	8b 75 08	 mov	 esi, DWORD PTR _y$[ebp]

; 1985 :        ch=y[i+m-1];

  0016c	8d 4c 06 ff	 lea	 ecx, DWORD PTR [esi+eax-1]
  00170	8a 0c 39	 mov	 cl, BYTE PTR [ecx+edi]
  00173	88 4c 24 0f	 mov	 BYTE PTR _ch$[esp+1056], cl

; 1986 :        if (ch ==lastch)

  00177	3a 4c 24 0e	 cmp	 cl, BYTE PTR _lastch$[esp+1056]
  0017b	75 51		 jne	 SHORT $LN1@HORSPOOL_h

; 1987 :           //if (memcmp(&y[i],x,m-1) == 0) OUTPUT(i);
; 1988 :           //if (memcmp(&y[i],x,m-1) == 0) return(i);
; 1989 :           if (memcmp(&y[i],x,m-1) == 0) Railgunhits++;

  0017d	8d 48 ff	 lea	 ecx, DWORD PTR [eax-1]
  00180	03 f7		 add	 esi, edi
  00182	8b d3		 mov	 edx, ebx
  00184	83 f9 04	 cmp	 ecx, 4
  00187	72 1b		 jb	 SHORT $LN22@HORSPOOL_h
  00189	8d a4 24 00 00
	00 00		 npad	 7
$LL14@HORSPOOL_h:
  00190	8b 1e		 mov	 ebx, DWORD PTR [esi]
  00192	3b 1a		 cmp	 ebx, DWORD PTR [edx]
  00194	75 38		 jne	 SHORT $LN1@HORSPOOL_h
  00196	83 e9 04	 sub	 ecx, 4
  00199	83 c2 04	 add	 edx, 4
  0019c	83 c6 04	 add	 esi, 4
  0019f	83 f9 04	 cmp	 ecx, 4
  001a2	73 ec		 jae	 SHORT $LL14@HORSPOOL_h
$LN22@HORSPOOL_h:
  001a4	85 c9		 test	 ecx, ecx
  001a6	74 20		 je	 SHORT $LN16@HORSPOOL_h
  001a8	8a 1a		 mov	 bl, BYTE PTR [edx]
  001aa	3a 1e		 cmp	 bl, BYTE PTR [esi]
  001ac	75 20		 jne	 SHORT $LN1@HORSPOOL_h
  001ae	83 f9 01	 cmp	 ecx, 1
  001b1	76 15		 jbe	 SHORT $LN16@HORSPOOL_h
  001b3	8a 5a 01	 mov	 bl, BYTE PTR [edx+1]
  001b6	3a 5e 01	 cmp	 bl, BYTE PTR [esi+1]
  001b9	75 13		 jne	 SHORT $LN1@HORSPOOL_h
  001bb	83 f9 02	 cmp	 ecx, 2
  001be	76 08		 jbe	 SHORT $LN16@HORSPOOL_h
  001c0	8a 52 02	 mov	 dl, BYTE PTR [edx+2]
  001c3	3a 56 02	 cmp	 dl, BYTE PTR [esi+2]
  001c6	75 06		 jne	 SHORT $LN1@HORSPOOL_h
$LN16@HORSPOOL_h:
  001c8	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits
$LN1@HORSPOOL_h:

; 1990 :        i+=bm_bc[ch];

  001ce	0f b6 4c 24 0f	 movzx	 ecx, BYTE PTR _ch$[esp+1056]
  001d3	03 7c 8c 18	 add	 edi, DWORD PTR _bm_bc$[esp+ecx*4+1056]
  001d7	3b 7c 24 14	 cmp	 edi, DWORD PTR $T7024[esp+1056]
  001db	7e 88		 jle	 SHORT $LL31@HORSPOOL_h
$LN27@HORSPOOL_h:

; 1991 :     }
; 1992 :     return(-1);
; 1993 :    }

  001dd	8b 8c 24 1c 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1056]
  001e4	5f		 pop	 edi
  001e5	5e		 pop	 esi
  001e6	5b		 pop	 ebx
  001e7	33 cc		 xor	 ecx, esp
  001e9	83 c8 ff	 or	 eax, -1
  001ec	e8 00 00 00 00	 call	 @__security_check_cookie@4
  001f1	8b e5		 mov	 esp, ebp
  001f3	5d		 pop	 ebp
  001f4	c3		 ret	 0
_HORSPOOL_hits ENDP
_TEXT	ENDS
PUBLIC	__$ArrayPad$
PUBLIC	_Boyer_Moore_Horspool_Kaze
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_lastch$ = -1045					; size = 1
$T7045 = -1044						; size = 4
tv285 = -1040						; size = 4
_countSTATIC$ = -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

; 1999 :    {

  00200	55		 push	 ebp
  00201	8b ec		 mov	 ebp, esp
  00203	83 e4 f8	 and	 esp, -8			; fffffff8H
  00206	81 ec 1c 04 00
	00		 sub	 esp, 1052		; 0000041cH
  0020c	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00211	33 c4		 xor	 eax, esp
  00213	89 84 24 18 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1052], eax

; 2000 :     long i;
; 2001 :     int a, j, bm_bc[ASIZE];
; 2002 :     unsigned char ch;
; 2003 :     unsigned char lastch;
; 2004 :     unsigned char firstch;
; 2005 : 
; 2006 :     unsigned long  count;
; 2007 :     unsigned long  countSTATIC;
; 2008 : 
; 2009 :     /* Preprocessing */
; 2010 :     for (a=0; a < ASIZE; a++) bm_bc[a]=m;

  0021a	8b 45 14	 mov	 eax, DWORD PTR _m$[ebp]
  0021d	53		 push	 ebx
  0021e	8b 5d 0c	 mov	 ebx, DWORD PTR _x$[ebp]
  00221	56		 push	 esi
  00222	57		 push	 edi
  00223	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  00228	8d 7c 24 20	 lea	 edi, DWORD PTR _bm_bc$[esp+1064]
  0022c	f3 ab		 rep stosd

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

  0022e	8d 50 ff	 lea	 edx, DWORD PTR [eax-1]
  00231	33 c9		 xor	 ecx, ecx
  00233	85 d2		 test	 edx, edx
  00235	7e 17		 jle	 SHORT $LN7@Boyer_Moor
  00237	8b f2		 mov	 esi, edx
  00239	8d a4 24 00 00
	00 00		 npad	 7
$LL9@Boyer_Moor:
  00240	0f be 3c 0b	 movsx	 edi, BYTE PTR [ebx+ecx]
  00244	89 74 bc 20	 mov	 DWORD PTR _bm_bc$[esp+edi*4+1064], esi
  00248	41		 inc	 ecx
  00249	4e		 dec	 esi
  0024a	3b ca		 cmp	 ecx, edx
  0024c	7c f2		 jl	 SHORT $LL9@Boyer_Moor
$LN7@Boyer_Moor:

; 2012 :    
; 2013 :     /* Searching */
; 2014 :     lastch=x[m-1];
; 2015 :     firstch=x[0];
; 2016 :     i=0;
; 2017 :         countSTATIC = m-2;   
; 2018 :     while (i <= n-m) {

  0024e	8b 75 10	 mov	 esi, DWORD PTR _n$[ebp]
  00251	8a 4c 03 ff	 mov	 cl, BYTE PTR [ebx+eax-1]
  00255	33 ff		 xor	 edi, edi
  00257	8d 50 fe	 lea	 edx, DWORD PTR [eax-2]
  0025a	2b f0		 sub	 esi, eax
  0025c	88 4c 24 13	 mov	 BYTE PTR _lastch$[esp+1064], cl
  00260	89 54 24 1c	 mov	 DWORD PTR _countSTATIC$[esp+1064], edx
  00264	89 74 24 14	 mov	 DWORD PTR $T7045[esp+1064], esi
  00268	78 70		 js	 SHORT $LN5@Boyer_Moor
  0026a	8b 4d 08	 mov	 ecx, DWORD PTR _y$[ebp]
  0026d	8d 44 01 ff	 lea	 eax, DWORD PTR [ecx+eax-1]
  00271	89 44 24 18	 mov	 DWORD PTR tv285[esp+1064], eax
$LL6@Boyer_Moor:

; 2019 :        ch=y[i+m-1];
; 2020 :        //if (ch ==lastch)
; 2021 :           //if (memcmp(&y[i],x,m-1) == 0) OUTPUT(i);
; 2022 : // Below line gives: 315KB/clock
; 2023 :           //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".
; 2024 : // Below line gives: 328KB/clock
; 2025 : //          if (ch == lastch && y[i] == firstch && memcmp(&y[i+1],&x[0+1],m-1-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".
; 2026 : 
; 2027 :           if (ch == lastch && y[i] == firstch)

  00275	8a 54 24 13	 mov	 dl, BYTE PTR _lastch$[esp+1064]
  00279	38 14 38	 cmp	 BYTE PTR [eax+edi], dl
  0027c	75 50		 jne	 SHORT $LN1@Boyer_Moor
  0027e	8b 4d 08	 mov	 ecx, DWORD PTR _y$[ebp]
  00281	0f be 14 0f	 movsx	 edx, BYTE PTR [edi+ecx]
  00285	0f b6 0b	 movzx	 ecx, BYTE PTR [ebx]
  00288	3b d1		 cmp	 edx, ecx
  0028a	75 42		 jne	 SHORT $LN1@Boyer_Moor

; 2028 :              {
; 2029 :          count = countSTATIC;

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

; 2030 :          while ( count && *(char *)(x+1+(countSTATIC-count)) == *(char *)(&y[i]+1+(countSTATIC-count)) ) {

  00290	85 c9		 test	 ecx, ecx
  00292	74 17		 je	 SHORT $LN19@Boyer_Moor

; 2028 :              {
; 2029 :          count = countSTATIC;

  00294	8b 55 08	 mov	 edx, DWORD PTR _y$[ebp]
  00297	8d 73 01	 lea	 esi, DWORD PTR [ebx+1]
  0029a	8d 54 17 01	 lea	 edx, DWORD PTR [edi+edx+1]
  0029e	8b ff		 npad	 2
$LL3@Boyer_Moor:

; 2030 :          while ( count && *(char *)(x+1+(countSTATIC-count)) == *(char *)(&y[i]+1+(countSTATIC-count)) ) {

  002a0	8a 06		 mov	 al, BYTE PTR [esi]
  002a2	3a 02		 cmp	 al, BYTE PTR [edx]
  002a4	75 1c		 jne	 SHORT $LN2@Boyer_Moor

; 2031 :                count--;

  002a6	42		 inc	 edx
  002a7	46		 inc	 esi
  002a8	49		 dec	 ecx
  002a9	75 f5		 jne	 SHORT $LL3@Boyer_Moor
$LN19@Boyer_Moor:

; 2032 :          }
; 2033 :          if ( count == 0) return(i);

  002ab	8b c7		 mov	 eax, edi

; 2038 :     }
; 2039 :     return(-1);
; 2040 :    }

  002ad	5f		 pop	 edi
  002ae	5e		 pop	 esi
  002af	5b		 pop	 ebx
  002b0	8b 8c 24 18 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1052]
  002b7	33 cc		 xor	 ecx, esp
  002b9	e8 00 00 00 00	 call	 @__security_check_cookie@4
  002be	8b e5		 mov	 esp, ebp
  002c0	5d		 pop	 ebp
  002c1	c3		 ret	 0
$LN2@Boyer_Moor:

; 2032 :          }
; 2033 :          if ( count == 0) return(i);

  002c2	85 c9		 test	 ecx, ecx
  002c4	74 e5		 je	 SHORT $LN19@Boyer_Moor
  002c6	8b 74 24 14	 mov	 esi, DWORD PTR $T7045[esp+1064]
  002ca	8b 44 24 18	 mov	 eax, DWORD PTR tv285[esp+1064]
$LN1@Boyer_Moor:

; 2034 : 	     }
; 2035 : 
; 2036 : 
; 2037 :        i+=bm_bc[ch];

  002ce	0f b6 0c 38	 movzx	 ecx, BYTE PTR [eax+edi]
  002d2	03 7c 8c 20	 add	 edi, DWORD PTR _bm_bc$[esp+ecx*4+1064]
  002d6	3b fe		 cmp	 edi, esi
  002d8	7e 9b		 jle	 SHORT $LL6@Boyer_Moor
$LN5@Boyer_Moor:

; 2038 :     }
; 2039 :     return(-1);
; 2040 :    }

  002da	8b 8c 24 24 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1064]
  002e1	5f		 pop	 edi
  002e2	5e		 pop	 esi
  002e3	5b		 pop	 ebx
  002e4	33 cc		 xor	 ecx, esp
  002e6	83 c8 ff	 or	 eax, -1
  002e9	e8 00 00 00 00	 call	 @__security_check_cookie@4
  002ee	8b e5		 mov	 esp, ebp
  002f0	5d		 pop	 ebp
  002f1	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

; 2046 :     long i, j;
; 2047 :   
; 2048 :     /* Searching */
; 2049 :     for (i=0; i <= n-m; i++) {

  00300	8b 54 24 10	 mov	 edx, DWORD PTR _m$[esp-4]
  00304	53		 push	 ebx
  00305	55		 push	 ebp
  00306	8b 6c 24 14	 mov	 ebp, DWORD PTR _n$[esp+4]
  0030a	56		 push	 esi
  0030b	57		 push	 edi
  0030c	33 ff		 xor	 edi, edi
  0030e	2b ea		 sub	 ebp, edx
  00310	78 2d		 js	 SHORT $LN4@Brute_Forc
  00312	8b 44 24 18	 mov	 eax, DWORD PTR _x$[esp+12]
$LL6@Brute_Forc:

; 2050 :        j=0;

  00316	33 c9		 xor	 ecx, ecx

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

  00318	85 d2		 test	 edx, edx
  0031a	7e 13		 jle	 SHORT $LN11@Brute_Forc
  0031c	8b 74 24 14	 mov	 esi, DWORD PTR _y$[esp+12]
  00320	03 f7		 add	 esi, edi
$LL3@Brute_Forc:
  00322	8a 1c 0e	 mov	 bl, BYTE PTR [esi+ecx]
  00325	3a 1c 01	 cmp	 bl, BYTE PTR [ecx+eax]
  00328	75 0c		 jne	 SHORT $LN2@Brute_Forc
  0032a	41		 inc	 ecx
  0032b	3b ca		 cmp	 ecx, edx
  0032d	7c f3		 jl	 SHORT $LL3@Brute_Forc
$LN11@Brute_Forc:

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

  0032f	8b c7		 mov	 eax, edi
  00331	5f		 pop	 edi
  00332	5e		 pop	 esi
  00333	5d		 pop	 ebp
  00334	5b		 pop	 ebx

; 2055 :    }

  00335	c3		 ret	 0
$LN2@Brute_Forc:

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

  00336	3b ca		 cmp	 ecx, edx
  00338	7d f5		 jge	 SHORT $LN11@Brute_Forc

; 2046 :     long i, j;
; 2047 :   
; 2048 :     /* Searching */
; 2049 :     for (i=0; i <= n-m; i++) {

  0033a	47		 inc	 edi
  0033b	3b fd		 cmp	 edi, ebp
  0033d	7e d7		 jle	 SHORT $LL6@Brute_Forc
$LN4@Brute_Forc:
  0033f	5f		 pop	 edi
  00340	5e		 pop	 esi
  00341	5d		 pop	 ebp

; 2053 :     }
; 2054 :     return(-1);

  00342	83 c8 ff	 or	 eax, -1
  00345	5b		 pop	 ebx

; 2055 :    }

  00346	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
$T7073 = 16						; size = 4
_n$ = 16						; size = 4
tv185 = 20						; size = 4
_hx$ = 20						; size = 4
_m$ = 20						; size = 4
_Karp_Rabin PROC

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

  00350	51		 push	 ecx
  00351	53		 push	 ebx
  00352	55		 push	 ebp

; 2062 :    int d, hx, hy, i, j;
; 2063 : 
; 2064 :    /* Preprocessing */
; 2065 :    /* computes d = 2^(m-1) with
; 2066 :       the left-shift operator */
; 2067 :    for (d = i = 1; i < m; ++i)

  00353	8b 6c 24 1c	 mov	 ebp, DWORD PTR _m$[esp+8]
  00357	b8 01 00 00 00	 mov	 eax, 1
  0035c	56		 push	 esi
  0035d	57		 push	 edi
  0035e	89 44 24 10	 mov	 DWORD PTR _d$[esp+20], eax
  00362	3b e8		 cmp	 ebp, eax
  00364	7e 13		 jle	 SHORT $LN7@Karp_Rabin
  00366	8d 4d ff	 lea	 ecx, DWORD PTR [ebp-1]
  00369	8d a4 24 00 00
	00 00		 npad	 7
$LL9@Karp_Rabin:

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

  00370	03 c0		 add	 eax, eax
  00372	49		 dec	 ecx
  00373	75 fb		 jne	 SHORT $LL9@Karp_Rabin
  00375	89 44 24 10	 mov	 DWORD PTR _d$[esp+20], eax
$LN7@Karp_Rabin:

; 2069 : 
; 2070 :    for (hy = hx = i = 0; i < m; ++i) {

  00379	8b 74 24 18	 mov	 esi, DWORD PTR _y$[esp+16]
  0037d	33 ff		 xor	 edi, edi
  0037f	33 d2		 xor	 edx, edx
  00381	89 7c 24 24	 mov	 DWORD PTR _hx$[esp+16], edi
  00385	85 ed		 test	 ebp, ebp
  00387	7e 24		 jle	 SHORT $LN4@Karp_Rabin
  00389	8b 4c 24 1c	 mov	 ecx, DWORD PTR _x$[esp+16]
  0038d	8b c6		 mov	 eax, esi
  0038f	2b ce		 sub	 ecx, esi
  00391	89 6c 24 24	 mov	 DWORD PTR tv185[esp+16], ebp
$LL6@Karp_Rabin:

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

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

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

  0039c	0f be 18	 movsx	 ebx, BYTE PTR [eax]
  0039f	40		 inc	 eax
  003a0	ff 4c 24 24	 dec	 DWORD PTR tv185[esp+16]
  003a4	8d 14 53	 lea	 edx, DWORD PTR [ebx+edx*2]
  003a7	75 ec		 jne	 SHORT $LL6@Karp_Rabin

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

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

; 2073 :    }
; 2074 : 
; 2075 :    /* Searching */
; 2076 :    j = 0;
; 2077 :    while (j <= n-m) {

  003ad	8b 4c 24 20	 mov	 ecx, DWORD PTR _n$[esp+16]
  003b1	33 c0		 xor	 eax, eax
  003b3	2b cd		 sub	 ecx, ebp
  003b5	89 4c 24 20	 mov	 DWORD PTR $T7073[esp+16], ecx
  003b9	78 74		 js	 SHORT $LN2@Karp_Rabin
  003bb	eb 03 8d 49 00	 npad	 5
$LL3@Karp_Rabin:

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

  003c0	3b fa		 cmp	 edi, edx
  003c2	75 51		 jne	 SHORT $LN1@Karp_Rabin
  003c4	8b 7c 24 1c	 mov	 edi, DWORD PTR _x$[esp+16]
  003c8	03 f0		 add	 esi, eax
  003ca	8b cd		 mov	 ecx, ebp
  003cc	83 fd 04	 cmp	 ebp, 4
  003cf	72 14		 jb	 SHORT $LN21@Karp_Rabin
$LL13@Karp_Rabin:
  003d1	8b 1f		 mov	 ebx, DWORD PTR [edi]
  003d3	3b 1e		 cmp	 ebx, DWORD PTR [esi]
  003d5	75 32		 jne	 SHORT $LN26@Karp_Rabin
  003d7	83 e9 04	 sub	 ecx, 4
  003da	83 c6 04	 add	 esi, 4
  003dd	83 c7 04	 add	 edi, 4
  003e0	83 f9 04	 cmp	 ecx, 4
  003e3	73 ec		 jae	 SHORT $LL13@Karp_Rabin
$LN21@Karp_Rabin:
  003e5	85 c9		 test	 ecx, ecx
  003e7	74 49		 je	 SHORT $LN10@Karp_Rabin
  003e9	8a 1e		 mov	 bl, BYTE PTR [esi]
  003eb	3a 1f		 cmp	 bl, BYTE PTR [edi]
  003ed	75 1a		 jne	 SHORT $LN26@Karp_Rabin
  003ef	83 f9 01	 cmp	 ecx, 1
  003f2	76 3e		 jbe	 SHORT $LN10@Karp_Rabin
  003f4	8a 5e 01	 mov	 bl, BYTE PTR [esi+1]
  003f7	3a 5f 01	 cmp	 bl, BYTE PTR [edi+1]
  003fa	75 0d		 jne	 SHORT $LN26@Karp_Rabin
  003fc	83 f9 02	 cmp	 ecx, 2
  003ff	76 31		 jbe	 SHORT $LN10@Karp_Rabin
  00401	8a 4e 02	 mov	 cl, BYTE PTR [esi+2]
  00404	3a 4f 02	 cmp	 cl, BYTE PTR [edi+2]
  00407	74 29		 je	 SHORT $LN10@Karp_Rabin
$LN26@Karp_Rabin:
  00409	8b 74 24 18	 mov	 esi, DWORD PTR _y$[esp+16]
  0040d	8b 7c 24 24	 mov	 edi, DWORD PTR _hx$[esp+16]
  00411	8b 4c 24 20	 mov	 ecx, DWORD PTR $T7073[esp+16]
$LN1@Karp_Rabin:

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

  00415	0f be 1c 30	 movsx	 ebx, BYTE PTR [eax+esi]
  00419	0f af 5c 24 10	 imul	 ebx, DWORD PTR _d$[esp+20]
  0041e	2b d3		 sub	 edx, ebx
  00420	8d 1c 30	 lea	 ebx, DWORD PTR [eax+esi]
  00423	0f be 1c 2b	 movsx	 ebx, BYTE PTR [ebx+ebp]

; 2080 :       ++j;

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

; 2081 :    }
; 2082 :     return(-1);

  0042f	83 c8 ff	 or	 eax, -1
$LN10@Karp_Rabin:
  00432	5f		 pop	 edi
  00433	5e		 pop	 esi
  00434	5d		 pop	 ebp
  00435	5b		 pop	 ebx

; 2083 :    }

  00436	59		 pop	 ecx
  00437	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

; 2092 : {

  00440	51		 push	 ecx

; 2093 :     unsigned int    i;
; 2094 :     char *  pbTargetMax = pbTarget + cbTarget;

  00441	8b 44 24 10	 mov	 eax, DWORD PTR _cbTarget$[esp]
  00445	55		 push	 ebp
  00446	8b 6c 24 0c	 mov	 ebp, DWORD PTR _pbTarget$[esp+4]
  0044a	8d 0c 28	 lea	 ecx, DWORD PTR [eax+ebp]
  0044d	57		 push	 edi

; 2095 :     char *  pbPatternMax = pbPattern + cbPattern;

  0044e	8b 7c 24 1c	 mov	 edi, DWORD PTR _cbPattern$[esp+8]
  00452	89 4c 24 08	 mov	 DWORD PTR _pbTargetMax$[esp+12], ecx
  00456	8b 4c 24 14	 mov	 ecx, DWORD PTR _pbPattern$[esp+8]
  0045a	8d 14 39	 lea	 edx, DWORD PTR [ecx+edi]

; 2096 :     unsigned long  ulBaseToPowerMod = 1;
; 2097 :     register unsigned long  ulHashPattern = 0;
; 2098 :     unsigned long  ulHashTarget = 0;
; 2099 : long hits = 0;
; 2100 : //unsigned long count;
; 2101 :     //char *  buf1;
; 2102 :     //char *  buf2;
; 2103 : 
; 2104 :     if (cbPattern > cbTarget)

  0045d	3b f8		 cmp	 edi, eax
  0045f	76 06		 jbe	 SHORT $LN16@KarpRabinK

; 2105 :         return(NULL);

  00461	5f		 pop	 edi
  00462	33 c0		 xor	 eax, eax
  00464	5d		 pop	 ebp

; 2187 : }

  00465	59		 pop	 ecx
  00466	c3		 ret	 0
$LN16@KarpRabinK:

; 2106 : 
; 2107 :     // Compute the power of the left most character in base ulBase
; 2108 :     //for (i = 1; i < cbPattern; i++) ulBaseToPowerMod = (ulBase * ulBaseToPowerMod);
; 2109 : 
; 2110 :     // Calculate the hash function for the src (and the first dst)
; 2111 :     while (pbPattern < pbPatternMax)

  00467	3b ca		 cmp	 ecx, edx
  00469	73 06		 jae	 SHORT $LN6@KarpRabinK
  0046b	2b d1		 sub	 edx, ecx
  0046d	03 ca		 add	 ecx, edx
  0046f	03 ea		 add	 ebp, edx
$LN6@KarpRabinK:

; 2112 :     {
; 2113 :         // Below lines give 366KB/clock for 'underdog':
; 2114 :         //ulHashPattern = (ulHashPattern*ulBase + *pbPattern);
; 2115 :         //ulHashTarget = (ulHashTarget*ulBase + *pbTarget);
; 2116 :         pbPattern++;
; 2117 :         pbTarget++;
; 2118 :     }
; 2119 :         // Below lines give 436KB/clock for 'underdog' + requirement pattern to be 4 chars min.:
; 2120 :         //ulHashPattern = ( (*(long *)(pbPattern-cbPattern)) & 0xffffff00 ) + *(pbPattern-1);
; 2121 :         //ulHashTarget = ( (*(long *)(pbTarget-cbPattern)) & 0xffffff00 ) + *(pbTarget-1);
; 2122 :         // Below lines give 482KB/clock for 'underdog' + requirement pattern to be 2 chars min.:
; 2123 :         //ulHashPattern = ( (*(unsigned short *)(pbPattern-cbPattern)) | *(pbPattern-1) );
; 2124 :         //ulHashTarget = ( (*(unsigned short *)(pbTarget-cbPattern)) | *(pbTarget-1) );
; 2125 :         // Below lines give 482KB/clock for 'underdog' + requirement pattern to be 2 chars min.:
; 2126 :         //ulHashPattern = ( (*(unsigned short *)(pbPattern-cbPattern)) & 0xff00 ) + *(pbPattern-1);
; 2127 :         //ulHashTarget = ( (*(unsigned short *)(pbTarget-cbPattern)) & 0xff00 ) + *(pbTarget-1);
; 2128 :         // Below lines give 605KB/clock for 'underdog' + requirement pattern to be 2 chars min.:
; 2129 :         //ulHashPattern = ( (*(unsigned short *)(pbPattern-cbPattern))<<8 ) + *(pbPattern-1);
; 2130 :         //ulHashTarget = ( (*(unsigned short *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1);
; 2131 :         // Below lines give 668KB/clock for 'underdog':
; 2132 :         ulHashPattern = ( (*(char *)(pbPattern-cbPattern))<<8 ) + *(pbPattern-1);

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

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

  00475	0f be 45 ff	 movsx	 eax, BYTE PTR [ebp-1]
  00479	53		 push	 ebx
  0047a	56		 push	 esi
  0047b	8b f1		 mov	 esi, ecx
  0047d	2b f7		 sub	 esi, edi
  0047f	0f be 1e	 movsx	 ebx, BYTE PTR [esi]
  00482	c1 e3 08	 shl	 ebx, 8
  00485	03 da		 add	 ebx, edx
  00487	8b d5		 mov	 edx, ebp
  00489	2b d7		 sub	 edx, edi
  0048b	0f be 0a	 movsx	 ecx, BYTE PTR [edx]
  0048e	c1 e1 08	 shl	 ecx, 8
  00491	03 c8		 add	 ecx, eax
  00493	89 74 24 20	 mov	 DWORD PTR tv199[esp+16], esi
  00497	89 5c 24 18	 mov	 DWORD PTR _ulHashPattern$[esp+16], ebx
  0049b	8b c2		 mov	 eax, edx
  0049d	8d 49 00	 npad	 3
$LL4@KarpRabinK:

; 2134 : 
; 2135 :     // Dynamically produce hash values for the string as we go
; 2136 :     for ( ;; )
; 2137 :     {
; 2138 :         if ( (ulHashPattern == ulHashTarget) && !memcmp(pbPattern-cbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )

  004a0	3b d9		 cmp	 ebx, ecx
  004a2	75 4c		 jne	 SHORT $LN2@KarpRabinK
  004a4	8b cf		 mov	 ecx, edi
  004a6	8b d0		 mov	 edx, eax
  004a8	83 ff 04	 cmp	 edi, 4
  004ab	72 17		 jb	 SHORT $LN19@KarpRabinK
  004ad	8d 49 00	 npad	 3
$LL11@KarpRabinK:
  004b0	8b 1e		 mov	 ebx, DWORD PTR [esi]
  004b2	3b 1a		 cmp	 ebx, DWORD PTR [edx]
  004b4	75 32		 jne	 SHORT $LN23@KarpRabinK
  004b6	83 e9 04	 sub	 ecx, 4
  004b9	83 c2 04	 add	 edx, 4
  004bc	83 c6 04	 add	 esi, 4
  004bf	83 f9 04	 cmp	 ecx, 4
  004c2	73 ec		 jae	 SHORT $LL11@KarpRabinK
$LN19@KarpRabinK:
  004c4	85 c9		 test	 ecx, ecx
  004c6	74 3f		 je	 SHORT $LN13@KarpRabinK
  004c8	8a 1a		 mov	 bl, BYTE PTR [edx]
  004ca	3a 1e		 cmp	 bl, BYTE PTR [esi]
  004cc	75 1a		 jne	 SHORT $LN23@KarpRabinK
  004ce	83 f9 01	 cmp	 ecx, 1
  004d1	76 34		 jbe	 SHORT $LN13@KarpRabinK
  004d3	8a 5a 01	 mov	 bl, BYTE PTR [edx+1]
  004d6	3a 5e 01	 cmp	 bl, BYTE PTR [esi+1]
  004d9	75 0d		 jne	 SHORT $LN23@KarpRabinK
  004db	83 f9 02	 cmp	 ecx, 2
  004de	76 27		 jbe	 SHORT $LN13@KarpRabinK
  004e0	8a 4a 02	 mov	 cl, BYTE PTR [edx+2]
  004e3	3a 4e 02	 cmp	 cl, BYTE PTR [esi+2]
  004e6	74 1f		 je	 SHORT $LN13@KarpRabinK
$LN23@KarpRabinK:
  004e8	8b 5c 24 18	 mov	 ebx, DWORD PTR _ulHashPattern$[esp+16]
  004ec	8b 74 24 20	 mov	 esi, DWORD PTR tv199[esp+16]
$LN2@KarpRabinK:

; 2152 :             //hits++;
; 2153 :                                                              
; 2154 :         if (pbTarget == pbTargetMax)

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

; 2156 : 
; 2157 :         // Below line gives 482KB/clock for 'underdog' + requirement pattern to be 2 chars min.:
; 2158 :         //ulHashTarget = ( (*(unsigned short *)(pbTarget+1-cbPattern)) | *pbTarget );
; 2159 :         // Below line gives 436KB/clock for 'underdog' + requirement pattern to be 4 chars min.:
; 2160 :         //ulHashTarget = ( (*(long *)(pbTarget+1-cbPattern)) & 0xffffff00 ) + *pbTarget;
; 2161 : //; Line 696
; 2162 : //        movsx   esi, BYTE PTR [ebx]
; 2163 : //        mov     ecx, DWORD PTR [edx+1]
; 2164 : //        and     ecx, -256                               ; ffffff00H
; 2165 : //        add     ecx, esi
; 2166 :         // Below line gives 482KB/clock for 'underdog' + requirement pattern to be 2 chars min.:
; 2167 :         //ulHashTarget = ( (*(unsigned short *)(pbTarget+1-cbPattern)) & 0xff00 ) + *pbTarget;
; 2168 : //; Line 691
; 2169 : //        movsx   esi, BYTE PTR [ebx]
; 2170 : //        xor     ecx, ecx
; 2171 : //        mov     cx, WORD PTR [edx+1]
; 2172 : //        and     ecx, 65280                              ; 0000ff00H
; 2173 : //        add     ecx, esi
; 2174 :         // Below line gives 605KB/clock for 'underdog' + requirement pattern to be 2 chars min.:
; 2175 :         //ulHashTarget = ( (*(unsigned short *)(pbTarget+1-cbPattern))<<8 ) + *pbTarget;
; 2176 :         // Below line gives 668KB/clock for 'underdog':
; 2177 :         ulHashTarget = ( (*(char *)(pbTarget+1-cbPattern))<<8 ) + *pbTarget;

  004f6	0f be 48 01	 movsx	 ecx, BYTE PTR [eax+1]
  004fa	0f be 55 00	 movsx	 edx, BYTE PTR [ebp]
  004fe	c1 e1 08	 shl	 ecx, 8
  00501	03 ca		 add	 ecx, edx

; 2178 : //; Line 718
; 2179 : //        movsx   ecx, BYTE PTR [eax+1]
; 2180 : //        movsx   edx, BYTE PTR [ebp]
; 2181 : //        shl     ecx, 8
; 2182 : //        add     ecx, edx
; 2183 :         // Below line gives 366KB/clock for 'underdog':
; 2184 :         //ulHashTarget = (ulHashTarget - *(pbTarget-cbPattern)*ulBaseToPowerMod)*ulBase + *pbTarget;
; 2185 :         pbTarget++;

  00503	45		 inc	 ebp
  00504	40		 inc	 eax

; 2186 :     }

  00505	eb 99		 jmp	 SHORT $LL4@KarpRabinK
$LN13@KarpRabinK:
  00507	5e		 pop	 esi

; 2139 :        // if ( ulHashPattern == ulHashTarget ) {
; 2140 :        // 
; 2141 :        //  count = cbPattern;
; 2142 :        //  buf1 = pbPattern-cbPattern;
; 2143 :        //  buf2 = pbTarget-cbPattern;
; 2144 :        //  while ( --count && *(char *)buf1 == *(char *)buf2 ) {
; 2145 :        //          buf1 = (char *)buf1 + 1;
; 2146 :        //          buf2 = (char *)buf2 + 1;
; 2147 :        //  }
; 2148 :        //                 
; 2149 :        //  if ( *((unsigned char *)buf1) - *((unsigned char *)buf2) == 0) hits++;
; 2150 :        //  }
; 2151 :             return((pbTarget-cbPattern));

  00508	8b c5		 mov	 eax, ebp
  0050a	5b		 pop	 ebx
  0050b	2b c7		 sub	 eax, edi
  0050d	5f		 pop	 edi
  0050e	5d		 pop	 ebp

; 2187 : }

  0050f	59		 pop	 ecx
  00510	c3		 ret	 0
$LN20@KarpRabinK:
  00511	5e		 pop	 esi
  00512	5b		 pop	 ebx
  00513	5f		 pop	 edi

; 2155 :             return(NULL);

  00514	33 c0		 xor	 eax, eax
  00516	5d		 pop	 ebp

; 2187 : }

  00517	59		 pop	 ecx
  00518	c3		 ret	 0
_KarpRabinKaze ENDP
_TEXT	ENDS
PUBLIC	_pbPattern$GSCopy$
PUBLIC	__$ArrayPad$
PUBLIC	_Railgun_Quadruplet
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_pbPattern$GSCopy$ = -1060				; size = 4
$T7117 = -1056						; size = 4
_Quadruplet3rd$ = -1056					; size = 4
_countSTATIC$ = -1052					; size = 4
_Quadruplet4th$ = -1052					; size = 4
_AdvanceHopperGrass$ = -1048				; size = 4
tv594 = -1044						; size = 4
_Quadruplet2nd$ = -1044					; size = 4
tv392 = -1040						; size = 4
_pbTargetMax$ = -1040					; size = 4
tv565 = -1036						; size = 4
_ulHashPattern$ = -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

; 2197 : {

  00520	81 ec 24 04 00
	00		 sub	 esp, 1060		; 00000424H
  00526	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  0052b	33 c4		 xor	 eax, esp
  0052d	89 84 24 20 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1060], eax
  00534	8b 94 24 2c 04
	00 00		 mov	 edx, DWORD PTR _pbPattern$[esp+1056]
  0053b	53		 push	 ebx

; 2198 :     char * pbTargetMax = pbTarget + cbTarget;

  0053c	8b 9c 24 34 04
	00 00		 mov	 ebx, DWORD PTR _cbTarget$[esp+1060]
  00543	55		 push	 ebp

; 2199 :     register unsigned long  ulHashPattern;
; 2200 :     unsigned long ulHashTarget;
; 2201 :     unsigned long count;
; 2202 :     unsigned long countSTATIC;
; 2203 : //  unsigned long countRemainder;
; 2204 : 
; 2205 : /*
; 2206 :     const unsigned char SINGLET = *(char *)(pbPattern);
; 2207 :     const unsigned long Quadruplet2nd = SINGLET<<8;
; 2208 :     const unsigned long Quadruplet3rd = SINGLET<<16;
; 2209 :     const unsigned long Quadruplet4th = SINGLET<<24;
; 2210 : */
; 2211 :     unsigned char SINGLET;
; 2212 :     unsigned long Quadruplet2nd;
; 2213 :     unsigned long Quadruplet3rd;
; 2214 :     unsigned long Quadruplet4th;
; 2215 : 
; 2216 :     unsigned long  AdvanceHopperGrass;
; 2217 : 
; 2218 :     long i; //BMH needed
; 2219 :     int a, j, bm_bc[ASIZE]; //BMH needed
; 2220 :     unsigned char ch; //BMH needed
; 2221 : //    unsigned char lastch, firstch; //BMH needed
; 2222 : 
; 2223 :     if (cbPattern > cbTarget)

  00544	8b ac 24 3c 04
	00 00		 mov	 ebp, DWORD PTR _cbPattern$[esp+1064]
  0054b	56		 push	 esi
  0054c	8b b4 24 34 04
	00 00		 mov	 esi, DWORD PTR _pbTarget$[esp+1068]
  00553	57		 push	 edi
  00554	8d 3c 1e	 lea	 edi, DWORD PTR [esi+ebx]
  00557	89 54 24 10	 mov	 DWORD PTR _pbPattern$GSCopy$[esp+1076], edx
  0055b	89 7c 24 24	 mov	 DWORD PTR _pbTargetMax$[esp+1076], edi
  0055f	3b eb		 cmp	 ebp, ebx

; 2224 :         return(NULL);

  00561	77 46		 ja	 SHORT $LN5@Railgun_Qu

; 2225 : 
; 2226 : // Doesn't work when cbPattern = 1
; 2227 : // 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!
; 2228 : 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.

  00563	83 fd 04	 cmp	 ebp, 4
  00566	0f 83 97 00 00
	00		 jae	 $LN41@Railgun_Qu

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

  0056c	0f be 02	 movsx	 eax, BYTE PTR [edx]
  0056f	0f be 4c 2a ff	 movsx	 ecx, BYTE PTR [edx+ebp-1]
  00574	c1 e0 08	 shl	 eax, 8
  00577	03 f5		 add	 esi, ebp
  00579	03 c8		 add	 ecx, eax

; 2231 : //        countSTATIC = cbPattern-2;
; 2232 : 
; 2233 : if ( cbPattern==3) {

  0057b	83 fd 03	 cmp	 ebp, 3
  0057e	75 49		 jne	 SHORT $LN46@Railgun_Qu
$LL39@Railgun_Qu:

; 2234 :     for ( ;; )
; 2235 :     {
; 2236 :         if ( ulHashPattern == ( (*(char *)(pbTarget-3))<<8 ) + *(pbTarget-1) ) {

  00580	0f be 46 fd	 movsx	 eax, BYTE PTR [esi-3]
  00584	0f be 5e ff	 movsx	 ebx, BYTE PTR [esi-1]
  00588	c1 e0 08	 shl	 eax, 8
  0058b	03 c3		 add	 eax, ebx
  0058d	3b c8		 cmp	 ecx, eax
  0058f	75 08		 jne	 SHORT $LN36@Railgun_Qu

; 2237 :          if ( *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) return((pbTarget-3));

  00591	8a 42 01	 mov	 al, BYTE PTR [edx+1]
  00594	3a 46 fe	 cmp	 al, BYTE PTR [esi-2]
  00597	74 2b		 je	 SHORT $LN53@Railgun_Qu
$LN36@Railgun_Qu:

; 2238 :         }
; 2239 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-2) ) pbTarget++;

  00599	8b c1		 mov	 eax, ecx
  0059b	c1 e8 08	 shr	 eax, 8
  0059e	3a 46 fe	 cmp	 al, BYTE PTR [esi-2]
  005a1	74 01		 je	 SHORT $LN35@Railgun_Qu
  005a3	46		 inc	 esi
$LN35@Railgun_Qu:

; 2240 :         pbTarget++;

  005a4	46		 inc	 esi

; 2241 :         if (pbTarget > pbTargetMax)

  005a5	3b f7		 cmp	 esi, edi
  005a7	76 d7		 jbe	 SHORT $LL39@Railgun_Qu
$LN5@Railgun_Qu:

; 2376 :     }
; 2377 :     return(NULL);

  005a9	33 c0		 xor	 eax, eax
$LN13@Railgun_Qu:

; 2378 : } //if (cbTarget<961)
; 2379 : } //if ( cbPattern<4)
; 2380 : }

  005ab	8b 8c 24 30 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1076]
  005b2	5f		 pop	 edi
  005b3	5e		 pop	 esi
  005b4	5d		 pop	 ebp
  005b5	5b		 pop	 ebx
  005b6	33 cc		 xor	 ecx, esp
  005b8	e8 00 00 00 00	 call	 @__security_check_cookie@4
  005bd	81 c4 24 04 00
	00		 add	 esp, 1060		; 00000424H
  005c3	c3		 ret	 0
$LN53@Railgun_Qu:

; 2237 :          if ( *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) return((pbTarget-3));

  005c4	8d 46 fd	 lea	 eax, DWORD PTR [esi-3]

; 2242 :             return(NULL);

  005c7	eb e2		 jmp	 SHORT $LN13@Railgun_Qu
$LN46@Railgun_Qu:

; 2243 :     }
; 2244 : } else {
; 2245 : }
; 2246 :     for ( ;; )
; 2247 :     {
; 2248 :         // The line below gives for 'cbPattern'>=1:
; 2249 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 2250 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 2251 : /*
; 2252 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 2253 :             return((long)(pbTarget-cbPattern));
; 2254 : */
; 2255 : 
; 2256 :         // The fragment below gives for 'cbPattern'>=2:
; 2257 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 2258 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 2259 : 
; 2260 : /*
; 2261 : //For 2 and 3 [
; 2262 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 2263 : //         count = countSTATIC;
; 2264 :          count = cbPattern-2;
; 2265 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 2266 :          while ( count && *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) { // Crippling i.e. only 2 and 3 chars are allowed!
; 2267 :                count--;
; 2268 :          }
; 2269 :          if ( count == 0) return((pbTarget-cbPattern));
; 2270 :         }
; 2271 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-cbPattern+1) ) pbTarget++;
; 2272 : //For 2 and 3 ]
; 2273 : */
; 2274 : 
; 2275 : 
; 2276 :         if ( ulHashPattern == ( (*(char *)(pbTarget-2))<<8 ) + *(pbTarget-1) )

  005c9	8a 46 ff	 mov	 al, BYTE PTR [esi-1]
  005cc	0f be 56 fe	 movsx	 edx, BYTE PTR [esi-2]
  005d0	0f be d8	 movsx	 ebx, al
  005d3	c1 e2 08	 shl	 edx, 8
  005d6	03 d3		 add	 edx, ebx
  005d8	3b ca		 cmp	 ecx, edx
  005da	74 22		 je	 SHORT $LN55@Railgun_Qu
  005dc	8b d1		 mov	 edx, ecx
  005de	c1 ea 08	 shr	 edx, 8
$LL32@Railgun_Qu:

; 2278 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-1) ) pbTarget++;

  005e1	3a d0		 cmp	 dl, al
  005e3	74 01		 je	 SHORT $LN73@Railgun_Qu
  005e5	46		 inc	 esi
$LN73@Railgun_Qu:

; 2279 : 
; 2280 : 
; 2281 :         // The fragment below gives for 'cbPattern'>=2:
; 2282 : 	// Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/554
; 2283 : 	// Karp_Rabin_Kaze_4_OCTETS performance: 364KB/clock
; 2284 : /*
; 2285 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 2286 :          count = countSTATIC>>2;
; 2287 :          countRemainder = countSTATIC % 4;
; 2288 : 
; 2289 :          while ( count && *(unsigned long *)(pbPattern+1+((count-1)<<2)) == *(unsigned long *)(pbTarget-cbPattern+1+((count-1)<<2)) ) {
; 2290 :                count--;
; 2291 :          }
; 2292 : 	 //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.
; 2293 :          while ( countRemainder && *(char *)(pbPattern+1+(countSTATIC-countRemainder)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-countRemainder)) ) {
; 2294 :                countRemainder--;
; 2295 :          }
; 2296 :          //if ( countRemainder == 0) return((long)(pbTarget-cbPattern));
; 2297 :          if ( count+countRemainder == 0) return((long)(pbTarget-cbPattern));
; 2298 :          //}
; 2299 :         }
; 2300 : */
; 2301 : 
; 2302 :         pbTarget++;

  005e6	46		 inc	 esi

; 2303 :         if (pbTarget > pbTargetMax)

  005e7	3b f7		 cmp	 esi, edi
  005e9	77 be		 ja	 SHORT $LN5@Railgun_Qu

; 2243 :     }
; 2244 : } else {
; 2245 : }
; 2246 :     for ( ;; )
; 2247 :     {
; 2248 :         // The line below gives for 'cbPattern'>=1:
; 2249 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 2250 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 2251 : /*
; 2252 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 2253 :             return((long)(pbTarget-cbPattern));
; 2254 : */
; 2255 : 
; 2256 :         // The fragment below gives for 'cbPattern'>=2:
; 2257 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 2258 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 2259 : 
; 2260 : /*
; 2261 : //For 2 and 3 [
; 2262 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 2263 : //         count = countSTATIC;
; 2264 :          count = cbPattern-2;
; 2265 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 2266 :          while ( count && *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) { // Crippling i.e. only 2 and 3 chars are allowed!
; 2267 :                count--;
; 2268 :          }
; 2269 :          if ( count == 0) return((pbTarget-cbPattern));
; 2270 :         }
; 2271 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-cbPattern+1) ) pbTarget++;
; 2272 : //For 2 and 3 ]
; 2273 : */
; 2274 : 
; 2275 : 
; 2276 :         if ( ulHashPattern == ( (*(char *)(pbTarget-2))<<8 ) + *(pbTarget-1) )

  005eb	8a 46 ff	 mov	 al, BYTE PTR [esi-1]
  005ee	0f be 5e fe	 movsx	 ebx, BYTE PTR [esi-2]
  005f2	0f be e8	 movsx	 ebp, al
  005f5	c1 e3 08	 shl	 ebx, 8
  005f8	03 dd		 add	 ebx, ebp
  005fa	3b cb		 cmp	 ecx, ebx
  005fc	75 e3		 jne	 SHORT $LL32@Railgun_Qu
$LN55@Railgun_Qu:

; 2277 :             return((pbTarget-2));

  005fe	8d 46 fe	 lea	 eax, DWORD PTR [esi-2]

; 2304 :             return(NULL);

  00601	eb a8		 jmp	 SHORT $LN13@Railgun_Qu
$LN41@Railgun_Qu:

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

  00603	81 fb c1 03 00
	00		 cmp	 ebx, 961		; 000003c1H
  00609	0f 83 dc 00 00
	00		 jae	 $LN26@Railgun_Qu

; 2308 : {
; 2309 :         pbTarget = pbTarget+cbPattern;
; 2310 :         ulHashPattern = *(unsigned long *)(pbPattern);

  0060f	8b 0a		 mov	 ecx, DWORD PTR [edx]

; 2311 : //        countSTATIC = cbPattern-1;
; 2312 : 
; 2313 :     //SINGLET = *(char *)(pbPattern);
; 2314 :     SINGLET = ulHashPattern & 0xFF;
; 2315 :     Quadruplet2nd = SINGLET<<8;

  00611	0f b6 c1	 movzx	 eax, cl
  00614	8b f8		 mov	 edi, eax

; 2316 :     Quadruplet3rd = SINGLET<<16;

  00616	8b d0		 mov	 edx, eax
  00618	c1 e7 08	 shl	 edi, 8
  0061b	c1 e2 10	 shl	 edx, 16			; 00000010H
  0061e	03 f5		 add	 esi, ebp
  00620	89 44 24 28	 mov	 DWORD PTR tv565[esp+1076], eax

; 2317 :     Quadruplet4th = SINGLET<<24;

  00624	c1 e0 18	 shl	 eax, 24			; 00000018H
  00627	89 4c 24 2c	 mov	 DWORD PTR _ulHashPattern$[esp+1076], ecx
  0062b	89 7c 24 20	 mov	 DWORD PTR _Quadruplet2nd$[esp+1076], edi
  0062f	89 54 24 14	 mov	 DWORD PTR _Quadruplet3rd$[esp+1076], edx
  00633	89 44 24 18	 mov	 DWORD PTR _Quadruplet4th$[esp+1076], eax
$LL25@Railgun_Qu:

; 2318 : 
; 2319 :     for ( ;; )
; 2320 :     {
; 2321 : 	AdvanceHopperGrass = 0;
; 2322 : 	ulHashTarget = *(unsigned long *)(pbTarget-cbPattern);

  00637	8b c6		 mov	 eax, esi
  00639	2b c5		 sub	 eax, ebp
  0063b	8b 00		 mov	 eax, DWORD PTR [eax]
  0063d	33 d2		 xor	 edx, edx
  0063f	89 54 24 1c	 mov	 DWORD PTR _AdvanceHopperGrass$[esp+1076], edx

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

  00643	3b c8		 cmp	 ecx, eax
  00645	75 59		 jne	 SHORT $LN23@Railgun_Qu

; 2325 : //         count = countSTATIC;
; 2326 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 2327 : //	       if ( countSTATIC==AdvanceHopperGrass+count && SINGLET != *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) AdvanceHopperGrass++;
; 2328 : //               count--;
; 2329 : //         }
; 2330 :          count = cbPattern-1;

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

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

  0064a	85 c0		 test	 eax, eax
  0064c	74 3f		 je	 SHORT $LN65@Railgun_Qu

; 2325 : //         count = countSTATIC;
; 2326 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 2327 : //	       if ( countSTATIC==AdvanceHopperGrass+count && SINGLET != *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) AdvanceHopperGrass++;
; 2328 : //               count--;
; 2329 : //         }
; 2330 :          count = cbPattern-1;

  0064e	8b 4c 24 10	 mov	 ecx, DWORD PTR _pbPattern$GSCopy$[esp+1076]
  00652	8b fe		 mov	 edi, esi
  00654	2b c8		 sub	 ecx, eax
  00656	2b f8		 sub	 edi, eax
  00658	03 cd		 add	 ecx, ebp
  0065a	8d 9b 00 00 00
	00		 npad	 6
$LL22@Railgun_Qu:

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

  00660	8a 1f		 mov	 bl, BYTE PTR [edi]
  00662	38 19		 cmp	 BYTE PTR [ecx], bl
  00664	75 30		 jne	 SHORT $LN21@Railgun_Qu

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

  00666	8d 1c 10	 lea	 ebx, DWORD PTR [eax+edx]
  00669	8d 55 ff	 lea	 edx, DWORD PTR [ebp-1]
  0066c	3b d3		 cmp	 edx, ebx
  0066e	75 14		 jne	 SHORT $LN68@Railgun_Qu
  00670	0f be 17	 movsx	 edx, BYTE PTR [edi]
  00673	39 54 24 28	 cmp	 DWORD PTR tv565[esp+1076], edx
  00677	74 0b		 je	 SHORT $LN68@Railgun_Qu
  00679	8b 54 24 1c	 mov	 edx, DWORD PTR _AdvanceHopperGrass$[esp+1076]
  0067d	42		 inc	 edx
  0067e	89 54 24 1c	 mov	 DWORD PTR _AdvanceHopperGrass$[esp+1076], edx
  00682	eb 04		 jmp	 SHORT $LN20@Railgun_Qu
$LN68@Railgun_Qu:
  00684	8b 54 24 1c	 mov	 edx, DWORD PTR _AdvanceHopperGrass$[esp+1076]
$LN20@Railgun_Qu:

; 2333 :                count--;

  00688	41		 inc	 ecx
  00689	47		 inc	 edi
  0068a	48		 dec	 eax
  0068b	75 d3		 jne	 SHORT $LL22@Railgun_Qu
$LN65@Railgun_Qu:

; 2334 :          }
; 2335 :          if ( count == 0) return((pbTarget-cbPattern));

  0068d	8b c6		 mov	 eax, esi
  0068f	2b c5		 sub	 eax, ebp

; 2350 :             return(NULL);

  00691	e9 15 ff ff ff	 jmp	 $LN13@Railgun_Qu
$LN21@Railgun_Qu:

; 2334 :          }
; 2335 :          if ( count == 0) return((pbTarget-cbPattern));

  00696	85 c0		 test	 eax, eax
  00698	74 f3		 je	 SHORT $LN65@Railgun_Qu

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

  0069a	8b 4c 24 2c	 mov	 ecx, DWORD PTR _ulHashPattern$[esp+1076]
  0069e	eb 34		 jmp	 SHORT $LN70@Railgun_Qu
$LN23@Railgun_Qu:

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

  006a0	8b d8		 mov	 ebx, eax
  006a2	81 e3 00 ff 00
	00		 and	 ebx, 65280		; 0000ff00H
  006a8	3b fb		 cmp	 edi, ebx
  006aa	74 28		 je	 SHORT $LN70@Railgun_Qu

; 2338 :          AdvanceHopperGrass++;
; 2339 :          if ( Quadruplet3rd != (ulHashTarget & 0x00FF0000) ) {

  006ac	8b f8		 mov	 edi, eax
  006ae	81 e7 00 00 ff
	00		 and	 edi, 16711680		; 00ff0000H
  006b4	ba 01 00 00 00	 mov	 edx, 1
  006b9	39 7c 24 14	 cmp	 DWORD PTR _Quadruplet3rd$[esp+1076], edi
  006bd	74 15		 je	 SHORT $LN70@Railgun_Qu

; 2340 :               AdvanceHopperGrass++;
; 2341 :               if ( Quadruplet4th != (ulHashTarget & 0xFF000000) ) AdvanceHopperGrass++;

  006bf	25 00 00 00 ff	 and	 eax, -16777216		; ff000000H
  006c4	ba 02 00 00 00	 mov	 edx, 2
  006c9	39 44 24 18	 cmp	 DWORD PTR _Quadruplet4th$[esp+1076], eax
  006cd	74 05		 je	 SHORT $LN70@Railgun_Qu
  006cf	ba 03 00 00 00	 mov	 edx, 3
$LN70@Railgun_Qu:

; 2342 :          }
; 2343 :     }
; 2344 : 	}
; 2345 : 
; 2346 : 	AdvanceHopperGrass++;
; 2347 : 
; 2348 : 	pbTarget = pbTarget + AdvanceHopperGrass;

  006d4	8d 74 16 01	 lea	 esi, DWORD PTR [esi+edx+1]

; 2349 :         if (pbTarget > pbTargetMax)

  006d8	3b 74 24 24	 cmp	 esi, DWORD PTR _pbTargetMax$[esp+1076]
  006dc	0f 87 c7 fe ff
	ff		 ja	 $LN5@Railgun_Qu

; 2351 :     }

  006e2	8b 7c 24 20	 mov	 edi, DWORD PTR _Quadruplet2nd$[esp+1076]
  006e6	e9 4c ff ff ff	 jmp	 $LL25@Railgun_Qu
$LN26@Railgun_Qu:

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

  006eb	8d 45 fe	 lea	 eax, DWORD PTR [ebp-2]
  006ee	89 44 24 18	 mov	 DWORD PTR _countSTATIC$[esp+1076], eax

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

  006f2	8b c5		 mov	 eax, ebp
  006f4	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  006f9	8d 7c 24 30	 lea	 edi, DWORD PTR _bm_bc$[esp+1076]
  006fd	f3 ab		 rep stosd

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

  006ff	8d 7d ff	 lea	 edi, DWORD PTR [ebp-1]
  00702	33 c0		 xor	 eax, eax
  00704	85 ff		 test	 edi, edi
  00706	74 1a		 je	 SHORT $LN7@Railgun_Qu
  00708	8d 4d ff	 lea	 ecx, DWORD PTR [ebp-1]
  0070b	eb 07		 jmp	 SHORT $LN9@Railgun_Qu
  0070d	8d 49 00	 npad	 3
$LL69@Railgun_Qu:
  00710	8b 54 24 10	 mov	 edx, DWORD PTR _pbPattern$GSCopy$[esp+1076]
$LN9@Railgun_Qu:
  00714	0f be 14 02	 movsx	 edx, BYTE PTR [edx+eax]
  00718	89 4c 94 30	 mov	 DWORD PTR _bm_bc$[esp+edx*4+1076], ecx
  0071c	40		 inc	 eax
  0071d	49		 dec	 ecx
  0071e	3b c7		 cmp	 eax, edi
  00720	72 ee		 jb	 SHORT $LL69@Railgun_Qu
$LN7@Railgun_Qu:

; 2357 : 
; 2358 :     /* Searching */
; 2359 :     //lastch=pbPattern[cbPattern-1];
; 2360 :     //firstch=pbPattern[0];
; 2361 :     i=0;
; 2362 :     while (i <= cbTarget-cbPattern) {

  00722	8b 7c 24 10	 mov	 edi, DWORD PTR _pbPattern$GSCopy$[esp+1076]
  00726	0f be 4c 2f ff	 movsx	 ecx, BYTE PTR [edi+ebp-1]
  0072b	33 d2		 xor	 edx, edx
  0072d	2b dd		 sub	 ebx, ebp
  0072f	8d 44 2e ff	 lea	 eax, DWORD PTR [esi+ebp-1]
  00733	89 5c 24 14	 mov	 DWORD PTR $T7117[esp+1076], ebx
  00737	89 44 24 20	 mov	 DWORD PTR tv594[esp+1076], eax
  0073b	89 4c 24 24	 mov	 DWORD PTR tv392[esp+1076], ecx
  0073f	90		 npad	 1
$LL6@Railgun_Qu:

; 2363 :        ch=pbTarget[i+cbPattern-1];
; 2364 :        //if (ch ==lastch)
; 2365 :           //if (memcmp(&pbTarget[i],pbPattern,cbPattern-1) == 0) OUTPUT(i);
; 2366 :           //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".
; 2367 :           if (ch == pbPattern[cbPattern-1] && pbTarget[i] == pbPattern[0])

  00740	8b 44 24 20	 mov	 eax, DWORD PTR tv594[esp+1076]
  00744	0f b6 2c 10	 movzx	 ebp, BYTE PTR [eax+edx]
  00748	3b 6c 24 24	 cmp	 ebp, DWORD PTR tv392[esp+1076]
  0074c	75 2f		 jne	 SHORT $LN1@Railgun_Qu
  0074e	8a 0c 32	 mov	 cl, BYTE PTR [edx+esi]
  00751	3a 0f		 cmp	 cl, BYTE PTR [edi]
  00753	75 28		 jne	 SHORT $LN1@Railgun_Qu

; 2368 :              {
; 2369 :          count = countSTATIC;

  00755	8b 44 24 18	 mov	 eax, DWORD PTR _countSTATIC$[esp+1076]

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

  00759	85 c0		 test	 eax, eax
  0075b	74 10		 je	 SHORT $LN59@Railgun_Qu

; 2368 :              {
; 2369 :          count = countSTATIC;

  0075d	47		 inc	 edi
  0075e	8d 4c 32 01	 lea	 ecx, DWORD PTR [edx+esi+1]
$LL3@Railgun_Qu:

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

  00762	8a 1f		 mov	 bl, BYTE PTR [edi]
  00764	3a 19		 cmp	 bl, BYTE PTR [ecx]
  00766	75 0d		 jne	 SHORT $LN2@Railgun_Qu

; 2371 :                count--;

  00768	41		 inc	 ecx
  00769	47		 inc	 edi
  0076a	48		 dec	 eax
  0076b	75 f5		 jne	 SHORT $LL3@Railgun_Qu
$LN59@Railgun_Qu:

; 2372 :          }
; 2373 :          if ( count == 0) return(pbTarget+i);

  0076d	8d 04 32	 lea	 eax, DWORD PTR [edx+esi]
  00770	e9 36 fe ff ff	 jmp	 $LN13@Railgun_Qu
$LN2@Railgun_Qu:
  00775	85 c0		 test	 eax, eax
  00777	74 f4		 je	 SHORT $LN59@Railgun_Qu
  00779	8b 7c 24 10	 mov	 edi, DWORD PTR _pbPattern$GSCopy$[esp+1076]
$LN1@Railgun_Qu:

; 2374 : 	     }
; 2375 :        i+=bm_bc[ch];

  0077d	03 54 ac 30	 add	 edx, DWORD PTR _bm_bc$[esp+ebp*4+1076]
  00781	3b 54 24 14	 cmp	 edx, DWORD PTR $T7117[esp+1076]
  00785	76 b9		 jbe	 SHORT $LL6@Railgun_Qu

; 2357 : 
; 2358 :     /* Searching */
; 2359 :     //lastch=pbPattern[cbPattern-1];
; 2360 :     //firstch=pbPattern[0];
; 2361 :     i=0;
; 2362 :     while (i <= cbTarget-cbPattern) {

  00787	e9 1d fe ff ff	 jmp	 $LN5@Railgun_Qu
_Railgun_Quadruplet ENDP
_TEXT	ENDS
PUBLIC	_pbPattern$GSCopy$
PUBLIC	__$ArrayPad$
PUBLIC	_Railgun_Quadruplet_6pp
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
$T7152 = -1060						; size = 4
_Quadruplet2nd$ = -1060					; size = 4
_AdvanceHopperGrass$ = -1056				; size = 4
tv595 = -1052						; size = 4
_Quadruplet3rd$ = -1052					; size = 4
_ulHashPattern$ = -1048					; size = 4
_countSTATIC$ = -1044					; size = 4
_Quadruplet4th$ = -1044					; size = 4
_pbPattern$GSCopy$ = -1040				; size = 4
tv392 = -1036						; size = 4
_pbTargetMax$ = -1036					; size = 4
tv566 = -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_6pp PROC

; 2390 : {

  00790	81 ec 24 04 00
	00		 sub	 esp, 1060		; 00000424H
  00796	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  0079b	33 c4		 xor	 eax, esp
  0079d	89 84 24 20 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1060], eax

; 2391 :     char * pbTargetMax = pbTarget + cbTarget;
; 2392 :     register unsigned long  ulHashPattern;
; 2393 :     unsigned long ulHashTarget;
; 2394 :     //unsigned long count; //r.6+
; 2395 :     signed long count;
; 2396 :     //unsigned long countSTATIC; //r.6+
; 2397 :     signed long countSTATIC;
; 2398 : //  unsigned long countRemainder;
; 2399 : 
; 2400 : /*
; 2401 :     const unsigned char SINGLET = *(char *)(pbPattern);
; 2402 :     const unsigned long Quadruplet2nd = SINGLET<<8;
; 2403 :     const unsigned long Quadruplet3rd = SINGLET<<16;
; 2404 :     const unsigned long Quadruplet4th = SINGLET<<24;
; 2405 : */
; 2406 :     unsigned char SINGLET;
; 2407 :     unsigned long Quadruplet2nd;
; 2408 :     unsigned long Quadruplet3rd;
; 2409 :     unsigned long Quadruplet4th;
; 2410 : 
; 2411 :     unsigned long  AdvanceHopperGrass;
; 2412 : 
; 2413 :     long i; //BMH needed
; 2414 :     int a, j, bm_bc[ASIZE]; //BMH needed
; 2415 :     unsigned char ch; //BMH needed
; 2416 : //    unsigned char lastch, firstch; //BMH needed
; 2417 : 
; 2418 :     if (cbPattern > cbTarget)

  007a4	8b 94 24 34 04
	00 00		 mov	 edx, DWORD PTR _cbPattern$[esp+1056]
  007ab	53		 push	 ebx
  007ac	8b 9c 24 30 04
	00 00		 mov	 ebx, DWORD PTR _pbPattern$[esp+1060]
  007b3	55		 push	 ebp
  007b4	8b ac 24 30 04
	00 00		 mov	 ebp, DWORD PTR _pbTarget$[esp+1064]
  007bb	56		 push	 esi
  007bc	8b b4 24 3c 04
	00 00		 mov	 esi, DWORD PTR _cbTarget$[esp+1068]
  007c3	57		 push	 edi
  007c4	8d 3c 2e	 lea	 edi, DWORD PTR [esi+ebp]
  007c7	89 5c 24 24	 mov	 DWORD PTR _pbPattern$GSCopy$[esp+1076], ebx
  007cb	89 7c 24 28	 mov	 DWORD PTR _pbTargetMax$[esp+1076], edi
  007cf	3b d6		 cmp	 edx, esi

; 2419 :         return(NULL);

  007d1	77 46		 ja	 SHORT $LN5@Railgun_Qu@2

; 2420 : 
; 2421 : // Doesn't work when cbPattern = 1
; 2422 : // 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!
; 2423 : 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.

  007d3	83 fa 04	 cmp	 edx, 4
  007d6	0f 83 97 00 00
	00		 jae	 $LN41@Railgun_Qu@2

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

  007dc	0f be 03	 movsx	 eax, BYTE PTR [ebx]
  007df	0f be 4c 13 ff	 movsx	 ecx, BYTE PTR [ebx+edx-1]
  007e4	c1 e0 08	 shl	 eax, 8
  007e7	03 ea		 add	 ebp, edx
  007e9	03 c8		 add	 ecx, eax

; 2426 : //        countSTATIC = cbPattern-2;
; 2427 : 
; 2428 : if ( cbPattern==3) {

  007eb	83 fa 03	 cmp	 edx, 3
  007ee	75 49		 jne	 SHORT $LN46@Railgun_Qu@2
$LL39@Railgun_Qu@2:

; 2429 :     for ( ;; )
; 2430 :     {
; 2431 :         if ( ulHashPattern == ( (*(char *)(pbTarget-3))<<8 ) + *(pbTarget-1) ) {

  007f0	0f be 55 fd	 movsx	 edx, BYTE PTR [ebp-3]
  007f4	0f be 45 ff	 movsx	 eax, BYTE PTR [ebp-1]
  007f8	c1 e2 08	 shl	 edx, 8
  007fb	03 d0		 add	 edx, eax
  007fd	3b ca		 cmp	 ecx, edx
  007ff	75 08		 jne	 SHORT $LN36@Railgun_Qu@2

; 2432 :          if ( *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) return((pbTarget-3));

  00801	8a 53 01	 mov	 dl, BYTE PTR [ebx+1]
  00804	3a 55 fe	 cmp	 dl, BYTE PTR [ebp-2]
  00807	74 2b		 je	 SHORT $LN53@Railgun_Qu@2
$LN36@Railgun_Qu@2:

; 2433 :         }
; 2434 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-2) ) pbTarget++;

  00809	8b c1		 mov	 eax, ecx
  0080b	c1 e8 08	 shr	 eax, 8
  0080e	3a 45 fe	 cmp	 al, BYTE PTR [ebp-2]
  00811	74 01		 je	 SHORT $LN35@Railgun_Qu@2
  00813	45		 inc	 ebp
$LN35@Railgun_Qu@2:

; 2435 :         pbTarget++;

  00814	45		 inc	 ebp

; 2436 :         if (pbTarget > pbTargetMax)

  00815	3b ef		 cmp	 ebp, edi
  00817	76 d7		 jbe	 SHORT $LL39@Railgun_Qu@2
$LN5@Railgun_Qu@2:

; 2580 :     }
; 2581 :     return(NULL);

  00819	33 c0		 xor	 eax, eax
$LN13@Railgun_Qu@2:

; 2582 : } //if (cbTarget<961)
; 2583 : } //if ( cbPattern<4)
; 2584 : }

  0081b	8b 8c 24 30 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1076]
  00822	5f		 pop	 edi
  00823	5e		 pop	 esi
  00824	5d		 pop	 ebp
  00825	5b		 pop	 ebx
  00826	33 cc		 xor	 ecx, esp
  00828	e8 00 00 00 00	 call	 @__security_check_cookie@4
  0082d	81 c4 24 04 00
	00		 add	 esp, 1060		; 00000424H
  00833	c3		 ret	 0
$LN53@Railgun_Qu@2:

; 2432 :          if ( *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) return((pbTarget-3));

  00834	8d 45 fd	 lea	 eax, DWORD PTR [ebp-3]

; 2437 :             return(NULL);

  00837	eb e2		 jmp	 SHORT $LN13@Railgun_Qu@2
$LN46@Railgun_Qu@2:

; 2438 :     }
; 2439 : } else {
; 2440 : }
; 2441 :     for ( ;; )
; 2442 :     {
; 2443 :         // The line below gives for 'cbPattern'>=1:
; 2444 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 2445 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 2446 : /*
; 2447 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 2448 :             return((long)(pbTarget-cbPattern));
; 2449 : */
; 2450 : 
; 2451 :         // The fragment below gives for 'cbPattern'>=2:
; 2452 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 2453 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 2454 : 
; 2455 : /*
; 2456 : //For 2 and 3 [
; 2457 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 2458 : //         count = countSTATIC;
; 2459 :          count = cbPattern-2;
; 2460 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 2461 :          while ( count && *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) { // Crippling i.e. only 2 and 3 chars are allowed!
; 2462 :                count--;
; 2463 :          }
; 2464 :          if ( count == 0) return((pbTarget-cbPattern));
; 2465 :         }
; 2466 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-cbPattern+1) ) pbTarget++;
; 2467 : //For 2 and 3 ]
; 2468 : */
; 2469 : 
; 2470 : 
; 2471 :         if ( ulHashPattern == ( (*(char *)(pbTarget-2))<<8 ) + *(pbTarget-1) )

  00839	8a 45 ff	 mov	 al, BYTE PTR [ebp-1]
  0083c	0f be 55 fe	 movsx	 edx, BYTE PTR [ebp-2]
  00840	0f be f0	 movsx	 esi, al
  00843	c1 e2 08	 shl	 edx, 8
  00846	03 d6		 add	 edx, esi
  00848	3b ca		 cmp	 ecx, edx
  0084a	74 22		 je	 SHORT $LN55@Railgun_Qu@2
  0084c	8b d1		 mov	 edx, ecx
  0084e	c1 ea 08	 shr	 edx, 8
$LL32@Railgun_Qu@2:

; 2473 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-1) ) pbTarget++;

  00851	3a d0		 cmp	 dl, al
  00853	74 01		 je	 SHORT $LN71@Railgun_Qu@2
  00855	45		 inc	 ebp
$LN71@Railgun_Qu@2:

; 2474 : 
; 2475 : 
; 2476 :         // The fragment below gives for 'cbPattern'>=2:
; 2477 : 	// Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/554
; 2478 : 	// Karp_Rabin_Kaze_4_OCTETS performance: 364KB/clock
; 2479 : /*
; 2480 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 2481 :          count = countSTATIC>>2;
; 2482 :          countRemainder = countSTATIC % 4;
; 2483 : 
; 2484 :          while ( count && *(unsigned long *)(pbPattern+1+((count-1)<<2)) == *(unsigned long *)(pbTarget-cbPattern+1+((count-1)<<2)) ) {
; 2485 :                count--;
; 2486 :          }
; 2487 : 	 //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.
; 2488 :          while ( countRemainder && *(char *)(pbPattern+1+(countSTATIC-countRemainder)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-countRemainder)) ) {
; 2489 :                countRemainder--;
; 2490 :          }
; 2491 :          //if ( countRemainder == 0) return((long)(pbTarget-cbPattern));
; 2492 :          if ( count+countRemainder == 0) return((long)(pbTarget-cbPattern));
; 2493 :          //}
; 2494 :         }
; 2495 : */
; 2496 : 
; 2497 :         pbTarget++;

  00856	45		 inc	 ebp

; 2498 :         if (pbTarget > pbTargetMax)

  00857	3b ef		 cmp	 ebp, edi
  00859	77 be		 ja	 SHORT $LN5@Railgun_Qu@2

; 2438 :     }
; 2439 : } else {
; 2440 : }
; 2441 :     for ( ;; )
; 2442 :     {
; 2443 :         // The line below gives for 'cbPattern'>=1:
; 2444 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 2445 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 2446 : /*
; 2447 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 2448 :             return((long)(pbTarget-cbPattern));
; 2449 : */
; 2450 : 
; 2451 :         // The fragment below gives for 'cbPattern'>=2:
; 2452 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 2453 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 2454 : 
; 2455 : /*
; 2456 : //For 2 and 3 [
; 2457 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 2458 : //         count = countSTATIC;
; 2459 :          count = cbPattern-2;
; 2460 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 2461 :          while ( count && *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) { // Crippling i.e. only 2 and 3 chars are allowed!
; 2462 :                count--;
; 2463 :          }
; 2464 :          if ( count == 0) return((pbTarget-cbPattern));
; 2465 :         }
; 2466 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-cbPattern+1) ) pbTarget++;
; 2467 : //For 2 and 3 ]
; 2468 : */
; 2469 : 
; 2470 : 
; 2471 :         if ( ulHashPattern == ( (*(char *)(pbTarget-2))<<8 ) + *(pbTarget-1) )

  0085b	8a 45 ff	 mov	 al, BYTE PTR [ebp-1]
  0085e	0f be 75 fe	 movsx	 esi, BYTE PTR [ebp-2]
  00862	0f be d8	 movsx	 ebx, al
  00865	c1 e6 08	 shl	 esi, 8
  00868	03 f3		 add	 esi, ebx
  0086a	3b ce		 cmp	 ecx, esi
  0086c	75 e3		 jne	 SHORT $LL32@Railgun_Qu@2
$LN55@Railgun_Qu@2:

; 2472 :             return((pbTarget-2));

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

; 2499 :             return(NULL);

  00871	eb a8		 jmp	 SHORT $LN13@Railgun_Qu@2
$LN41@Railgun_Qu@2:

; 2500 :     }
; 2501 : } else { //if ( cbPattern<4)
; 2502 : if (cbTarget<961) // This value is arbitrary(don't know how exactly), it ensures(at least must) better performance than 'Boyer_Moore_Horspool'.
; 2503 : {
; 2504 :         pbTarget = pbTarget+cbPattern;
; 2505 :         ulHashPattern = *(unsigned long *)(pbPattern);

  00873	8b 0b		 mov	 ecx, DWORD PTR [ebx]
  00875	89 4c 24 1c	 mov	 DWORD PTR _ulHashPattern$[esp+1076], ecx
  00879	81 fe c1 03 00
	00		 cmp	 esi, 961		; 000003c1H
  0087f	0f 83 d3 00 00
	00		 jae	 $LN26@Railgun_Qu@2

; 2506 : //        countSTATIC = cbPattern-1;
; 2507 : 
; 2508 :     //SINGLET = *(char *)(pbPattern);
; 2509 :     SINGLET = ulHashPattern & 0xFF;
; 2510 :     Quadruplet2nd = SINGLET<<8;

  00885	0f b6 c1	 movzx	 eax, cl
  00888	8b f0		 mov	 esi, eax
  0088a	c1 e6 08	 shl	 esi, 8
  0088d	89 74 24 10	 mov	 DWORD PTR _Quadruplet2nd$[esp+1076], esi

; 2511 :     Quadruplet3rd = SINGLET<<16;

  00891	8b f0		 mov	 esi, eax
  00893	c1 e6 10	 shl	 esi, 16			; 00000010H
  00896	03 ea		 add	 ebp, edx
  00898	89 44 24 2c	 mov	 DWORD PTR tv566[esp+1076], eax

; 2512 :     Quadruplet4th = SINGLET<<24;

  0089c	c1 e0 18	 shl	 eax, 24			; 00000018H
  0089f	89 74 24 18	 mov	 DWORD PTR _Quadruplet3rd$[esp+1076], esi
  008a3	89 44 24 20	 mov	 DWORD PTR _Quadruplet4th$[esp+1076], eax
$LL25@Railgun_Qu@2:

; 2513 : 
; 2514 :     for ( ;; )
; 2515 :     {
; 2516 : 	AdvanceHopperGrass = 0;
; 2517 : 	ulHashTarget = *(unsigned long *)(pbTarget-cbPattern);

  008a7	8b c5		 mov	 eax, ebp
  008a9	2b c2		 sub	 eax, edx
  008ab	8b 00		 mov	 eax, DWORD PTR [eax]
  008ad	33 db		 xor	 ebx, ebx
  008af	89 5c 24 14	 mov	 DWORD PTR _AdvanceHopperGrass$[esp+1076], ebx

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

  008b3	3b c8		 cmp	 ecx, eax
  008b5	75 54		 jne	 SHORT $LN23@Railgun_Qu@2

; 2520 : //         count = countSTATIC;
; 2521 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 2522 : //	       if ( countSTATIC==AdvanceHopperGrass+count && SINGLET != *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) AdvanceHopperGrass++;
; 2523 : //               count--;
; 2524 : //         }
; 2525 :          count = cbPattern-1;

  008b7	8d 42 ff	 lea	 eax, DWORD PTR [edx-1]

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

  008ba	85 c0		 test	 eax, eax
  008bc	74 3e		 je	 SHORT $LN65@Railgun_Qu@2

; 2520 : //         count = countSTATIC;
; 2521 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 2522 : //	       if ( countSTATIC==AdvanceHopperGrass+count && SINGLET != *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) AdvanceHopperGrass++;
; 2523 : //               count--;
; 2524 : //         }
; 2525 :          count = cbPattern-1;

  008be	8b 74 24 24	 mov	 esi, DWORD PTR _pbPattern$GSCopy$[esp+1076]
  008c2	8b fd		 mov	 edi, ebp
  008c4	2b f0		 sub	 esi, eax
  008c6	2b f8		 sub	 edi, eax
  008c8	03 f2		 add	 esi, edx
  008ca	8d 9b 00 00 00
	00		 npad	 6
$LL22@Railgun_Qu@2:

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

  008d0	8a 0f		 mov	 cl, BYTE PTR [edi]
  008d2	38 0e		 cmp	 BYTE PTR [esi], cl
  008d4	75 2f		 jne	 SHORT $LN21@Railgun_Qu@2

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

  008d6	8d 4a ff	 lea	 ecx, DWORD PTR [edx-1]
  008d9	03 d8		 add	 ebx, eax
  008db	3b cb		 cmp	 ecx, ebx
  008dd	75 14		 jne	 SHORT $LN66@Railgun_Qu@2
  008df	0f be 0f	 movsx	 ecx, BYTE PTR [edi]
  008e2	39 4c 24 2c	 cmp	 DWORD PTR tv566[esp+1076], ecx
  008e6	74 0b		 je	 SHORT $LN66@Railgun_Qu@2
  008e8	8b 5c 24 14	 mov	 ebx, DWORD PTR _AdvanceHopperGrass$[esp+1076]
  008ec	43		 inc	 ebx
  008ed	89 5c 24 14	 mov	 DWORD PTR _AdvanceHopperGrass$[esp+1076], ebx
  008f1	eb 04		 jmp	 SHORT $LN20@Railgun_Qu@2
$LN66@Railgun_Qu@2:
  008f3	8b 5c 24 14	 mov	 ebx, DWORD PTR _AdvanceHopperGrass$[esp+1076]
$LN20@Railgun_Qu@2:

; 2528 :                count--;

  008f7	46		 inc	 esi
  008f8	47		 inc	 edi
  008f9	48		 dec	 eax
  008fa	75 d4		 jne	 SHORT $LL22@Railgun_Qu@2
$LN65@Railgun_Qu@2:

; 2529 :          }
; 2530 :          if ( count == 0) return((pbTarget-cbPattern));

  008fc	8b c5		 mov	 eax, ebp
  008fe	2b c2		 sub	 eax, edx

; 2545 :             return(NULL);

  00900	e9 16 ff ff ff	 jmp	 $LN13@Railgun_Qu@2
$LN21@Railgun_Qu@2:

; 2529 :          }
; 2530 :          if ( count == 0) return((pbTarget-cbPattern));

  00905	85 c0		 test	 eax, eax
  00907	74 f3		 je	 SHORT $LN65@Railgun_Qu@2

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

  00909	eb 36		 jmp	 SHORT $LN15@Railgun_Qu@2
$LN23@Railgun_Qu@2:

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

  0090b	8b c8		 mov	 ecx, eax
  0090d	81 e1 00 ff 00
	00		 and	 ecx, 65280		; 0000ff00H
  00913	39 4c 24 10	 cmp	 DWORD PTR _Quadruplet2nd$[esp+1076], ecx
  00917	74 28		 je	 SHORT $LN15@Railgun_Qu@2

; 2533 :          AdvanceHopperGrass++;
; 2534 :          if ( Quadruplet3rd != (ulHashTarget & 0x00FF0000) ) {

  00919	8b c8		 mov	 ecx, eax
  0091b	81 e1 00 00 ff
	00		 and	 ecx, 16711680		; 00ff0000H
  00921	bb 01 00 00 00	 mov	 ebx, 1
  00926	39 4c 24 18	 cmp	 DWORD PTR _Quadruplet3rd$[esp+1076], ecx
  0092a	74 15		 je	 SHORT $LN15@Railgun_Qu@2

; 2535 :               AdvanceHopperGrass++;
; 2536 :               if ( Quadruplet4th != (ulHashTarget & 0xFF000000) ) AdvanceHopperGrass++;

  0092c	25 00 00 00 ff	 and	 eax, -16777216		; ff000000H
  00931	bb 02 00 00 00	 mov	 ebx, 2
  00936	39 44 24 20	 cmp	 DWORD PTR _Quadruplet4th$[esp+1076], eax
  0093a	74 05		 je	 SHORT $LN15@Railgun_Qu@2
  0093c	bb 03 00 00 00	 mov	 ebx, 3
$LN15@Railgun_Qu@2:

; 2537 :          }
; 2538 :     }
; 2539 : 	}
; 2540 : 
; 2541 : 	AdvanceHopperGrass++;
; 2542 : 
; 2543 : 	pbTarget = pbTarget + AdvanceHopperGrass;

  00941	8d 6c 2b 01	 lea	 ebp, DWORD PTR [ebx+ebp+1]

; 2544 :         if (pbTarget > pbTargetMax)

  00945	3b 6c 24 28	 cmp	 ebp, DWORD PTR _pbTargetMax$[esp+1076]
  00949	0f 87 ca fe ff
	ff		 ja	 $LN5@Railgun_Qu@2

; 2546 :     }

  0094f	8b 4c 24 1c	 mov	 ecx, DWORD PTR _ulHashPattern$[esp+1076]
  00953	e9 4f ff ff ff	 jmp	 $LL25@Railgun_Qu@2
$LN26@Railgun_Qu@2:

; 2547 : } else { //if (cbTarget<961)
; 2548 :         //countSTATIC = cbPattern-2; //r.6+
; 2549 :         //countSTATIC = cbPattern-2-3;
; 2550 :         countSTATIC = cbPattern-2-2; // r.6+++ I suppose that the awful degradation comes from 2bytes more (from either 'if (countSTATIC<0) countSTATIC=0;' or 'count >0' fixes) which make the function unfittable in code cache lines?!

  00958	8d 42 fc	 lea	 eax, DWORD PTR [edx-4]
  0095b	89 44 24 20	 mov	 DWORD PTR _countSTATIC$[esp+1076], eax

; 2551 :         ulHashPattern = *(unsigned long *)(pbPattern);
; 2552 : // Next line fixes the BUG from r.6++: but with awful speed degradation! So the bug is fixed in the definitions by setting 'countSTATIC = cbPattern-2-2;', bug appears only for patterns with lengths of 4, The setback is one unnecessary comparison for 5bytes patterns, stupidly such setback exists (from before) for 4bytes as well.
; 2553 : //if (countSTATIC<0) countSTATIC=0;
; 2554 :     /* Preprocessing */
; 2555 :     for (a=0; a < ASIZE; a++) bm_bc[a]=cbPattern;

  0095f	8b c2		 mov	 eax, edx
  00961	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  00966	8d 7c 24 30	 lea	 edi, DWORD PTR _bm_bc$[esp+1076]
  0096a	f3 ab		 rep stosd

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

  0096c	8d 4a ff	 lea	 ecx, DWORD PTR [edx-1]
  0096f	33 c0		 xor	 eax, eax
  00971	85 c9		 test	 ecx, ecx
  00973	74 1d		 je	 SHORT $LN7@Railgun_Qu@2
  00975	8d 7a ff	 lea	 edi, DWORD PTR [edx-1]
  00978	eb 06 8d 9b 00
	00 00 00	 npad	 8
$LL67@Railgun_Qu@2:
  00980	0f be 1c 03	 movsx	 ebx, BYTE PTR [ebx+eax]
  00984	89 7c 9c 30	 mov	 DWORD PTR _bm_bc$[esp+ebx*4+1076], edi
  00988	8b 5c 24 24	 mov	 ebx, DWORD PTR _pbPattern$GSCopy$[esp+1076]
  0098c	40		 inc	 eax
  0098d	4f		 dec	 edi
  0098e	3b c1		 cmp	 eax, ecx
  00990	72 ee		 jb	 SHORT $LL67@Railgun_Qu@2
$LN7@Railgun_Qu@2:

; 2557 : 
; 2558 :     /* Searching */
; 2559 :     //lastch=pbPattern[cbPattern-1];
; 2560 :     //firstch=pbPattern[0];
; 2561 :     i=0;

  00992	33 ff		 xor	 edi, edi

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

  00994	2b f2		 sub	 esi, edx
  00996	8d 4c 2a ff	 lea	 ecx, DWORD PTR [edx+ebp-1]
  0099a	0f be 54 13 ff	 movsx	 edx, BYTE PTR [ebx+edx-1]
  0099f	89 74 24 10	 mov	 DWORD PTR $T7152[esp+1076], esi
  009a3	89 4c 24 18	 mov	 DWORD PTR tv595[esp+1076], ecx
  009a7	89 54 24 28	 mov	 DWORD PTR tv392[esp+1076], edx
  009ab	eb 03 8d 49 00	 npad	 5
$LL6@Railgun_Qu@2:

; 2563 :        ch=pbTarget[i+cbPattern-1];
; 2564 :        //if (ch ==lastch)
; 2565 :           //if (memcmp(&pbTarget[i],pbPattern,cbPattern-1) == 0) OUTPUT(i);
; 2566 :           //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".
; 2567 :           //if (ch == pbPattern[cbPattern-1] && pbTarget[i] == pbPattern[0]) // r.6+
; 2568 :           //if (ch == pbPattern[cbPattern-1] && *(long *)&pbTarget[i] == *(long *)&pbPattern[0]) // No problema here since we have 4[+] long pattern here. Overlapping (1 byte recompared) when length=4, grmbl.
; 2569 :           if (ch == pbPattern[cbPattern-1] && *(long *)&pbTarget[i] == ulHashPattern) // No problema here since we have 4[+] long pattern here. Overlapping (1 byte recompared) when length=4, grmbl.

  009b0	0f b6 04 39	 movzx	 eax, BYTE PTR [ecx+edi]
  009b4	3b 44 24 28	 cmp	 eax, DWORD PTR tv392[esp+1076]
  009b8	75 2b		 jne	 SHORT $LN1@Railgun_Qu@2
  009ba	8b 44 24 1c	 mov	 eax, DWORD PTR _ulHashPattern$[esp+1076]
  009be	39 04 2f	 cmp	 DWORD PTR [edi+ebp], eax
  009c1	75 22		 jne	 SHORT $LN1@Railgun_Qu@2

; 2570 :              {
; 2571 :          count = countSTATIC;

  009c3	8b 44 24 20	 mov	 eax, DWORD PTR _countSTATIC$[esp+1076]

; 2572 :          //while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+(countSTATIC-count)) ) { // r.6+
; 2573 : // A BUG (in next line) crushed from r.6++: 'count !=0' becomes 'count >0' in r.6+++ but with awful speed degradation! So the bug is fixed outside the cycles by setting 'countSTATIC' from -1 to 0, bug appears only for patterns with lengths of 4.
; 2574 :          while ( count !=0 && *(char *)(pbPattern+1+3+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+3+(countSTATIC-count)) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.

  009c7	85 c0		 test	 eax, eax
  009c9	74 2d		 je	 SHORT $LN59@Railgun_Qu@2

; 2570 :              {
; 2571 :          count = countSTATIC;

  009cb	8d 73 04	 lea	 esi, DWORD PTR [ebx+4]
  009ce	8d 4c 2f 04	 lea	 ecx, DWORD PTR [edi+ebp+4]
$LL3@Railgun_Qu@2:

; 2572 :          //while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+(countSTATIC-count)) ) { // r.6+
; 2573 : // A BUG (in next line) crushed from r.6++: 'count !=0' becomes 'count >0' in r.6+++ but with awful speed degradation! So the bug is fixed outside the cycles by setting 'countSTATIC' from -1 to 0, bug appears only for patterns with lengths of 4.
; 2574 :          while ( count !=0 && *(char *)(pbPattern+1+3+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+3+(countSTATIC-count)) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.

  009d2	8a 16		 mov	 dl, BYTE PTR [esi]
  009d4	3a 11		 cmp	 dl, BYTE PTR [ecx]
  009d6	75 05		 jne	 SHORT $LN68@Railgun_Qu@2

; 2575 :                count--;

  009d8	41		 inc	 ecx
  009d9	46		 inc	 esi
  009da	48		 dec	 eax
  009db	75 f5		 jne	 SHORT $LL3@Railgun_Qu@2
$LN68@Railgun_Qu@2:

; 2572 :          //while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+(countSTATIC-count)) ) { // r.6+
; 2573 : // A BUG (in next line) crushed from r.6++: 'count !=0' becomes 'count >0' in r.6+++ but with awful speed degradation! So the bug is fixed outside the cycles by setting 'countSTATIC' from -1 to 0, bug appears only for patterns with lengths of 4.
; 2574 :          while ( count !=0 && *(char *)(pbPattern+1+3+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+3+(countSTATIC-count)) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.

  009dd	8b 4c 24 18	 mov	 ecx, DWORD PTR tv595[esp+1076]

; 2576 :          }
; 2577 :          if ( count <= 0) return(pbTarget+i);

  009e1	85 c0		 test	 eax, eax
  009e3	7e 13		 jle	 SHORT $LN59@Railgun_Qu@2
$LN1@Railgun_Qu@2:

; 2578 : 	     }
; 2579 :        i+=bm_bc[ch];

  009e5	0f b6 04 39	 movzx	 eax, BYTE PTR [ecx+edi]
  009e9	03 7c 84 30	 add	 edi, DWORD PTR _bm_bc$[esp+eax*4+1076]
  009ed	3b 7c 24 10	 cmp	 edi, DWORD PTR $T7152[esp+1076]
  009f1	76 bd		 jbe	 SHORT $LL6@Railgun_Qu@2

; 2576 :          }
; 2577 :          if ( count <= 0) return(pbTarget+i);

  009f3	e9 21 fe ff ff	 jmp	 $LN5@Railgun_Qu@2
$LN59@Railgun_Qu@2:
  009f8	8d 04 2f	 lea	 eax, DWORD PTR [edi+ebp]
  009fb	e9 1b fe ff ff	 jmp	 $LN13@Railgun_Qu@2
_Railgun_Quadruplet_6pp ENDP
_TEXT	ENDS
PUBLIC	_pbPattern$GSCopy$
PUBLIC	__$ArrayPad$
PUBLIC	_Railgun_Quadruplet_6pp_count_hits
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
tv660 = -1061						; size = 1
_pbPattern$GSCopy$ = -1060				; size = 4
_AdvanceHopperGrass$ = -1056				; size = 4
tv457 = -1052						; size = 4
_pbTargetMax$ = -1052					; size = 4
_ulHashPattern$ = -1048					; size = 4
$T7182 = -1044						; size = 4
_Quadruplet3rd$ = -1044					; size = 4
_Quadruplet4th$ = -1040					; size = 4
tv537 = -1036						; size = 4
_Quadruplet2nd$ = -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_6pp_count_hits PROC

; 2594 : {

  00a00	81 ec 28 04 00
	00		 sub	 esp, 1064		; 00000428H
  00a06	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00a0b	33 c4		 xor	 eax, esp
  00a0d	89 84 24 24 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1064], eax

; 2595 :     char * pbTargetMax = pbTarget + cbTarget;

  00a14	8b 94 24 34 04
	00 00		 mov	 edx, DWORD PTR _cbTarget$[esp+1060]
  00a1b	53		 push	 ebx
  00a1c	8b 9c 24 30 04
	00 00		 mov	 ebx, DWORD PTR _pbTarget$[esp+1064]
  00a23	55		 push	 ebp

; 2596 :     register unsigned long  ulHashPattern;
; 2597 :     unsigned long ulHashTarget;
; 2598 :     //unsigned long count; //r.6+
; 2599 :     signed long count;
; 2600 :     //unsigned long countSTATIC; //r.6+
; 2601 :     signed long countSTATIC;
; 2602 : //  unsigned long countRemainder;
; 2603 : 
; 2604 : /*
; 2605 :     const unsigned char SINGLET = *(char *)(pbPattern);
; 2606 :     const unsigned long Quadruplet2nd = SINGLET<<8;
; 2607 :     const unsigned long Quadruplet3rd = SINGLET<<16;
; 2608 :     const unsigned long Quadruplet4th = SINGLET<<24;
; 2609 : */
; 2610 :     unsigned char SINGLET;
; 2611 :     unsigned long Quadruplet2nd;
; 2612 :     unsigned long Quadruplet3rd;
; 2613 :     unsigned long Quadruplet4th;
; 2614 : 
; 2615 :     unsigned long  AdvanceHopperGrass;
; 2616 : 
; 2617 :     long i; //BMH needed
; 2618 :     int a, j, bm_bc[ASIZE]; //BMH needed
; 2619 :     unsigned char ch; //BMH needed
; 2620 : //    unsigned char lastch, firstch; //BMH needed
; 2621 : 
; 2622 :     if (cbPattern > cbTarget)

  00a24	8b ac 24 40 04
	00 00		 mov	 ebp, DWORD PTR _cbPattern$[esp+1068]
  00a2b	56		 push	 esi
  00a2c	8b b4 24 3c 04
	00 00		 mov	 esi, DWORD PTR _pbPattern$[esp+1072]
  00a33	57		 push	 edi
  00a34	8d 3c 13	 lea	 edi, DWORD PTR [ebx+edx]
  00a37	89 74 24 14	 mov	 DWORD PTR _pbPattern$GSCopy$[esp+1080], esi
  00a3b	89 7c 24 1c	 mov	 DWORD PTR _pbTargetMax$[esp+1080], edi
  00a3f	3b ea		 cmp	 ebp, edx

; 2623 :         return(NULL);

  00a41	0f 87 10 02 00
	00		 ja	 $LN84@Railgun_Qu@3

; 2624 : 
; 2625 : // Doesn't work when cbPattern = 1
; 2626 : // 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!
; 2627 : 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.

  00a47	83 fd 04	 cmp	 ebp, 4
  00a4a	73 7d		 jae	 SHORT $LN41@Railgun_Qu@3

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

  00a4c	0f be 0e	 movsx	 ecx, BYTE PTR [esi]
  00a4f	0f be 44 2e ff	 movsx	 eax, BYTE PTR [esi+ebp-1]
  00a54	c1 e1 08	 shl	 ecx, 8
  00a57	03 c1		 add	 eax, ecx

; 2630 : //        countSTATIC = cbPattern-2;
; 2631 : 
; 2632 : if ( cbPattern==3) {

  00a59	8b c8		 mov	 ecx, eax
  00a5b	03 dd		 add	 ebx, ebp
  00a5d	c1 e9 08	 shr	 ecx, 8
  00a60	83 fd 03	 cmp	 ebp, 3
  00a63	75 2f		 jne	 SHORT $LN69@Railgun_Qu@3
$LL39@Railgun_Qu@3:

; 2633 :     for ( ;; )
; 2634 :     {
; 2635 :         if ( ulHashPattern == ( (*(char *)(pbTarget-3))<<8 ) + *(pbTarget-1) ) {

  00a65	0f be 53 fd	 movsx	 edx, BYTE PTR [ebx-3]
  00a69	0f be 6b ff	 movsx	 ebp, BYTE PTR [ebx-1]
  00a6d	c1 e2 08	 shl	 edx, 8
  00a70	03 d5		 add	 edx, ebp
  00a72	3b c2		 cmp	 eax, edx
  00a74	75 0e		 jne	 SHORT $LN80@Railgun_Qu@3

; 2636 :          if ( *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) Railgunhits++; //return((pbTarget-3));

  00a76	8a 56 01	 mov	 dl, BYTE PTR [esi+1]
  00a79	3a 53 fe	 cmp	 dl, BYTE PTR [ebx-2]
  00a7c	75 06		 jne	 SHORT $LN80@Railgun_Qu@3
  00a7e	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits
$LN80@Railgun_Qu@3:

; 2637 :         }
; 2638 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-2) ) pbTarget++;

  00a84	3a 4b fe	 cmp	 cl, BYTE PTR [ebx-2]
  00a87	74 01		 je	 SHORT $LN83@Railgun_Qu@3
  00a89	43		 inc	 ebx
$LN83@Railgun_Qu@3:

; 2639 :         pbTarget++;

  00a8a	43		 inc	 ebx

; 2640 :         if (pbTarget > pbTargetMax)

  00a8b	3b df		 cmp	 ebx, edi
  00a8d	76 d6		 jbe	 SHORT $LL39@Railgun_Qu@3

; 2641 :             return(NULL);

  00a8f	e9 c3 01 00 00	 jmp	 $LN84@Railgun_Qu@3
$LN69@Railgun_Qu@3:
  00a94	ba 01 00 00 00	 mov	 edx, 1
  00a99	8d a4 24 00 00
	00 00		 npad	 7
$LL32@Railgun_Qu@3:

; 2642 :     }
; 2643 : } else {
; 2644 : }
; 2645 :     for ( ;; )
; 2646 :     {
; 2647 :         // The line below gives for 'cbPattern'>=1:
; 2648 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 2649 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 2650 : /*
; 2651 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 2652 :             return((long)(pbTarget-cbPattern));
; 2653 : */
; 2654 : 
; 2655 :         // The fragment below gives for 'cbPattern'>=2:
; 2656 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 2657 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 2658 : 
; 2659 : /*
; 2660 : //For 2 and 3 [
; 2661 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 2662 : //         count = countSTATIC;
; 2663 :          count = cbPattern-2;
; 2664 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 2665 :          while ( count && *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) { // Crippling i.e. only 2 and 3 chars are allowed!
; 2666 :                count--;
; 2667 :          }
; 2668 :          if ( count == 0) return((pbTarget-cbPattern));
; 2669 :         }
; 2670 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-cbPattern+1) ) pbTarget++;
; 2671 : //For 2 and 3 ]
; 2672 : */
; 2673 : 
; 2674 : 
; 2675 :         if ( ulHashPattern == ( (*(char *)(pbTarget-2))<<8 ) + *(pbTarget-1) )

  00aa0	0f be 73 fe	 movsx	 esi, BYTE PTR [ebx-2]
  00aa4	0f be 6b ff	 movsx	 ebp, BYTE PTR [ebx-1]
  00aa8	c1 e6 08	 shl	 esi, 8
  00aab	03 f5		 add	 esi, ebp
  00aad	3b c6		 cmp	 eax, esi
  00aaf	75 06		 jne	 SHORT $LN30@Railgun_Qu@3

; 2676 :             Railgunhits++; //return((pbTarget-2));

  00ab1	01 15 00 00 00
	00		 add	 DWORD PTR _Railgunhits, edx
$LN30@Railgun_Qu@3:

; 2677 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-1) ) pbTarget++;

  00ab7	3a 4b ff	 cmp	 cl, BYTE PTR [ebx-1]
  00aba	74 02		 je	 SHORT $LN29@Railgun_Qu@3
  00abc	03 da		 add	 ebx, edx
$LN29@Railgun_Qu@3:

; 2678 : 
; 2679 : 
; 2680 :         // The fragment below gives for 'cbPattern'>=2:
; 2681 : 	// Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/554
; 2682 : 	// Karp_Rabin_Kaze_4_OCTETS performance: 364KB/clock
; 2683 : /*
; 2684 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 2685 :          count = countSTATIC>>2;
; 2686 :          countRemainder = countSTATIC % 4;
; 2687 : 
; 2688 :          while ( count && *(unsigned long *)(pbPattern+1+((count-1)<<2)) == *(unsigned long *)(pbTarget-cbPattern+1+((count-1)<<2)) ) {
; 2689 :                count--;
; 2690 :          }
; 2691 : 	 //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.
; 2692 :          while ( countRemainder && *(char *)(pbPattern+1+(countSTATIC-countRemainder)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-countRemainder)) ) {
; 2693 :                countRemainder--;
; 2694 :          }
; 2695 :          //if ( countRemainder == 0) return((long)(pbTarget-cbPattern));
; 2696 :          if ( count+countRemainder == 0) return((long)(pbTarget-cbPattern));
; 2697 :          //}
; 2698 :         }
; 2699 : */
; 2700 : 
; 2701 :         pbTarget++;

  00abe	03 da		 add	 ebx, edx

; 2702 :         if (pbTarget > pbTargetMax)

  00ac0	3b df		 cmp	 ebx, edi
  00ac2	76 dc		 jbe	 SHORT $LL32@Railgun_Qu@3

; 2703 :             return(NULL);

  00ac4	e9 8e 01 00 00	 jmp	 $LN84@Railgun_Qu@3
$LN41@Railgun_Qu@3:

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

  00ac9	81 fa c1 03 00
	00		 cmp	 edx, 961		; 000003c1H
  00acf	0f 83 e7 00 00
	00		 jae	 $LN26@Railgun_Qu@3

; 2707 : {
; 2708 :         pbTarget = pbTarget+cbPattern;
; 2709 :         ulHashPattern = *(unsigned long *)(pbPattern);

  00ad5	8b 16		 mov	 edx, DWORD PTR [esi]

; 2710 : //        countSTATIC = cbPattern-1;
; 2711 : 
; 2712 :     //SINGLET = *(char *)(pbPattern);
; 2713 :     SINGLET = ulHashPattern & 0xFF;
; 2714 :     Quadruplet2nd = SINGLET<<8;

  00ad7	0f b6 c2	 movzx	 eax, dl
  00ada	8b f0		 mov	 esi, eax

; 2715 :     Quadruplet3rd = SINGLET<<16;

  00adc	8b c8		 mov	 ecx, eax
  00ade	c1 e6 08	 shl	 esi, 8
  00ae1	c1 e1 10	 shl	 ecx, 16			; 00000010H
  00ae4	03 dd		 add	 ebx, ebp
  00ae6	89 44 24 2c	 mov	 DWORD PTR tv537[esp+1080], eax

; 2716 :     Quadruplet4th = SINGLET<<24;

  00aea	c1 e0 18	 shl	 eax, 24			; 00000018H
  00aed	89 54 24 20	 mov	 DWORD PTR _ulHashPattern$[esp+1080], edx
  00af1	89 74 24 30	 mov	 DWORD PTR _Quadruplet2nd$[esp+1080], esi
  00af5	89 4c 24 24	 mov	 DWORD PTR _Quadruplet3rd$[esp+1080], ecx
  00af9	89 44 24 28	 mov	 DWORD PTR _Quadruplet4th$[esp+1080], eax
  00afd	eb 0d		 jmp	 SHORT $LN25@Railgun_Qu@3
  00aff	90		 npad	 1
$LL81@Railgun_Qu@3:
  00b00	8b 44 24 28	 mov	 eax, DWORD PTR _Quadruplet4th$[esp+1080]
  00b04	8b 54 24 20	 mov	 edx, DWORD PTR _ulHashPattern$[esp+1080]
  00b08	8b 74 24 30	 mov	 esi, DWORD PTR _Quadruplet2nd$[esp+1080]
$LN25@Railgun_Qu@3:

; 2717 : 
; 2718 :     for ( ;; )
; 2719 :     {
; 2720 : 	AdvanceHopperGrass = 0;
; 2721 : 	ulHashTarget = *(unsigned long *)(pbTarget-cbPattern);

  00b0c	8b cb		 mov	 ecx, ebx
  00b0e	2b cd		 sub	 ecx, ebp
  00b10	8b 09		 mov	 ecx, DWORD PTR [ecx]
  00b12	33 ff		 xor	 edi, edi
  00b14	89 7c 24 18	 mov	 DWORD PTR _AdvanceHopperGrass$[esp+1080], edi

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

  00b18	3b d1		 cmp	 edx, ecx
  00b1a	75 5a		 jne	 SHORT $LN23@Railgun_Qu@3

; 2724 : //         count = countSTATIC;
; 2725 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 2726 : //	       if ( countSTATIC==AdvanceHopperGrass+count && SINGLET != *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) AdvanceHopperGrass++;
; 2727 : //               count--;
; 2728 : //         }
; 2729 :          count = cbPattern-1;

  00b1c	8d 4d ff	 lea	 ecx, DWORD PTR [ebp-1]

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

  00b1f	85 c9		 test	 ecx, ecx
  00b21	74 4b		 je	 SHORT $LN61@Railgun_Qu@3

; 2724 : //         count = countSTATIC;
; 2725 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 2726 : //	       if ( countSTATIC==AdvanceHopperGrass+count && SINGLET != *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) AdvanceHopperGrass++;
; 2727 : //               count--;
; 2728 : //         }
; 2729 :          count = cbPattern-1;

  00b23	8b 54 24 14	 mov	 edx, DWORD PTR _pbPattern$GSCopy$[esp+1080]
  00b27	8b f3		 mov	 esi, ebx
  00b29	2b d1		 sub	 edx, ecx
  00b2b	2b f1		 sub	 esi, ecx
  00b2d	03 d5		 add	 edx, ebp
  00b2f	90		 npad	 1
$LL22@Railgun_Qu@3:

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

  00b30	8a 06		 mov	 al, BYTE PTR [esi]
  00b32	88 44 24 13	 mov	 BYTE PTR tv660[esp+1080], al
  00b36	38 02		 cmp	 BYTE PTR [edx], al
  00b38	75 30		 jne	 SHORT $LN21@Railgun_Qu@3

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

  00b3a	8d 45 ff	 lea	 eax, DWORD PTR [ebp-1]
  00b3d	03 f9		 add	 edi, ecx
  00b3f	3b c7		 cmp	 eax, edi
  00b41	75 16		 jne	 SHORT $LN77@Railgun_Qu@3
  00b43	0f be 44 24 13	 movsx	 eax, BYTE PTR tv660[esp+1080]
  00b48	39 44 24 2c	 cmp	 DWORD PTR tv537[esp+1080], eax
  00b4c	74 0b		 je	 SHORT $LN77@Railgun_Qu@3
  00b4e	8b 7c 24 18	 mov	 edi, DWORD PTR _AdvanceHopperGrass$[esp+1080]
  00b52	47		 inc	 edi
  00b53	89 7c 24 18	 mov	 DWORD PTR _AdvanceHopperGrass$[esp+1080], edi
  00b57	eb 04		 jmp	 SHORT $LN20@Railgun_Qu@3
$LN77@Railgun_Qu@3:
  00b59	8b 7c 24 18	 mov	 edi, DWORD PTR _AdvanceHopperGrass$[esp+1080]
$LN20@Railgun_Qu@3:

; 2732 :                count--;

  00b5d	42		 inc	 edx
  00b5e	46		 inc	 esi
  00b5f	49		 dec	 ecx
  00b60	75 ce		 jne	 SHORT $LL22@Railgun_Qu@3

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

  00b62	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits

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

  00b68	eb 3f		 jmp	 SHORT $LN78@Railgun_Qu@3
$LN21@Railgun_Qu@3:

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

  00b6a	85 c9		 test	 ecx, ecx
  00b6c	75 3b		 jne	 SHORT $LN78@Railgun_Qu@3
$LN61@Railgun_Qu@3:
  00b6e	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits

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

  00b74	eb 33		 jmp	 SHORT $LN78@Railgun_Qu@3
$LN23@Railgun_Qu@3:

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

  00b76	8b d1		 mov	 edx, ecx
  00b78	81 e2 00 ff 00
	00		 and	 edx, 65280		; 0000ff00H
  00b7e	3b f2		 cmp	 esi, edx
  00b80	74 27		 je	 SHORT $LN78@Railgun_Qu@3

; 2737 :          AdvanceHopperGrass++;
; 2738 :          if ( Quadruplet3rd != (ulHashTarget & 0x00FF0000) ) {

  00b82	8b d1		 mov	 edx, ecx
  00b84	81 e2 00 00 ff
	00		 and	 edx, 16711680		; 00ff0000H
  00b8a	bf 01 00 00 00	 mov	 edi, 1
  00b8f	39 54 24 24	 cmp	 DWORD PTR _Quadruplet3rd$[esp+1080], edx
  00b93	74 14		 je	 SHORT $LN78@Railgun_Qu@3

; 2739 :               AdvanceHopperGrass++;
; 2740 :               if ( Quadruplet4th != (ulHashTarget & 0xFF000000) ) AdvanceHopperGrass++;

  00b95	81 e1 00 00 00
	ff		 and	 ecx, -16777216		; ff000000H
  00b9b	bf 02 00 00 00	 mov	 edi, 2
  00ba0	3b c1		 cmp	 eax, ecx
  00ba2	74 05		 je	 SHORT $LN78@Railgun_Qu@3
  00ba4	bf 03 00 00 00	 mov	 edi, 3
$LN78@Railgun_Qu@3:

; 2741 :          }
; 2742 :     }
; 2743 : 	}
; 2744 : 
; 2745 : 	AdvanceHopperGrass++;
; 2746 : 
; 2747 : 	pbTarget = pbTarget + AdvanceHopperGrass;

  00ba9	8d 5c 3b 01	 lea	 ebx, DWORD PTR [ebx+edi+1]

; 2748 :         if (pbTarget > pbTargetMax)

  00bad	3b 5c 24 1c	 cmp	 ebx, DWORD PTR _pbTargetMax$[esp+1080]
  00bb1	0f 86 49 ff ff
	ff		 jbe	 $LL81@Railgun_Qu@3

; 2749 :             return(NULL);

  00bb7	e9 9b 00 00 00	 jmp	 $LN84@Railgun_Qu@3
$LN26@Railgun_Qu@3:

; 2750 :     }
; 2751 : } else { //if (cbTarget<961)
; 2752 :         //countSTATIC = cbPattern-2; //r.6+
; 2753 :         //countSTATIC = cbPattern-2-3;
; 2754 :         countSTATIC = cbPattern-2-2; // r.6+++ I suppose that the awful degradation comes from 2bytes more (from either 'if (countSTATIC<0) countSTATIC=0;' or 'count >0' fixes) which make the function unfittable in code cache lines?!
; 2755 :         ulHashPattern = *(unsigned long *)(pbPattern);

  00bbc	8b 06		 mov	 eax, DWORD PTR [esi]
  00bbe	89 44 24 20	 mov	 DWORD PTR _ulHashPattern$[esp+1080], eax

; 2756 : // Next line fixes the BUG from r.6++: but with awful speed degradation! So the bug is fixed in the definitions by setting 'countSTATIC = cbPattern-2-2;', bug appears only for patterns with lengths of 4, The setback is one unnecessary comparison for 5bytes patterns, stupidly such setback exists (from before) for 4bytes as well.
; 2757 : //if (countSTATIC<0) countSTATIC=0;
; 2758 :     /* Preprocessing */
; 2759 :     for (a=0; a < ASIZE; a++) bm_bc[a]=cbPattern;

  00bc2	8b c5		 mov	 eax, ebp
  00bc4	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  00bc9	8d 7c 24 34	 lea	 edi, DWORD PTR _bm_bc$[esp+1080]
  00bcd	f3 ab		 rep stosd

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

  00bcf	8d 45 ff	 lea	 eax, DWORD PTR [ebp-1]
  00bd2	33 c9		 xor	 ecx, ecx
  00bd4	85 c0		 test	 eax, eax
  00bd6	74 1e		 je	 SHORT $LN7@Railgun_Qu@3
  00bd8	8d 75 ff	 lea	 esi, DWORD PTR [ebp-1]
  00bdb	eb 03 8d 49 00	 npad	 5
$LL9@Railgun_Qu@3:
  00be0	8b 7c 24 14	 mov	 edi, DWORD PTR _pbPattern$GSCopy$[esp+1080]
  00be4	0f be 3c 0f	 movsx	 edi, BYTE PTR [edi+ecx]
  00be8	89 74 bc 34	 mov	 DWORD PTR _bm_bc$[esp+edi*4+1080], esi
  00bec	41		 inc	 ecx
  00bed	4e		 dec	 esi
  00bee	3b c8		 cmp	 ecx, eax
  00bf0	72 ee		 jb	 SHORT $LL9@Railgun_Qu@3
  00bf2	8b 74 24 14	 mov	 esi, DWORD PTR _pbPattern$GSCopy$[esp+1080]
$LN7@Railgun_Qu@3:

; 2761 : 
; 2762 :     /* Searching */
; 2763 :     //lastch=pbPattern[cbPattern-1];
; 2764 :     //firstch=pbPattern[0];
; 2765 :     i=0;

  00bf6	33 ff		 xor	 edi, edi

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

  00bf8	2b d5		 sub	 edx, ebp
  00bfa	89 54 24 24	 mov	 DWORD PTR $T7182[esp+1080], edx
  00bfe	8b ff		 npad	 2
$LL6@Railgun_Qu@3:

; 2767 :        ch=pbTarget[i+cbPattern-1];
; 2768 :        //if (ch ==lastch)
; 2769 :           //if (memcmp(&pbTarget[i],pbPattern,cbPattern-1) == 0) OUTPUT(i);
; 2770 :           //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".
; 2771 :           //if (ch == pbPattern[cbPattern-1] && pbTarget[i] == pbPattern[0]) // r.6+
; 2772 :           //if (ch == pbPattern[cbPattern-1] && *(long *)&pbTarget[i] == *(long *)&pbPattern[0]) // No problema here since we have 4[+] long pattern here. Overlapping (1 byte recompared) when length=4, grmbl.
; 2773 :           if (ch == pbPattern[cbPattern-1] && *(long *)&pbTarget[i] == ulHashPattern) // No problema here since we have 4[+] long pattern here. Overlapping (1 byte recompared) when length=4, grmbl.

  00c00	0f be 4c 2e ff	 movsx	 ecx, BYTE PTR [esi+ebp-1]
  00c05	8d 44 2b ff	 lea	 eax, DWORD PTR [ebx+ebp-1]
  00c09	0f b6 04 38	 movzx	 eax, BYTE PTR [eax+edi]
  00c0d	89 44 24 1c	 mov	 DWORD PTR tv457[esp+1080], eax
  00c11	3b c1		 cmp	 eax, ecx
  00c13	75 38		 jne	 SHORT $LN82@Railgun_Qu@3
  00c15	8b 54 24 20	 mov	 edx, DWORD PTR _ulHashPattern$[esp+1080]
  00c19	39 14 1f	 cmp	 DWORD PTR [edi+ebx], edx
  00c1c	75 2f		 jne	 SHORT $LN82@Railgun_Qu@3

; 2774 :              {
; 2775 :          count = countSTATIC;

  00c1e	8d 4d fc	 lea	 ecx, DWORD PTR [ebp-4]

; 2776 :          //while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+(countSTATIC-count)) ) { // r.6+
; 2777 : // A BUG (in next line) crushed from r.6++: 'count !=0' becomes 'count >0' in r.6+++ but with awful speed degradation! So the bug is fixed outside the cycles by setting 'countSTATIC' from -1 to 0, bug appears only for patterns with lengths of 4.
; 2778 :          while ( count !=0 && *(char *)(pbPattern+1+3+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+3+(countSTATIC-count)) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.

  00c21	85 c9		 test	 ecx, ecx
  00c23	74 22		 je	 SHORT $LN86@Railgun_Qu@3

; 2774 :              {
; 2775 :          count = countSTATIC;

  00c25	83 c6 04	 add	 esi, 4
  00c28	8d 54 1f 04	 lea	 edx, DWORD PTR [edi+ebx+4]
  00c2c	8d 64 24 00	 npad	 4
$LL3@Railgun_Qu@3:

; 2776 :          //while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+(countSTATIC-count)) ) { // r.6+
; 2777 : // A BUG (in next line) crushed from r.6++: 'count !=0' becomes 'count >0' in r.6+++ but with awful speed degradation! So the bug is fixed outside the cycles by setting 'countSTATIC' from -1 to 0, bug appears only for patterns with lengths of 4.
; 2778 :          while ( count !=0 && *(char *)(pbPattern+1+3+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+3+(countSTATIC-count)) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.

  00c30	8a 06		 mov	 al, BYTE PTR [esi]
  00c32	3a 02		 cmp	 al, BYTE PTR [edx]
  00c34	75 05		 jne	 SHORT $LN79@Railgun_Qu@3

; 2779 :                count--;

  00c36	42		 inc	 edx
  00c37	46		 inc	 esi
  00c38	49		 dec	 ecx
  00c39	75 f5		 jne	 SHORT $LL3@Railgun_Qu@3
$LN79@Railgun_Qu@3:

; 2776 :          //while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+(countSTATIC-count)) ) { // r.6+
; 2777 : // A BUG (in next line) crushed from r.6++: 'count !=0' becomes 'count >0' in r.6+++ but with awful speed degradation! So the bug is fixed outside the cycles by setting 'countSTATIC' from -1 to 0, bug appears only for patterns with lengths of 4.
; 2778 :          while ( count !=0 && *(char *)(pbPattern+1+3+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+3+(countSTATIC-count)) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.

  00c3b	8b 44 24 1c	 mov	 eax, DWORD PTR tv457[esp+1080]
  00c3f	8b 74 24 14	 mov	 esi, DWORD PTR _pbPattern$GSCopy$[esp+1080]

; 2780 :          }
; 2781 :          if ( count <= 0) Railgunhits++; //return(pbTarget+i);

  00c43	85 c9		 test	 ecx, ecx
  00c45	7f 06		 jg	 SHORT $LN82@Railgun_Qu@3
$LN86@Railgun_Qu@3:
  00c47	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits
$LN82@Railgun_Qu@3:

; 2782 : 	     }
; 2783 :        i+=bm_bc[ch];

  00c4d	03 7c 84 34	 add	 edi, DWORD PTR _bm_bc$[esp+eax*4+1080]
  00c51	3b 7c 24 24	 cmp	 edi, DWORD PTR $T7182[esp+1080]
  00c55	76 a9		 jbe	 SHORT $LL6@Railgun_Qu@3
$LN84@Railgun_Qu@3:

; 2784 :     }
; 2785 :     return(NULL);
; 2786 : } //if (cbTarget<961)
; 2787 : } //if ( cbPattern<4)
; 2788 : }

  00c57	8b 8c 24 34 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1080]
  00c5e	5f		 pop	 edi
  00c5f	5e		 pop	 esi
  00c60	5d		 pop	 ebp
  00c61	5b		 pop	 ebx
  00c62	33 cc		 xor	 ecx, esp
  00c64	33 c0		 xor	 eax, eax
  00c66	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00c6b	81 c4 28 04 00
	00		 add	 esp, 1064		; 00000428H
  00c71	c3		 ret	 0
_Railgun_Quadruplet_6pp_count_hits ENDP
_TEXT	ENDS
PUBLIC	_pbPattern$GSCopy$
PUBLIC	__$ArrayPad$
PUBLIC	_Railgun_Quadruplet_7m
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_countSTATIC$ = -1060					; size = 4
_AdvanceHopperGrass$ = -1060				; size = 4
_pbPattern$GSCopy$ = -1056				; size = 4
_ulHashPattern$ = -1052					; size = 4
tv594 = -1048						; size = 4
_pbTargetMax$ = -1048					; size = 4
$T7233 = -1044						; size = 4
_Quadruplet4th$ = -1044					; size = 4
_Quadruplet2nd$ = -1040					; size = 4
_Quadruplet3rd$ = -1036					; size = 4
tv565 = -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_7m PROC

; 2798 : {

  00c80	81 ec 24 04 00
	00		 sub	 esp, 1060		; 00000424H
  00c86	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00c8b	33 c4		 xor	 eax, esp
  00c8d	89 84 24 20 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1060], eax

; 2799 :     char * pbTargetMax = pbTarget + cbTarget;
; 2800 :     register unsigned long  ulHashPattern;
; 2801 :     unsigned long ulHashTarget;
; 2802 :     //unsigned long count; //r.6+
; 2803 :     signed long count;
; 2804 :     //unsigned long countSTATIC; //r.6+
; 2805 :     signed long countSTATIC;
; 2806 : //  unsigned long countRemainder;
; 2807 : 
; 2808 : /*
; 2809 :     const unsigned char SINGLET = *(char *)(pbPattern);
; 2810 :     const unsigned long Quadruplet2nd = SINGLET<<8;
; 2811 :     const unsigned long Quadruplet3rd = SINGLET<<16;
; 2812 :     const unsigned long Quadruplet4th = SINGLET<<24;
; 2813 : */
; 2814 :     unsigned char SINGLET;
; 2815 :     unsigned long Quadruplet2nd;
; 2816 :     unsigned long Quadruplet3rd;
; 2817 :     unsigned long Quadruplet4th;
; 2818 : 
; 2819 :     unsigned long  AdvanceHopperGrass;
; 2820 : 
; 2821 :     long i; //BMH needed
; 2822 :     int a, j, bm_bc[ASIZE]; //BMH needed
; 2823 :     unsigned char ch; //BMH needed
; 2824 :     unsigned long chchchch; //BMH needed
; 2825 : //    unsigned char lastch, firstch; //BMH needed
; 2826 : 
; 2827 :     if (cbPattern > cbTarget)

  00c94	8b 94 24 34 04
	00 00		 mov	 edx, DWORD PTR _cbPattern$[esp+1056]
  00c9b	53		 push	 ebx
  00c9c	8b 9c 24 34 04
	00 00		 mov	 ebx, DWORD PTR _cbTarget$[esp+1060]
  00ca3	55		 push	 ebp
  00ca4	8b ac 24 30 04
	00 00		 mov	 ebp, DWORD PTR _pbTarget$[esp+1064]
  00cab	56		 push	 esi
  00cac	8b b4 24 38 04
	00 00		 mov	 esi, DWORD PTR _pbPattern$[esp+1068]
  00cb3	57		 push	 edi
  00cb4	8d 3c 2b	 lea	 edi, DWORD PTR [ebx+ebp]
  00cb7	89 74 24 14	 mov	 DWORD PTR _pbPattern$GSCopy$[esp+1076], esi
  00cbb	89 7c 24 1c	 mov	 DWORD PTR _pbTargetMax$[esp+1076], edi
  00cbf	3b d3		 cmp	 edx, ebx

; 2828 :         return(NULL);

  00cc1	77 46		 ja	 SHORT $LN5@Railgun_Qu@4

; 2829 : 
; 2830 : // Doesn't work when cbPattern = 1
; 2831 : // 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!
; 2832 : 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.

  00cc3	83 fa 04	 cmp	 edx, 4
  00cc6	0f 83 97 00 00
	00		 jae	 $LN41@Railgun_Qu@4

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

  00ccc	0f be 06	 movsx	 eax, BYTE PTR [esi]
  00ccf	0f be 4c 16 ff	 movsx	 ecx, BYTE PTR [esi+edx-1]
  00cd4	c1 e0 08	 shl	 eax, 8
  00cd7	03 ea		 add	 ebp, edx
  00cd9	03 c8		 add	 ecx, eax

; 2835 : //        countSTATIC = cbPattern-2;
; 2836 : 
; 2837 : if ( cbPattern==3) {

  00cdb	83 fa 03	 cmp	 edx, 3
  00cde	75 49		 jne	 SHORT $LN46@Railgun_Qu@4
$LL39@Railgun_Qu@4:

; 2838 :     for ( ;; )
; 2839 :     {
; 2840 :         if ( ulHashPattern == ( (*(char *)(pbTarget-3))<<8 ) + *(pbTarget-1) ) {

  00ce0	0f be 55 fd	 movsx	 edx, BYTE PTR [ebp-3]
  00ce4	0f be 45 ff	 movsx	 eax, BYTE PTR [ebp-1]
  00ce8	c1 e2 08	 shl	 edx, 8
  00ceb	03 d0		 add	 edx, eax
  00ced	3b ca		 cmp	 ecx, edx
  00cef	75 08		 jne	 SHORT $LN36@Railgun_Qu@4

; 2841 :          if ( *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) return((pbTarget-3));

  00cf1	8a 56 01	 mov	 dl, BYTE PTR [esi+1]
  00cf4	3a 55 fe	 cmp	 dl, BYTE PTR [ebp-2]
  00cf7	74 2b		 je	 SHORT $LN53@Railgun_Qu@4
$LN36@Railgun_Qu@4:

; 2842 :         }
; 2843 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-2) ) pbTarget++;

  00cf9	8b c1		 mov	 eax, ecx
  00cfb	c1 e8 08	 shr	 eax, 8
  00cfe	3a 45 fe	 cmp	 al, BYTE PTR [ebp-2]
  00d01	74 01		 je	 SHORT $LN35@Railgun_Qu@4
  00d03	45		 inc	 ebp
$LN35@Railgun_Qu@4:

; 2844 :         pbTarget++;

  00d04	45		 inc	 ebp

; 2845 :         if (pbTarget > pbTargetMax)

  00d05	3b ef		 cmp	 ebp, edi
  00d07	76 d7		 jbe	 SHORT $LL39@Railgun_Qu@4
$LN5@Railgun_Qu@4:

; 2995 :     }
; 2996 :     return(NULL);

  00d09	33 c0		 xor	 eax, eax
$LN13@Railgun_Qu@4:

; 2997 : } //if (cbTarget<961)
; 2998 : } //if ( cbPattern<4)
; 2999 : }

  00d0b	8b 8c 24 30 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1076]
  00d12	5f		 pop	 edi
  00d13	5e		 pop	 esi
  00d14	5d		 pop	 ebp
  00d15	5b		 pop	 ebx
  00d16	33 cc		 xor	 ecx, esp
  00d18	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00d1d	81 c4 24 04 00
	00		 add	 esp, 1060		; 00000424H
  00d23	c3		 ret	 0
$LN53@Railgun_Qu@4:

; 2841 :          if ( *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) return((pbTarget-3));

  00d24	8d 45 fd	 lea	 eax, DWORD PTR [ebp-3]

; 2846 :             return(NULL);

  00d27	eb e2		 jmp	 SHORT $LN13@Railgun_Qu@4
$LN46@Railgun_Qu@4:

; 2847 :     }
; 2848 : } else {
; 2849 : }
; 2850 :     for ( ;; )
; 2851 :     {
; 2852 :         // The line below gives for 'cbPattern'>=1:
; 2853 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 2854 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 2855 : /*
; 2856 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 2857 :             return((long)(pbTarget-cbPattern));
; 2858 : */
; 2859 : 
; 2860 :         // The fragment below gives for 'cbPattern'>=2:
; 2861 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 2862 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 2863 : 
; 2864 : /*
; 2865 : //For 2 and 3 [
; 2866 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 2867 : //         count = countSTATIC;
; 2868 :          count = cbPattern-2;
; 2869 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 2870 :          while ( count && *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) { // Crippling i.e. only 2 and 3 chars are allowed!
; 2871 :                count--;
; 2872 :          }
; 2873 :          if ( count == 0) return((pbTarget-cbPattern));
; 2874 :         }
; 2875 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-cbPattern+1) ) pbTarget++;
; 2876 : //For 2 and 3 ]
; 2877 : */
; 2878 : 
; 2879 : 
; 2880 :         if ( ulHashPattern == ( (*(char *)(pbTarget-2))<<8 ) + *(pbTarget-1) )

  00d29	8a 45 ff	 mov	 al, BYTE PTR [ebp-1]
  00d2c	0f be 55 fe	 movsx	 edx, BYTE PTR [ebp-2]
  00d30	0f be f0	 movsx	 esi, al
  00d33	c1 e2 08	 shl	 edx, 8
  00d36	03 d6		 add	 edx, esi
  00d38	3b ca		 cmp	 ecx, edx
  00d3a	74 22		 je	 SHORT $LN55@Railgun_Qu@4
  00d3c	8b d1		 mov	 edx, ecx
  00d3e	c1 ea 08	 shr	 edx, 8
$LL32@Railgun_Qu@4:

; 2882 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-1) ) pbTarget++;

  00d41	3a d0		 cmp	 dl, al
  00d43	74 01		 je	 SHORT $LN70@Railgun_Qu@4
  00d45	45		 inc	 ebp
$LN70@Railgun_Qu@4:

; 2883 : 
; 2884 : 
; 2885 :         // The fragment below gives for 'cbPattern'>=2:
; 2886 : 	// Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/554
; 2887 : 	// Karp_Rabin_Kaze_4_OCTETS performance: 364KB/clock
; 2888 : /*
; 2889 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 2890 :          count = countSTATIC>>2;
; 2891 :          countRemainder = countSTATIC % 4;
; 2892 : 
; 2893 :          while ( count && *(unsigned long *)(pbPattern+1+((count-1)<<2)) == *(unsigned long *)(pbTarget-cbPattern+1+((count-1)<<2)) ) {
; 2894 :                count--;
; 2895 :          }
; 2896 : 	 //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.
; 2897 :          while ( countRemainder && *(char *)(pbPattern+1+(countSTATIC-countRemainder)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-countRemainder)) ) {
; 2898 :                countRemainder--;
; 2899 :          }
; 2900 :          //if ( countRemainder == 0) return((long)(pbTarget-cbPattern));
; 2901 :          if ( count+countRemainder == 0) return((long)(pbTarget-cbPattern));
; 2902 :          //}
; 2903 :         }
; 2904 : */
; 2905 : 
; 2906 :         pbTarget++;

  00d46	45		 inc	 ebp

; 2907 :         if (pbTarget > pbTargetMax)

  00d47	3b ef		 cmp	 ebp, edi
  00d49	77 be		 ja	 SHORT $LN5@Railgun_Qu@4

; 2847 :     }
; 2848 : } else {
; 2849 : }
; 2850 :     for ( ;; )
; 2851 :     {
; 2852 :         // The line below gives for 'cbPattern'>=1:
; 2853 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 2854 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 2855 : /*
; 2856 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 2857 :             return((long)(pbTarget-cbPattern));
; 2858 : */
; 2859 : 
; 2860 :         // The fragment below gives for 'cbPattern'>=2:
; 2861 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 2862 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 2863 : 
; 2864 : /*
; 2865 : //For 2 and 3 [
; 2866 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 2867 : //         count = countSTATIC;
; 2868 :          count = cbPattern-2;
; 2869 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 2870 :          while ( count && *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) { // Crippling i.e. only 2 and 3 chars are allowed!
; 2871 :                count--;
; 2872 :          }
; 2873 :          if ( count == 0) return((pbTarget-cbPattern));
; 2874 :         }
; 2875 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-cbPattern+1) ) pbTarget++;
; 2876 : //For 2 and 3 ]
; 2877 : */
; 2878 : 
; 2879 : 
; 2880 :         if ( ulHashPattern == ( (*(char *)(pbTarget-2))<<8 ) + *(pbTarget-1) )

  00d4b	8a 45 ff	 mov	 al, BYTE PTR [ebp-1]
  00d4e	0f be 75 fe	 movsx	 esi, BYTE PTR [ebp-2]
  00d52	0f be d8	 movsx	 ebx, al
  00d55	c1 e6 08	 shl	 esi, 8
  00d58	03 f3		 add	 esi, ebx
  00d5a	3b ce		 cmp	 ecx, esi
  00d5c	75 e3		 jne	 SHORT $LL32@Railgun_Qu@4
$LN55@Railgun_Qu@4:

; 2881 :             return((pbTarget-2));

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

; 2908 :             return(NULL);

  00d61	eb a8		 jmp	 SHORT $LN13@Railgun_Qu@4
$LN41@Railgun_Qu@4:

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

  00d63	81 fb c1 03 00
	00		 cmp	 ebx, 961		; 000003c1H
  00d69	0f 83 d3 00 00
	00		 jae	 $LN26@Railgun_Qu@4

; 2912 : {
; 2913 :         pbTarget = pbTarget+cbPattern;
; 2914 :         ulHashPattern = *(unsigned long *)(pbPattern);

  00d6f	8b 0e		 mov	 ecx, DWORD PTR [esi]

; 2915 : //        countSTATIC = cbPattern-1;
; 2916 : 
; 2917 :     //SINGLET = *(char *)(pbPattern);
; 2918 :     SINGLET = ulHashPattern & 0xFF;
; 2919 :     Quadruplet2nd = SINGLET<<8;

  00d71	0f b6 c1	 movzx	 eax, cl
  00d74	8b f8		 mov	 edi, eax
  00d76	c1 e7 08	 shl	 edi, 8
  00d79	89 7c 24 24	 mov	 DWORD PTR _Quadruplet2nd$[esp+1076], edi

; 2920 :     Quadruplet3rd = SINGLET<<16;

  00d7d	8b f8		 mov	 edi, eax
  00d7f	c1 e7 10	 shl	 edi, 16			; 00000010H
  00d82	03 ea		 add	 ebp, edx
  00d84	89 44 24 2c	 mov	 DWORD PTR tv565[esp+1076], eax

; 2921 :     Quadruplet4th = SINGLET<<24;

  00d88	c1 e0 18	 shl	 eax, 24			; 00000018H
  00d8b	89 4c 24 18	 mov	 DWORD PTR _ulHashPattern$[esp+1076], ecx
  00d8f	89 7c 24 28	 mov	 DWORD PTR _Quadruplet3rd$[esp+1076], edi
  00d93	89 44 24 20	 mov	 DWORD PTR _Quadruplet4th$[esp+1076], eax
$LL25@Railgun_Qu@4:

; 2922 : 
; 2923 :     for ( ;; )
; 2924 :     {
; 2925 : 	AdvanceHopperGrass = 0;
; 2926 : 	ulHashTarget = *(unsigned long *)(pbTarget-cbPattern);

  00d97	8b c5		 mov	 eax, ebp
  00d99	2b c2		 sub	 eax, edx
  00d9b	8b 00		 mov	 eax, DWORD PTR [eax]
  00d9d	33 db		 xor	 ebx, ebx
  00d9f	89 5c 24 10	 mov	 DWORD PTR _AdvanceHopperGrass$[esp+1076], ebx

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

  00da3	3b c8		 cmp	 ecx, eax
  00da5	75 4e		 jne	 SHORT $LN23@Railgun_Qu@4

; 2929 : //         count = countSTATIC;
; 2930 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 2931 : //	       if ( countSTATIC==AdvanceHopperGrass+count && SINGLET != *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) AdvanceHopperGrass++;
; 2932 : //               count--;
; 2933 : //         }
; 2934 :          count = cbPattern-1;

  00da7	8d 42 ff	 lea	 eax, DWORD PTR [edx-1]

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

  00daa	85 c0		 test	 eax, eax
  00dac	74 34		 je	 SHORT $LN65@Railgun_Qu@4

; 2929 : //         count = countSTATIC;
; 2930 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 2931 : //	       if ( countSTATIC==AdvanceHopperGrass+count && SINGLET != *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) AdvanceHopperGrass++;
; 2932 : //               count--;
; 2933 : //         }
; 2934 :          count = cbPattern-1;

  00dae	8b fd		 mov	 edi, ebp
  00db0	2b f0		 sub	 esi, eax
  00db2	2b f8		 sub	 edi, eax
  00db4	03 f2		 add	 esi, edx
$LL22@Railgun_Qu@4:

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

  00db6	8a 0f		 mov	 cl, BYTE PTR [edi]
  00db8	38 0e		 cmp	 BYTE PTR [esi], cl
  00dba	75 2f		 jne	 SHORT $LN21@Railgun_Qu@4

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

  00dbc	8d 4a ff	 lea	 ecx, DWORD PTR [edx-1]
  00dbf	03 d8		 add	 ebx, eax
  00dc1	3b cb		 cmp	 ecx, ebx
  00dc3	75 14		 jne	 SHORT $LN68@Railgun_Qu@4
  00dc5	0f be 0f	 movsx	 ecx, BYTE PTR [edi]
  00dc8	39 4c 24 2c	 cmp	 DWORD PTR tv565[esp+1076], ecx
  00dcc	74 0b		 je	 SHORT $LN68@Railgun_Qu@4
  00dce	8b 5c 24 10	 mov	 ebx, DWORD PTR _AdvanceHopperGrass$[esp+1076]
  00dd2	43		 inc	 ebx
  00dd3	89 5c 24 10	 mov	 DWORD PTR _AdvanceHopperGrass$[esp+1076], ebx
  00dd7	eb 04		 jmp	 SHORT $LN20@Railgun_Qu@4
$LN68@Railgun_Qu@4:
  00dd9	8b 5c 24 10	 mov	 ebx, DWORD PTR _AdvanceHopperGrass$[esp+1076]
$LN20@Railgun_Qu@4:

; 2937 :                count--;

  00ddd	46		 inc	 esi
  00dde	47		 inc	 edi
  00ddf	48		 dec	 eax
  00de0	75 d4		 jne	 SHORT $LL22@Railgun_Qu@4
$LN65@Railgun_Qu@4:

; 2938 :          }
; 2939 :          if ( count == 0) return((pbTarget-cbPattern));

  00de2	8b c5		 mov	 eax, ebp
  00de4	2b c2		 sub	 eax, edx

; 2954 :             return(NULL);

  00de6	e9 20 ff ff ff	 jmp	 $LN13@Railgun_Qu@4
$LN21@Railgun_Qu@4:

; 2938 :          }
; 2939 :          if ( count == 0) return((pbTarget-cbPattern));

  00deb	85 c0		 test	 eax, eax
  00ded	74 f3		 je	 SHORT $LN65@Railgun_Qu@4

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

  00def	8b 74 24 14	 mov	 esi, DWORD PTR _pbPattern$GSCopy$[esp+1076]
  00df3	eb 36		 jmp	 SHORT $LN15@Railgun_Qu@4
$LN23@Railgun_Qu@4:

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

  00df5	8b c8		 mov	 ecx, eax
  00df7	81 e1 00 ff 00
	00		 and	 ecx, 65280		; 0000ff00H
  00dfd	39 4c 24 24	 cmp	 DWORD PTR _Quadruplet2nd$[esp+1076], ecx
  00e01	74 28		 je	 SHORT $LN15@Railgun_Qu@4

; 2942 :          AdvanceHopperGrass++;
; 2943 :          if ( Quadruplet3rd != (ulHashTarget & 0x00FF0000) ) {

  00e03	8b c8		 mov	 ecx, eax
  00e05	81 e1 00 00 ff
	00		 and	 ecx, 16711680		; 00ff0000H
  00e0b	bb 01 00 00 00	 mov	 ebx, 1
  00e10	39 4c 24 28	 cmp	 DWORD PTR _Quadruplet3rd$[esp+1076], ecx
  00e14	74 15		 je	 SHORT $LN15@Railgun_Qu@4

; 2944 :               AdvanceHopperGrass++;
; 2945 :               if ( Quadruplet4th != (ulHashTarget & 0xFF000000) ) AdvanceHopperGrass++;

  00e16	25 00 00 00 ff	 and	 eax, -16777216		; ff000000H
  00e1b	bb 02 00 00 00	 mov	 ebx, 2
  00e20	39 44 24 20	 cmp	 DWORD PTR _Quadruplet4th$[esp+1076], eax
  00e24	74 05		 je	 SHORT $LN15@Railgun_Qu@4
  00e26	bb 03 00 00 00	 mov	 ebx, 3
$LN15@Railgun_Qu@4:

; 2946 :          }
; 2947 :     }
; 2948 : 	}
; 2949 : 
; 2950 : 	AdvanceHopperGrass++;
; 2951 : 
; 2952 : 	pbTarget = pbTarget + AdvanceHopperGrass;

  00e2b	8d 6c 2b 01	 lea	 ebp, DWORD PTR [ebx+ebp+1]

; 2953 :         if (pbTarget > pbTargetMax)

  00e2f	3b 6c 24 1c	 cmp	 ebp, DWORD PTR _pbTargetMax$[esp+1076]
  00e33	0f 87 d0 fe ff
	ff		 ja	 $LN5@Railgun_Qu@4

; 2955 :     }

  00e39	8b 4c 24 18	 mov	 ecx, DWORD PTR _ulHashPattern$[esp+1076]
  00e3d	e9 55 ff ff ff	 jmp	 $LL25@Railgun_Qu@4
$LN26@Railgun_Qu@4:

; 2956 : } else { //if (cbTarget<961)
; 2957 :         //countSTATIC = cbPattern-2; //r.6+
; 2958 :         //countSTATIC = cbPattern-2-3;
; 2959 :         //countSTATIC = cbPattern-2-2; // r.6+++ I suppose that the awful degradation comes from 2bytes more (from either 'if (countSTATIC<0) countSTATIC=0;' or 'count >0' fixes) which make the function unfittable in code cache lines?!
; 2960 :         //countSTATIC = cbPattern-2-3; // r.7- At last no recompared bytes in-between chars
; 2961 :         countSTATIC = cbPattern-2-2; // r.7 
; 2962 :         ulHashPattern = *(unsigned long *)(pbPattern+cbPattern-1-3);

  00e42	8b 44 24 14	 mov	 eax, DWORD PTR _pbPattern$GSCopy$[esp+1076]
  00e46	8b 4c 10 fc	 mov	 ecx, DWORD PTR [eax+edx-4]
  00e4a	89 4c 24 18	 mov	 DWORD PTR _ulHashPattern$[esp+1076], ecx

; 2963 : // Next line fixes the BUG from r.6++: but with awful speed degradation! So the bug is fixed in the definitions by setting 'countSTATIC = cbPattern-2-2;', bug appears only for patterns with lengths of 4, The setback is one unnecessary comparison for 5bytes patterns, stupidly such setback exists (from before) for 4bytes as well.
; 2964 : //if (countSTATIC<0) countSTATIC=0;
; 2965 :     /* Preprocessing */
; 2966 :     for (a=0; a < ASIZE; a++) bm_bc[a]=cbPattern;

  00e4e	8b c2		 mov	 eax, edx
  00e50	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  00e55	8d 7c 24 30	 lea	 edi, DWORD PTR _bm_bc$[esp+1076]
  00e59	f3 ab		 rep stosd

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

  00e5b	8d 4a ff	 lea	 ecx, DWORD PTR [edx-1]
  00e5e	8d 72 fc	 lea	 esi, DWORD PTR [edx-4]
  00e61	33 c0		 xor	 eax, eax
  00e63	89 74 24 10	 mov	 DWORD PTR _countSTATIC$[esp+1076], esi
  00e67	85 c9		 test	 ecx, ecx
  00e69	74 1b		 je	 SHORT $LN7@Railgun_Qu@4
  00e6b	8d 72 ff	 lea	 esi, DWORD PTR [edx-1]
  00e6e	8b ff		 npad	 2
$LL9@Railgun_Qu@4:
  00e70	8b 7c 24 14	 mov	 edi, DWORD PTR _pbPattern$GSCopy$[esp+1076]
  00e74	0f be 3c 07	 movsx	 edi, BYTE PTR [edi+eax]
  00e78	89 74 bc 30	 mov	 DWORD PTR _bm_bc$[esp+edi*4+1076], esi
  00e7c	40		 inc	 eax
  00e7d	4e		 dec	 esi
  00e7e	3b c1		 cmp	 eax, ecx
  00e80	72 ee		 jb	 SHORT $LL9@Railgun_Qu@4
  00e82	8b 74 24 10	 mov	 esi, DWORD PTR _countSTATIC$[esp+1076]
$LN7@Railgun_Qu@4:

; 2968 : 
; 2969 :     /* Searching */
; 2970 :     //lastch=pbPattern[cbPattern-1];
; 2971 :     //firstch=pbPattern[0];
; 2972 :     i=0;

  00e86	33 ff		 xor	 edi, edi

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

  00e88	2b da		 sub	 ebx, edx
  00e8a	8d 54 2a fc	 lea	 edx, DWORD PTR [edx+ebp-4]
  00e8e	89 5c 24 20	 mov	 DWORD PTR $T7233[esp+1076], ebx
  00e92	89 54 24 1c	 mov	 DWORD PTR tv594[esp+1076], edx
  00e96	eb 08 8d a4 24
	00 00 00 00 90	 npad	 10
$LL6@Railgun_Qu@4:

; 2974 :        //ch=pbTarget[i+cbPattern-1];
; 2975 :        chchchch=*(unsigned long *)&pbTarget[i+cbPattern-1-3];

  00ea0	8b 44 24 1c	 mov	 eax, DWORD PTR tv594[esp+1076]
  00ea4	8b 14 38	 mov	 edx, DWORD PTR [eax+edi]

; 2976 :        //if (ch ==lastch)
; 2977 :           //if (memcmp(&pbTarget[i],pbPattern,cbPattern-1) == 0) OUTPUT(i);
; 2978 :           //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".
; 2979 :           //if (ch == pbPattern[cbPattern-1] && pbTarget[i] == pbPattern[0]) // r.6+
; 2980 :           //if (ch == pbPattern[cbPattern-1] && *(long *)&pbTarget[i] == *(long *)&pbPattern[0]) // No problema here since we have 4[+] long pattern here. Overlapping (1 byte recompared) when length=4, grmbl.
; 2981 :           //if (ch == pbPattern[cbPattern-1] && *(long *)&pbTarget[i] == ulHashPattern) // No problema here since we have 4[+] long pattern here. Overlapping (1 byte recompared) when length=4, grmbl.
; 2982 :           if (chchchch == ulHashPattern) // No problema here since we have 4[+] long pattern here. Overlapping (1 byte recompared) when length=4, grmbl.

  00ea7	3b 54 24 18	 cmp	 edx, DWORD PTR _ulHashPattern$[esp+1076]
  00eab	75 2e		 jne	 SHORT $LN1@Railgun_Qu@4

; 2983 :              {
; 2984 :          count = countSTATIC;

  00ead	8b c6		 mov	 eax, esi

; 2985 :          //while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+(countSTATIC-count)) ) { // r.6+
; 2986 : // A BUG (in next line) crushed from r.6++: 'count !=0' becomes 'count >0' in r.6+++ but with awful speed degradation! So the bug is fixed outside the cycles by setting 'countSTATIC' from -1 to 0, bug appears only for patterns with lengths of 4.
; 2987 :          //while ( count !=0 && *(char *)(pbPattern+1+3+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+3+(countSTATIC-count)) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.
; 2988 : // The next line is somewhat stupid - it compares backwardly, AFAIK the CPU won't cache the previous 32bytes but the next?!
; 2989 :          while ( count !=0 && *(char *)(pbPattern+(countSTATIC-count)) == *(char *)(&pbTarget[i]+(countSTATIC-count)) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.

  00eaf	85 f6		 test	 esi, esi
  00eb1	74 18		 je	 SHORT $LN59@Railgun_Qu@4

; 2983 :              {
; 2984 :          count = countSTATIC;

  00eb3	8b 74 24 14	 mov	 esi, DWORD PTR _pbPattern$GSCopy$[esp+1076]
  00eb7	8d 0c 2f	 lea	 ecx, DWORD PTR [edi+ebp]
  00eba	8d 9b 00 00 00
	00		 npad	 6
$LL3@Railgun_Qu@4:

; 2985 :          //while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+(countSTATIC-count)) ) { // r.6+
; 2986 : // A BUG (in next line) crushed from r.6++: 'count !=0' becomes 'count >0' in r.6+++ but with awful speed degradation! So the bug is fixed outside the cycles by setting 'countSTATIC' from -1 to 0, bug appears only for patterns with lengths of 4.
; 2987 :          //while ( count !=0 && *(char *)(pbPattern+1+3+(countSTATIC-count)) == *(char *)(&pbTarget[i]+1+3+(countSTATIC-count)) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.
; 2988 : // The next line is somewhat stupid - it compares backwardly, AFAIK the CPU won't cache the previous 32bytes but the next?!
; 2989 :          while ( count !=0 && *(char *)(pbPattern+(countSTATIC-count)) == *(char *)(&pbTarget[i]+(countSTATIC-count)) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.

  00ec0	8a 1e		 mov	 bl, BYTE PTR [esi]
  00ec2	3a 19		 cmp	 bl, BYTE PTR [ecx]
  00ec4	75 0d		 jne	 SHORT $LN2@Railgun_Qu@4

; 2990 :                count--;

  00ec6	41		 inc	 ecx
  00ec7	46		 inc	 esi
  00ec8	48		 dec	 eax
  00ec9	75 f5		 jne	 SHORT $LL3@Railgun_Qu@4
$LN59@Railgun_Qu@4:

; 2991 :          }
; 2992 :          if ( count == 0) return(pbTarget+i);

  00ecb	8d 04 2f	 lea	 eax, DWORD PTR [edi+ebp]
  00ece	e9 38 fe ff ff	 jmp	 $LN13@Railgun_Qu@4
$LN2@Railgun_Qu@4:
  00ed3	85 c0		 test	 eax, eax
  00ed5	74 f4		 je	 SHORT $LN59@Railgun_Qu@4
  00ed7	8b 74 24 10	 mov	 esi, DWORD PTR _countSTATIC$[esp+1076]
$LN1@Railgun_Qu@4:

; 2993 : 	     }
; 2994 :        i+=bm_bc[(char)(chchchch>>24)];

  00edb	c1 ea 18	 shr	 edx, 24			; 00000018H
  00ede	0f be ca	 movsx	 ecx, dl
  00ee1	03 7c 8c 30	 add	 edi, DWORD PTR _bm_bc$[esp+ecx*4+1076]
  00ee5	3b 7c 24 20	 cmp	 edi, DWORD PTR $T7233[esp+1076]
  00ee9	76 b5		 jbe	 SHORT $LL6@Railgun_Qu@4

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

  00eeb	e9 19 fe ff ff	 jmp	 $LN5@Railgun_Qu@4
_Railgun_Quadruplet_7m ENDP
_TEXT	ENDS
PUBLIC	_pbPattern$GSCopy$
PUBLIC	__$ArrayPad$
PUBLIC	_Railgun_Quadruplet_7m_count_hits
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_pbPattern$GSCopy$ = -1060				; size = 4
_AdvanceHopperGrass$ = -1056				; size = 4
_ulHashPattern$ = -1052					; size = 4
$T7261 = -1048						; size = 4
_Quadruplet3rd$ = -1048					; size = 4
tv560 = -1044						; size = 4
_pbTargetMax$ = -1044					; size = 4
_countSTATIC$ = -1040					; size = 4
_Quadruplet4th$ = -1040					; size = 4
_Quadruplet2nd$ = -1036					; size = 4
tv531 = -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_7m_count_hits PROC

; 3009 : {

  00ef0	81 ec 24 04 00
	00		 sub	 esp, 1060		; 00000424H
  00ef6	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00efb	33 c4		 xor	 eax, esp
  00efd	89 84 24 20 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1060], eax

; 3010 :     char * pbTargetMax = pbTarget + cbTarget;
; 3011 :     register unsigned long ulHashPattern;
; 3012 :     unsigned long ulHashTarget;
; 3013 :     //unsigned long count; //r.6+
; 3014 :     signed long count;
; 3015 :     //unsigned long countSTATIC; //r.6+
; 3016 :     signed long countSTATIC;
; 3017 : //  unsigned long countRemainder;
; 3018 : 
; 3019 : /*
; 3020 :     const unsigned char SINGLET = *(char *)(pbPattern);
; 3021 :     const unsigned long Quadruplet2nd = SINGLET<<8;
; 3022 :     const unsigned long Quadruplet3rd = SINGLET<<16;
; 3023 :     const unsigned long Quadruplet4th = SINGLET<<24;
; 3024 : */
; 3025 :     unsigned char SINGLET;
; 3026 :     unsigned long Quadruplet2nd;
; 3027 :     unsigned long Quadruplet3rd;
; 3028 :     unsigned long Quadruplet4th;
; 3029 : 
; 3030 :     unsigned long  AdvanceHopperGrass;
; 3031 : 
; 3032 :     long i; //BMH needed
; 3033 :     int a, j, bm_bc[ASIZE]; //BMH needed
; 3034 :     unsigned char ch; //BMH needed
; 3035 :     unsigned long chchchch; //BMH needed
; 3036 :     unsigned short chchchchSHORT; //BMH needed
; 3037 :     //unsigned char * chPTR;
; 3038 : //    unsigned char lastch, firstch; //BMH needed
; 3039 : 
; 3040 :     if (cbPattern > cbTarget)

  00f04	8b 84 24 34 04
	00 00		 mov	 eax, DWORD PTR _cbPattern$[esp+1056]
  00f0b	8b 8c 24 2c 04
	00 00		 mov	 ecx, DWORD PTR _pbPattern$[esp+1056]
  00f12	53		 push	 ebx
  00f13	8b 9c 24 34 04
	00 00		 mov	 ebx, DWORD PTR _cbTarget$[esp+1060]
  00f1a	55		 push	 ebp
  00f1b	8b ac 24 30 04
	00 00		 mov	 ebp, DWORD PTR _pbTarget$[esp+1064]
  00f22	56		 push	 esi
  00f23	8d 34 2b	 lea	 esi, DWORD PTR [ebx+ebp]
  00f26	89 4c 24 0c	 mov	 DWORD PTR _pbPattern$GSCopy$[esp+1072], ecx
  00f2a	89 74 24 1c	 mov	 DWORD PTR _pbTargetMax$[esp+1072], esi
  00f2e	3b c3		 cmp	 eax, ebx

; 3041 :         return(NULL);

  00f30	0f 87 ff 01 00
	00		 ja	 $LN87@Railgun_Qu@5

; 3042 : 
; 3043 : // Doesn't work when cbPattern = 1
; 3044 : // 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!
; 3045 : 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.

  00f36	57		 push	 edi
  00f37	83 f8 04	 cmp	 eax, 4
  00f3a	73 7d		 jae	 SHORT $LN41@Railgun_Qu@5

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

  00f3c	0f be 39	 movsx	 edi, BYTE PTR [ecx]
  00f3f	0f be 54 01 ff	 movsx	 edx, BYTE PTR [ecx+eax-1]
  00f44	c1 e7 08	 shl	 edi, 8
  00f47	03 e8		 add	 ebp, eax
  00f49	03 d7		 add	 edx, edi

; 3048 : //        countSTATIC = cbPattern-2;
; 3049 : 
; 3050 : if ( cbPattern==3) {

  00f4b	83 f8 03	 cmp	 eax, 3
  00f4e	8b c2		 mov	 eax, edx
  00f50	75 32		 jne	 SHORT $LN70@Railgun_Qu@5
  00f52	c1 e8 08	 shr	 eax, 8
$LL39@Railgun_Qu@5:

; 3051 :     for ( ;; )
; 3052 :     {
; 3053 :         if ( ulHashPattern == ( (*(char *)(pbTarget-3))<<8 ) + *(pbTarget-1) ) {

  00f55	0f be 7d fd	 movsx	 edi, BYTE PTR [ebp-3]
  00f59	0f be 5d ff	 movsx	 ebx, BYTE PTR [ebp-1]
  00f5d	c1 e7 08	 shl	 edi, 8
  00f60	03 fb		 add	 edi, ebx
  00f62	3b d7		 cmp	 edx, edi
  00f64	75 0e		 jne	 SHORT $LN83@Railgun_Qu@5

; 3054 :          if ( *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) Railgunhits++; //return((pbTarget-3));

  00f66	8a 59 01	 mov	 bl, BYTE PTR [ecx+1]
  00f69	3a 5d fe	 cmp	 bl, BYTE PTR [ebp-2]
  00f6c	75 06		 jne	 SHORT $LN83@Railgun_Qu@5
  00f6e	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits
$LN83@Railgun_Qu@5:

; 3055 :         }
; 3056 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-2) ) pbTarget++;

  00f74	3a 45 fe	 cmp	 al, BYTE PTR [ebp-2]
  00f77	74 01		 je	 SHORT $LN84@Railgun_Qu@5
  00f79	45		 inc	 ebp
$LN84@Railgun_Qu@5:

; 3057 :         pbTarget++;

  00f7a	45		 inc	 ebp

; 3058 :         if (pbTarget > pbTargetMax)

  00f7b	3b ee		 cmp	 ebp, esi
  00f7d	76 d6		 jbe	 SHORT $LL39@Railgun_Qu@5

; 3059 :             return(NULL);

  00f7f	e9 b0 01 00 00	 jmp	 $LN86@Railgun_Qu@5
$LN70@Railgun_Qu@5:
  00f84	c1 e8 08	 shr	 eax, 8
  00f87	b9 01 00 00 00	 mov	 ecx, 1
  00f8c	8d 64 24 00	 npad	 4
$LL32@Railgun_Qu@5:

; 3060 :     }
; 3061 : } else {
; 3062 : }
; 3063 :     for ( ;; )
; 3064 :     {
; 3065 :         // The line below gives for 'cbPattern'>=1:
; 3066 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 3067 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 3068 : /*
; 3069 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 3070 :             return((long)(pbTarget-cbPattern));
; 3071 : */
; 3072 : 
; 3073 :         // The fragment below gives for 'cbPattern'>=2:
; 3074 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 3075 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 3076 : 
; 3077 : /*
; 3078 : //For 2 and 3 [
; 3079 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 3080 : //         count = countSTATIC;
; 3081 :          count = cbPattern-2;
; 3082 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 3083 :          while ( count && *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) { // Crippling i.e. only 2 and 3 chars are allowed!
; 3084 :                count--;
; 3085 :          }
; 3086 :          if ( count == 0) return((pbTarget-cbPattern));
; 3087 :         }
; 3088 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-cbPattern+1) ) pbTarget++;
; 3089 : //For 2 and 3 ]
; 3090 : */
; 3091 : 
; 3092 : 
; 3093 :         if ( ulHashPattern == ( (*(char *)(pbTarget-2))<<8 ) + *(pbTarget-1) )

  00f90	0f be 7d fe	 movsx	 edi, BYTE PTR [ebp-2]
  00f94	0f be 5d ff	 movsx	 ebx, BYTE PTR [ebp-1]
  00f98	c1 e7 08	 shl	 edi, 8
  00f9b	03 fb		 add	 edi, ebx
  00f9d	3b d7		 cmp	 edx, edi
  00f9f	75 06		 jne	 SHORT $LN30@Railgun_Qu@5

; 3094 :             Railgunhits++; //return((pbTarget-2));

  00fa1	01 0d 00 00 00
	00		 add	 DWORD PTR _Railgunhits, ecx
$LN30@Railgun_Qu@5:

; 3095 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-1) ) pbTarget++;

  00fa7	3a 45 ff	 cmp	 al, BYTE PTR [ebp-1]
  00faa	74 02		 je	 SHORT $LN29@Railgun_Qu@5
  00fac	03 e9		 add	 ebp, ecx
$LN29@Railgun_Qu@5:

; 3096 : 
; 3097 : 
; 3098 :         // The fragment below gives for 'cbPattern'>=2:
; 3099 : 	// Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/554
; 3100 : 	// Karp_Rabin_Kaze_4_OCTETS performance: 364KB/clock
; 3101 : /*
; 3102 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 3103 :          count = countSTATIC>>2;
; 3104 :          countRemainder = countSTATIC % 4;
; 3105 : 
; 3106 :          while ( count && *(unsigned long *)(pbPattern+1+((count-1)<<2)) == *(unsigned long *)(pbTarget-cbPattern+1+((count-1)<<2)) ) {
; 3107 :                count--;
; 3108 :          }
; 3109 : 	 //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.
; 3110 :          while ( countRemainder && *(char *)(pbPattern+1+(countSTATIC-countRemainder)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-countRemainder)) ) {
; 3111 :                countRemainder--;
; 3112 :          }
; 3113 :          //if ( countRemainder == 0) return((long)(pbTarget-cbPattern));
; 3114 :          if ( count+countRemainder == 0) return((long)(pbTarget-cbPattern));
; 3115 :          //}
; 3116 :         }
; 3117 : */
; 3118 : 
; 3119 :         pbTarget++;

  00fae	03 e9		 add	 ebp, ecx

; 3120 :         if (pbTarget > pbTargetMax)

  00fb0	3b ee		 cmp	 ebp, esi
  00fb2	76 dc		 jbe	 SHORT $LL32@Railgun_Qu@5

; 3121 :             return(NULL);

  00fb4	e9 7b 01 00 00	 jmp	 $LN86@Railgun_Qu@5
$LN41@Railgun_Qu@5:

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

  00fb9	81 fb c1 03 00
	00		 cmp	 ebx, 961		; 000003c1H
  00fbf	0f 83 dc 00 00
	00		 jae	 $LN26@Railgun_Qu@5

; 3125 : {
; 3126 :         pbTarget = pbTarget+cbPattern;
; 3127 :         ulHashPattern = *(unsigned long *)(pbPattern);

  00fc5	8b 11		 mov	 edx, DWORD PTR [ecx]

; 3128 : //        countSTATIC = cbPattern-1;
; 3129 : 
; 3130 :     //SINGLET = *(char *)(pbPattern);
; 3131 :     SINGLET = ulHashPattern & 0xFF;
; 3132 :     Quadruplet2nd = SINGLET<<8;

  00fc7	0f b6 ca	 movzx	 ecx, dl
  00fca	8b f1		 mov	 esi, ecx
  00fcc	c1 e6 08	 shl	 esi, 8
  00fcf	89 74 24 28	 mov	 DWORD PTR _Quadruplet2nd$[esp+1076], esi

; 3133 :     Quadruplet3rd = SINGLET<<16;

  00fd3	8b f1		 mov	 esi, ecx
  00fd5	c1 e6 10	 shl	 esi, 16			; 00000010H
  00fd8	03 e8		 add	 ebp, eax
  00fda	89 4c 24 2c	 mov	 DWORD PTR tv531[esp+1076], ecx

; 3134 :     Quadruplet4th = SINGLET<<24;

  00fde	c1 e1 18	 shl	 ecx, 24			; 00000018H
  00fe1	89 54 24 18	 mov	 DWORD PTR _ulHashPattern$[esp+1076], edx
  00fe5	89 74 24 1c	 mov	 DWORD PTR _Quadruplet3rd$[esp+1076], esi
  00fe9	89 4c 24 24	 mov	 DWORD PTR _Quadruplet4th$[esp+1076], ecx
  00fed	eb 05		 jmp	 SHORT $LN25@Railgun_Qu@5
  00fef	90		 npad	 1
$LL81@Railgun_Qu@5:
  00ff0	8b 54 24 18	 mov	 edx, DWORD PTR _ulHashPattern$[esp+1076]
$LN25@Railgun_Qu@5:

; 3135 : 
; 3136 :     for ( ;; )
; 3137 :     {
; 3138 : 	AdvanceHopperGrass = 0;
; 3139 : 	ulHashTarget = *(unsigned long *)(pbTarget-cbPattern);

  00ff4	8b cd		 mov	 ecx, ebp
  00ff6	2b c8		 sub	 ecx, eax
  00ff8	8b 09		 mov	 ecx, DWORD PTR [ecx]
  00ffa	33 db		 xor	 ebx, ebx
  00ffc	89 5c 24 14	 mov	 DWORD PTR _AdvanceHopperGrass$[esp+1076], ebx

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

  01000	3b d1		 cmp	 edx, ecx
  01002	75 53		 jne	 SHORT $LN23@Railgun_Qu@5

; 3142 : //         count = countSTATIC;
; 3143 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 3144 : //	       if ( countSTATIC==AdvanceHopperGrass+count && SINGLET != *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) AdvanceHopperGrass++;
; 3145 : //               count--;
; 3146 : //         }
; 3147 :          count = cbPattern-1;

  01004	8d 48 ff	 lea	 ecx, DWORD PTR [eax-1]

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

  01007	85 c9		 test	 ecx, ecx
  01009	74 44		 je	 SHORT $LN62@Railgun_Qu@5

; 3142 : //         count = countSTATIC;
; 3143 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 3144 : //	       if ( countSTATIC==AdvanceHopperGrass+count && SINGLET != *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) AdvanceHopperGrass++;
; 3145 : //               count--;
; 3146 : //         }
; 3147 :          count = cbPattern-1;

  0100b	8b 74 24 10	 mov	 esi, DWORD PTR _pbPattern$GSCopy$[esp+1076]
  0100f	8b fd		 mov	 edi, ebp
  01011	2b f1		 sub	 esi, ecx
  01013	2b f9		 sub	 edi, ecx
  01015	03 f0		 add	 esi, eax
$LL22@Railgun_Qu@5:

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

  01017	8a 17		 mov	 dl, BYTE PTR [edi]
  01019	38 16		 cmp	 BYTE PTR [esi], dl
  0101b	75 2e		 jne	 SHORT $LN21@Railgun_Qu@5

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

  0101d	8d 50 ff	 lea	 edx, DWORD PTR [eax-1]
  01020	03 d9		 add	 ebx, ecx
  01022	3b d3		 cmp	 edx, ebx
  01024	75 14		 jne	 SHORT $LN78@Railgun_Qu@5
  01026	0f be 17	 movsx	 edx, BYTE PTR [edi]
  01029	39 54 24 2c	 cmp	 DWORD PTR tv531[esp+1076], edx
  0102d	74 0b		 je	 SHORT $LN78@Railgun_Qu@5
  0102f	8b 5c 24 14	 mov	 ebx, DWORD PTR _AdvanceHopperGrass$[esp+1076]
  01033	43		 inc	 ebx
  01034	89 5c 24 14	 mov	 DWORD PTR _AdvanceHopperGrass$[esp+1076], ebx
  01038	eb 04		 jmp	 SHORT $LN20@Railgun_Qu@5
$LN78@Railgun_Qu@5:
  0103a	8b 5c 24 14	 mov	 ebx, DWORD PTR _AdvanceHopperGrass$[esp+1076]
$LN20@Railgun_Qu@5:

; 3150 :                count--;

  0103e	46		 inc	 esi
  0103f	47		 inc	 edi
  01040	49		 dec	 ecx
  01041	75 d4		 jne	 SHORT $LL22@Railgun_Qu@5

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

  01043	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits

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

  01049	eb 43		 jmp	 SHORT $LN79@Railgun_Qu@5
$LN21@Railgun_Qu@5:

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

  0104b	85 c9		 test	 ecx, ecx
  0104d	75 3f		 jne	 SHORT $LN79@Railgun_Qu@5
$LN62@Railgun_Qu@5:
  0104f	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits

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

  01055	eb 37		 jmp	 SHORT $LN79@Railgun_Qu@5
$LN23@Railgun_Qu@5:

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

  01057	8b d1		 mov	 edx, ecx
  01059	81 e2 00 ff 00
	00		 and	 edx, 65280		; 0000ff00H
  0105f	39 54 24 28	 cmp	 DWORD PTR _Quadruplet2nd$[esp+1076], edx
  01063	74 29		 je	 SHORT $LN79@Railgun_Qu@5

; 3155 :          AdvanceHopperGrass++;
; 3156 :          if ( Quadruplet3rd != (ulHashTarget & 0x00FF0000) ) {

  01065	8b d1		 mov	 edx, ecx
  01067	81 e2 00 00 ff
	00		 and	 edx, 16711680		; 00ff0000H
  0106d	bb 01 00 00 00	 mov	 ebx, 1
  01072	39 54 24 1c	 cmp	 DWORD PTR _Quadruplet3rd$[esp+1076], edx
  01076	74 16		 je	 SHORT $LN79@Railgun_Qu@5

; 3157 :               AdvanceHopperGrass++;
; 3158 :               if ( Quadruplet4th != (ulHashTarget & 0xFF000000) ) AdvanceHopperGrass++;

  01078	81 e1 00 00 00
	ff		 and	 ecx, -16777216		; ff000000H
  0107e	bb 02 00 00 00	 mov	 ebx, 2
  01083	39 4c 24 24	 cmp	 DWORD PTR _Quadruplet4th$[esp+1076], ecx
  01087	74 05		 je	 SHORT $LN79@Railgun_Qu@5
  01089	bb 03 00 00 00	 mov	 ebx, 3
$LN79@Railgun_Qu@5:

; 3159 :          }
; 3160 :     }
; 3161 : 	}
; 3162 : 
; 3163 : 	AdvanceHopperGrass++;
; 3164 : 
; 3165 : 	pbTarget = pbTarget + AdvanceHopperGrass;

  0108e	8d 6c 2b 01	 lea	 ebp, DWORD PTR [ebx+ebp+1]

; 3166 :         if (pbTarget > pbTargetMax)

  01092	3b 6c 24 20	 cmp	 ebp, DWORD PTR _pbTargetMax$[esp+1076]
  01096	0f 86 54 ff ff
	ff		 jbe	 $LL81@Railgun_Qu@5

; 3167 :             return(NULL);

  0109c	e9 93 00 00 00	 jmp	 $LN86@Railgun_Qu@5
$LN26@Railgun_Qu@5:

; 3168 :     }
; 3169 : } else { //if (cbTarget<961)
; 3170 :         //countSTATIC = cbPattern-2; //r.6+
; 3171 :         //countSTATIC = cbPattern-2-3;
; 3172 :         //countSTATIC = cbPattern-2-2; // r.6+++ I suppose that the awful degradation comes from 2bytes more (from either 'if (countSTATIC<0) countSTATIC=0;' or 'count >0' fixes) which make the function unfittable in code cache lines?!
; 3173 :         //countSTATIC = cbPattern-2-3; // r.7- At last no recompared bytes in-between chars
; 3174 :         countSTATIC = cbPattern-2-2; // r.7 
; 3175 :         ulHashPattern = *(unsigned long *)(pbPattern+cbPattern-1-3);

  010a1	8b 4c 01 fc	 mov	 ecx, DWORD PTR [ecx+eax-4]
  010a5	89 4c 24 18	 mov	 DWORD PTR _ulHashPattern$[esp+1076], ecx
  010a9	8d 50 fc	 lea	 edx, DWORD PTR [eax-4]

; 3176 : 
; 3177 :         //chPTR=(unsigned char *)&chchchch+3;
; 3178 : // Next line fixes the BUG from r.6++: but with awful speed degradation! So the bug is fixed in the definitions by setting 'countSTATIC = cbPattern-2-2;', bug appears only for patterns with lengths of 4, The setback is one unnecessary comparison for 5bytes patterns, stupidly such setback exists (from before) for 4bytes as well.
; 3179 : //if (countSTATIC<0) countSTATIC=0;
; 3180 :     /* Preprocessing */
; 3181 :     for (a=0; a < ASIZE; a++) bm_bc[a]=cbPattern;

  010ac	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  010b1	8d 7c 24 30	 lea	 edi, DWORD PTR _bm_bc$[esp+1076]
  010b5	89 54 24 24	 mov	 DWORD PTR _countSTATIC$[esp+1076], edx
  010b9	f3 ab		 rep stosd

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

  010bb	8d 50 ff	 lea	 edx, DWORD PTR [eax-1]
  010be	33 c9		 xor	 ecx, ecx
  010c0	85 d2		 test	 edx, edx
  010c2	74 1e		 je	 SHORT $LN7@Railgun_Qu@5
  010c4	8d 70 ff	 lea	 esi, DWORD PTR [eax-1]
  010c7	eb 07 8d a4 24
	00 00 00 00	 npad	 9
$LL9@Railgun_Qu@5:
  010d0	8b 7c 24 10	 mov	 edi, DWORD PTR _pbPattern$GSCopy$[esp+1076]
  010d4	0f be 3c 0f	 movsx	 edi, BYTE PTR [edi+ecx]
  010d8	89 74 bc 30	 mov	 DWORD PTR _bm_bc$[esp+edi*4+1076], esi
  010dc	41		 inc	 ecx
  010dd	4e		 dec	 esi
  010de	3b ca		 cmp	 ecx, edx
  010e0	72 ee		 jb	 SHORT $LL9@Railgun_Qu@5
$LN7@Railgun_Qu@5:

; 3183 : 
; 3184 :     /* Searching */
; 3185 :     //lastch=pbPattern[cbPattern-1];
; 3186 :     //firstch=pbPattern[0];
; 3187 :     i=0;

  010e2	33 ff		 xor	 edi, edi

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

  010e4	2b d8		 sub	 ebx, eax
  010e6	8d 54 28 fc	 lea	 edx, DWORD PTR [eax+ebp-4]
  010ea	89 5c 24 1c	 mov	 DWORD PTR $T7261[esp+1076], ebx
  010ee	89 54 24 20	 mov	 DWORD PTR tv560[esp+1076], edx
$LL6@Railgun_Qu@5:

; 3189 :        //ch=pbTarget[i+cbPattern-1];
; 3190 :        ulHashTarget=*(unsigned long *)&pbTarget[i+cbPattern-1-3];

  010f2	8b 44 24 20	 mov	 eax, DWORD PTR tv560[esp+1076]
  010f6	8b 14 38	 mov	 edx, DWORD PTR [eax+edi]

; 3191 :           if (ulHashTarget == ulHashPattern) // No problema here since we have 4[+] long pattern here. Overlapping (1 byte recompared) when length=4, grmbl.

  010f9	3b 54 24 18	 cmp	 edx, DWORD PTR _ulHashPattern$[esp+1076]
  010fd	75 28		 jne	 SHORT $LN80@Railgun_Qu@5

; 3192 :              {
; 3193 :          count = countSTATIC;

  010ff	8b 44 24 24	 mov	 eax, DWORD PTR _countSTATIC$[esp+1076]

; 3194 :          while ( count !=0 && *(char *)(pbPattern+(countSTATIC-count)) == *(char *)(&pbTarget[i]+(countSTATIC-count)) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.

  01103	85 c0		 test	 eax, eax
  01105	74 1a		 je	 SHORT $LN61@Railgun_Qu@5

; 3192 :              {
; 3193 :          count = countSTATIC;

  01107	8b 74 24 10	 mov	 esi, DWORD PTR _pbPattern$GSCopy$[esp+1076]
  0110b	8d 0c 2f	 lea	 ecx, DWORD PTR [edi+ebp]
  0110e	8b ff		 npad	 2
$LL3@Railgun_Qu@5:

; 3194 :          while ( count !=0 && *(char *)(pbPattern+(countSTATIC-count)) == *(char *)(&pbTarget[i]+(countSTATIC-count)) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.

  01110	8a 1e		 mov	 bl, BYTE PTR [esi]
  01112	3a 19		 cmp	 bl, BYTE PTR [ecx]
  01114	75 07		 jne	 SHORT $LN2@Railgun_Qu@5

; 3195 :                count--;

  01116	41		 inc	 ecx
  01117	46		 inc	 esi
  01118	48		 dec	 eax
  01119	75 f5		 jne	 SHORT $LL3@Railgun_Qu@5

; 3196 :          }
; 3197 :          if ( count == 0) Railgunhits++; //return(pbTarget+i);

  0111b	eb 04		 jmp	 SHORT $LN61@Railgun_Qu@5
$LN2@Railgun_Qu@5:
  0111d	85 c0		 test	 eax, eax
  0111f	75 06		 jne	 SHORT $LN80@Railgun_Qu@5
$LN61@Railgun_Qu@5:
  01121	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits
$LN80@Railgun_Qu@5:

; 3198 : 	     }
; 3199 :        //i+=bm_bc[*chPTR]; // Twice as slow than the below line!
; 3200 :        i+=bm_bc[(unsigned char)(ulHashTarget>>24)];

  01127	c1 ea 18	 shr	 edx, 24			; 00000018H
  0112a	03 7c 94 30	 add	 edi, DWORD PTR _bm_bc$[esp+edx*4+1076]
  0112e	3b 7c 24 1c	 cmp	 edi, DWORD PTR $T7261[esp+1076]
  01132	76 be		 jbe	 SHORT $LL6@Railgun_Qu@5
$LN86@Railgun_Qu@5:
  01134	5f		 pop	 edi
$LN87@Railgun_Qu@5:

; 3201 :     }
; 3202 :     return(NULL);
; 3203 : } //if (cbTarget<961)
; 3204 : } //if ( cbPattern<4)
; 3205 : }

  01135	8b 8c 24 2c 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1072]
  0113c	5e		 pop	 esi
  0113d	5d		 pop	 ebp
  0113e	5b		 pop	 ebx
  0113f	33 cc		 xor	 ecx, esp
  01141	33 c0		 xor	 eax, eax
  01143	e8 00 00 00 00	 call	 @__security_check_cookie@4
  01148	81 c4 24 04 00
	00		 add	 esp, 1060		; 00000424H
  0114e	c3		 ret	 0
_Railgun_Quadruplet_7m_count_hits ENDP
_TEXT	ENDS
PUBLIC	_pbPattern$GSCopy$
PUBLIC	__$ArrayPad$
PUBLIC	_Railgun_Quadruplet_7_count_hits
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_pbPattern$GSCopy$ = -1060				; size = 4
_ulHashPattern$ = -1056					; size = 4
_AdvanceHopperGrass$ = -1052				; size = 4
_countSTATIC$ = -1048					; size = 4
_pbTargetMax$ = -1048					; size = 4
$T7309 = -1044						; size = 4
_Quadruplet4th$ = -1044					; size = 4
tv532 = -1040						; size = 4
_Quadruplet3rd$ = -1036					; size = 4
_Quadruplet2nd$ = -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_7_count_hits PROC

; 3216 : {

  01150	81 ec 24 04 00
	00		 sub	 esp, 1060		; 00000424H
  01156	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  0115b	33 c4		 xor	 eax, esp
  0115d	89 84 24 20 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1060], eax
  01164	8b 94 24 2c 04
	00 00		 mov	 edx, DWORD PTR _pbPattern$[esp+1056]
  0116b	53		 push	 ebx

; 3217 :     char * pbTargetMax = pbTarget + cbTarget;

  0116c	8b 9c 24 34 04
	00 00		 mov	 ebx, DWORD PTR _cbTarget$[esp+1060]
  01173	55		 push	 ebp
  01174	8b ac 24 30 04
	00 00		 mov	 ebp, DWORD PTR _pbTarget$[esp+1064]
  0117b	56		 push	 esi

; 3218 :     register unsigned long ulHashPattern;
; 3219 :     unsigned long ulHashTarget;
; 3220 :     //unsigned long count; //r.6+
; 3221 :     signed long count;
; 3222 :     //unsigned long countSTATIC; //r.6+
; 3223 :     signed long countSTATIC;
; 3224 : //  unsigned long countRemainder;
; 3225 : 
; 3226 : /*
; 3227 :     const unsigned char SINGLET = *(char *)(pbPattern);
; 3228 :     const unsigned long Quadruplet2nd = SINGLET<<8;
; 3229 :     const unsigned long Quadruplet3rd = SINGLET<<16;
; 3230 :     const unsigned long Quadruplet4th = SINGLET<<24;
; 3231 : */
; 3232 :     unsigned char SINGLET;
; 3233 :     unsigned long Quadruplet2nd;
; 3234 :     unsigned long Quadruplet3rd;
; 3235 :     unsigned long Quadruplet4th;
; 3236 : 
; 3237 :     unsigned long  AdvanceHopperGrass;
; 3238 : 
; 3239 :     long i; //BMH needed
; 3240 :     int a, j, bm_bc[ASIZE]; //BMH needed
; 3241 :     unsigned char ch; //BMH needed
; 3242 :     unsigned long chchchch; //BMH needed
; 3243 :     unsigned short chchchchSHORT; //BMH needed
; 3244 :     //unsigned char * chPTR;
; 3245 :     unsigned char firstch; //BMH needed
; 3246 : //    unsigned char lastch, firstch; //BMH needed
; 3247 : 
; 3248 :     if (cbPattern > cbTarget)

  0117c	8b b4 24 40 04
	00 00		 mov	 esi, DWORD PTR _cbPattern$[esp+1068]
  01183	57		 push	 edi
  01184	8d 3c 2b	 lea	 edi, DWORD PTR [ebx+ebp]
  01187	89 54 24 10	 mov	 DWORD PTR _pbPattern$GSCopy$[esp+1076], edx
  0118b	89 7c 24 1c	 mov	 DWORD PTR _pbTargetMax$[esp+1076], edi
  0118f	3b f3		 cmp	 esi, ebx

; 3249 :         return(NULL);

  01191	0f 87 fe 01 00
	00		 ja	 $LN88@Railgun_Qu@6

; 3250 : 
; 3251 : // Doesn't work when cbPattern = 1
; 3252 : // 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!
; 3253 : 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.

  01197	83 fe 04	 cmp	 esi, 4
  0119a	73 7d		 jae	 SHORT $LN41@Railgun_Qu@6

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

  0119c	0f be 0a	 movsx	 ecx, BYTE PTR [edx]
  0119f	0f be 44 32 ff	 movsx	 eax, BYTE PTR [edx+esi-1]
  011a4	c1 e1 08	 shl	 ecx, 8
  011a7	03 c1		 add	 eax, ecx

; 3256 : //        countSTATIC = cbPattern-2;
; 3257 : 
; 3258 : if ( cbPattern==3) {

  011a9	8b c8		 mov	 ecx, eax
  011ab	03 ee		 add	 ebp, esi
  011ad	c1 e9 08	 shr	 ecx, 8
  011b0	83 fe 03	 cmp	 esi, 3
  011b3	75 2f		 jne	 SHORT $LN70@Railgun_Qu@6
$LL39@Railgun_Qu@6:

; 3259 :     for ( ;; )
; 3260 :     {
; 3261 :         if ( ulHashPattern == ( (*(char *)(pbTarget-3))<<8 ) + *(pbTarget-1) ) {

  011b5	0f be 75 fd	 movsx	 esi, BYTE PTR [ebp-3]
  011b9	0f be 5d ff	 movsx	 ebx, BYTE PTR [ebp-1]
  011bd	c1 e6 08	 shl	 esi, 8
  011c0	03 f3		 add	 esi, ebx
  011c2	3b c6		 cmp	 eax, esi
  011c4	75 0e		 jne	 SHORT $LN85@Railgun_Qu@6

; 3262 :          if ( *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) Railgunhits++; //return((pbTarget-3));

  011c6	8a 5a 01	 mov	 bl, BYTE PTR [edx+1]
  011c9	3a 5d fe	 cmp	 bl, BYTE PTR [ebp-2]
  011cc	75 06		 jne	 SHORT $LN85@Railgun_Qu@6
  011ce	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits
$LN85@Railgun_Qu@6:

; 3263 :         }
; 3264 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-2) ) pbTarget++;

  011d4	3a 4d fe	 cmp	 cl, BYTE PTR [ebp-2]
  011d7	74 01		 je	 SHORT $LN86@Railgun_Qu@6
  011d9	45		 inc	 ebp
$LN86@Railgun_Qu@6:

; 3265 :         pbTarget++;

  011da	45		 inc	 ebp

; 3266 :         if (pbTarget > pbTargetMax)

  011db	3b ef		 cmp	 ebp, edi
  011dd	76 d6		 jbe	 SHORT $LL39@Railgun_Qu@6

; 3267 :             return(NULL);

  011df	e9 b1 01 00 00	 jmp	 $LN88@Railgun_Qu@6
$LN70@Railgun_Qu@6:
  011e4	ba 01 00 00 00	 mov	 edx, 1
  011e9	8d a4 24 00 00
	00 00		 npad	 7
$LL32@Railgun_Qu@6:

; 3268 :     }
; 3269 : } else {
; 3270 : }
; 3271 :     for ( ;; )
; 3272 :     {
; 3273 :         // The line below gives for 'cbPattern'>=1:
; 3274 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 3275 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 3276 : /*
; 3277 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 3278 :             return((long)(pbTarget-cbPattern));
; 3279 : */
; 3280 : 
; 3281 :         // The fragment below gives for 'cbPattern'>=2:
; 3282 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 3283 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 3284 : 
; 3285 : /*
; 3286 : //For 2 and 3 [
; 3287 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 3288 : //         count = countSTATIC;
; 3289 :          count = cbPattern-2;
; 3290 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 3291 :          while ( count && *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) { // Crippling i.e. only 2 and 3 chars are allowed!
; 3292 :                count--;
; 3293 :          }
; 3294 :          if ( count == 0) return((pbTarget-cbPattern));
; 3295 :         }
; 3296 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-cbPattern+1) ) pbTarget++;
; 3297 : //For 2 and 3 ]
; 3298 : */
; 3299 : 
; 3300 : 
; 3301 :         if ( ulHashPattern == ( (*(char *)(pbTarget-2))<<8 ) + *(pbTarget-1) )

  011f0	0f be 75 fe	 movsx	 esi, BYTE PTR [ebp-2]
  011f4	0f be 5d ff	 movsx	 ebx, BYTE PTR [ebp-1]
  011f8	c1 e6 08	 shl	 esi, 8
  011fb	03 f3		 add	 esi, ebx
  011fd	3b c6		 cmp	 eax, esi
  011ff	75 06		 jne	 SHORT $LN30@Railgun_Qu@6

; 3302 :             Railgunhits++; //return((pbTarget-2));

  01201	01 15 00 00 00
	00		 add	 DWORD PTR _Railgunhits, edx
$LN30@Railgun_Qu@6:

; 3303 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-1) ) pbTarget++;

  01207	3a 4d ff	 cmp	 cl, BYTE PTR [ebp-1]
  0120a	74 02		 je	 SHORT $LN29@Railgun_Qu@6
  0120c	03 ea		 add	 ebp, edx
$LN29@Railgun_Qu@6:

; 3304 : 
; 3305 : 
; 3306 :         // The fragment below gives for 'cbPattern'>=2:
; 3307 : 	// Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/554
; 3308 : 	// Karp_Rabin_Kaze_4_OCTETS performance: 364KB/clock
; 3309 : /*
; 3310 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 3311 :          count = countSTATIC>>2;
; 3312 :          countRemainder = countSTATIC % 4;
; 3313 : 
; 3314 :          while ( count && *(unsigned long *)(pbPattern+1+((count-1)<<2)) == *(unsigned long *)(pbTarget-cbPattern+1+((count-1)<<2)) ) {
; 3315 :                count--;
; 3316 :          }
; 3317 : 	 //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.
; 3318 :          while ( countRemainder && *(char *)(pbPattern+1+(countSTATIC-countRemainder)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-countRemainder)) ) {
; 3319 :                countRemainder--;
; 3320 :          }
; 3321 :          //if ( countRemainder == 0) return((long)(pbTarget-cbPattern));
; 3322 :          if ( count+countRemainder == 0) return((long)(pbTarget-cbPattern));
; 3323 :          //}
; 3324 :         }
; 3325 : */
; 3326 : 
; 3327 :         pbTarget++;

  0120e	03 ea		 add	 ebp, edx

; 3328 :         if (pbTarget > pbTargetMax)

  01210	3b ef		 cmp	 ebp, edi
  01212	76 dc		 jbe	 SHORT $LL32@Railgun_Qu@6

; 3329 :             return(NULL);

  01214	e9 7c 01 00 00	 jmp	 $LN88@Railgun_Qu@6
$LN41@Railgun_Qu@6:

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

  01219	81 fb c1 03 00
	00		 cmp	 ebx, 961		; 000003c1H
  0121f	0f 83 e4 00 00
	00		 jae	 $LN26@Railgun_Qu@6

; 3333 : {
; 3334 :         pbTarget = pbTarget+cbPattern;
; 3335 :         ulHashPattern = *(unsigned long *)(pbPattern);

  01225	8b 02		 mov	 eax, DWORD PTR [edx]
  01227	89 44 24 14	 mov	 DWORD PTR _ulHashPattern$[esp+1076], eax

; 3336 : //        countSTATIC = cbPattern-1;
; 3337 : 
; 3338 :     //SINGLET = *(char *)(pbPattern);
; 3339 :     SINGLET = ulHashPattern & 0xFF;
; 3340 :     Quadruplet2nd = SINGLET<<8;

  0122b	0f b6 c0	 movzx	 eax, al
  0122e	8b f8		 mov	 edi, eax

; 3341 :     Quadruplet3rd = SINGLET<<16;

  01230	8b c8		 mov	 ecx, eax
  01232	c1 e7 08	 shl	 edi, 8
  01235	c1 e1 10	 shl	 ecx, 16			; 00000010H
  01238	03 ee		 add	 ebp, esi
  0123a	89 44 24 24	 mov	 DWORD PTR tv532[esp+1076], eax

; 3342 :     Quadruplet4th = SINGLET<<24;

  0123e	c1 e0 18	 shl	 eax, 24			; 00000018H
  01241	89 7c 24 2c	 mov	 DWORD PTR _Quadruplet2nd$[esp+1076], edi
  01245	89 4c 24 28	 mov	 DWORD PTR _Quadruplet3rd$[esp+1076], ecx
  01249	89 44 24 20	 mov	 DWORD PTR _Quadruplet4th$[esp+1076], eax
  0124d	eb 05		 jmp	 SHORT $LN25@Railgun_Qu@6
  0124f	90		 npad	 1
$LL84@Railgun_Qu@6:
  01250	8b 7c 24 2c	 mov	 edi, DWORD PTR _Quadruplet2nd$[esp+1076]
$LN25@Railgun_Qu@6:

; 3343 : 
; 3344 :     for ( ;; )
; 3345 :     {
; 3346 : 	AdvanceHopperGrass = 0;
; 3347 : 	ulHashTarget = *(unsigned long *)(pbTarget-cbPattern);

  01254	8b c5		 mov	 eax, ebp
  01256	2b c6		 sub	 eax, esi
  01258	8b 08		 mov	 ecx, DWORD PTR [eax]
  0125a	33 db		 xor	 ebx, ebx
  0125c	89 5c 24 18	 mov	 DWORD PTR _AdvanceHopperGrass$[esp+1076], ebx

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

  01260	39 4c 24 14	 cmp	 DWORD PTR _ulHashPattern$[esp+1076], ecx
  01264	75 57		 jne	 SHORT $LN23@Railgun_Qu@6

; 3350 : //         count = countSTATIC;
; 3351 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 3352 : //	       if ( countSTATIC==AdvanceHopperGrass+count && SINGLET != *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) AdvanceHopperGrass++;
; 3353 : //               count--;
; 3354 : //         }
; 3355 :          count = cbPattern-1;

  01266	8d 4e ff	 lea	 ecx, DWORD PTR [esi-1]

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

  01269	85 c9		 test	 ecx, ecx
  0126b	74 48		 je	 SHORT $LN62@Railgun_Qu@6

; 3350 : //         count = countSTATIC;
; 3351 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 3352 : //	       if ( countSTATIC==AdvanceHopperGrass+count && SINGLET != *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) AdvanceHopperGrass++;
; 3353 : //               count--;
; 3354 : //         }
; 3355 :          count = cbPattern-1;

  0126d	8b fd		 mov	 edi, ebp
  0126f	2b d1		 sub	 edx, ecx
  01271	2b f9		 sub	 edi, ecx
  01273	03 d6		 add	 edx, esi
$LL22@Railgun_Qu@6:

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

  01275	8a 07		 mov	 al, BYTE PTR [edi]
  01277	38 02		 cmp	 BYTE PTR [edx], al
  01279	75 32		 jne	 SHORT $LN21@Railgun_Qu@6

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

  0127b	8d 46 ff	 lea	 eax, DWORD PTR [esi-1]
  0127e	03 d9		 add	 ebx, ecx
  01280	3b c3		 cmp	 eax, ebx
  01282	75 14		 jne	 SHORT $LN78@Railgun_Qu@6
  01284	0f be 07	 movsx	 eax, BYTE PTR [edi]
  01287	39 44 24 24	 cmp	 DWORD PTR tv532[esp+1076], eax
  0128b	74 0b		 je	 SHORT $LN78@Railgun_Qu@6
  0128d	8b 5c 24 18	 mov	 ebx, DWORD PTR _AdvanceHopperGrass$[esp+1076]
  01291	43		 inc	 ebx
  01292	89 5c 24 18	 mov	 DWORD PTR _AdvanceHopperGrass$[esp+1076], ebx
  01296	eb 04		 jmp	 SHORT $LN20@Railgun_Qu@6
$LN78@Railgun_Qu@6:
  01298	8b 5c 24 18	 mov	 ebx, DWORD PTR _AdvanceHopperGrass$[esp+1076]
$LN20@Railgun_Qu@6:

; 3358 :                count--;

  0129c	42		 inc	 edx
  0129d	47		 inc	 edi
  0129e	49		 dec	 ecx
  0129f	75 d4		 jne	 SHORT $LL22@Railgun_Qu@6

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

  012a1	8b 54 24 10	 mov	 edx, DWORD PTR _pbPattern$GSCopy$[esp+1076]
  012a5	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits

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

  012ab	eb 49		 jmp	 SHORT $LN82@Railgun_Qu@6
$LN21@Railgun_Qu@6:

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

  012ad	85 c9		 test	 ecx, ecx
  012af	75 41		 jne	 SHORT $LN80@Railgun_Qu@6
  012b1	8b 54 24 10	 mov	 edx, DWORD PTR _pbPattern$GSCopy$[esp+1076]
$LN62@Railgun_Qu@6:
  012b5	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits

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

  012bb	eb 39		 jmp	 SHORT $LN82@Railgun_Qu@6
$LN23@Railgun_Qu@6:

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

  012bd	8b c1		 mov	 eax, ecx
  012bf	25 00 ff 00 00	 and	 eax, 65280		; 0000ff00H
  012c4	3b f8		 cmp	 edi, eax
  012c6	74 2e		 je	 SHORT $LN82@Railgun_Qu@6

; 3363 :          AdvanceHopperGrass++;
; 3364 :          if ( Quadruplet3rd != (ulHashTarget & 0x00FF0000) ) {

  012c8	8b c1		 mov	 eax, ecx
  012ca	25 00 00 ff 00	 and	 eax, 16711680		; 00ff0000H
  012cf	bb 01 00 00 00	 mov	 ebx, 1
  012d4	39 44 24 28	 cmp	 DWORD PTR _Quadruplet3rd$[esp+1076], eax
  012d8	74 1c		 je	 SHORT $LN82@Railgun_Qu@6

; 3365 :               AdvanceHopperGrass++;
; 3366 :               if ( Quadruplet4th != (ulHashTarget & 0xFF000000) ) AdvanceHopperGrass++;

  012da	81 e1 00 00 00
	ff		 and	 ecx, -16777216		; ff000000H
  012e0	bb 02 00 00 00	 mov	 ebx, 2
  012e5	39 4c 24 20	 cmp	 DWORD PTR _Quadruplet4th$[esp+1076], ecx
  012e9	74 0b		 je	 SHORT $LN82@Railgun_Qu@6
  012eb	bb 03 00 00 00	 mov	 ebx, 3
  012f0	eb 04		 jmp	 SHORT $LN82@Railgun_Qu@6
$LN80@Railgun_Qu@6:
  012f2	8b 54 24 10	 mov	 edx, DWORD PTR _pbPattern$GSCopy$[esp+1076]
$LN82@Railgun_Qu@6:

; 3367 :          }
; 3368 :     }
; 3369 : 	}
; 3370 : 
; 3371 : 	AdvanceHopperGrass++;
; 3372 : 
; 3373 : 	pbTarget = pbTarget + AdvanceHopperGrass;

  012f6	8d 6c 2b 01	 lea	 ebp, DWORD PTR [ebx+ebp+1]

; 3374 :         if (pbTarget > pbTargetMax)

  012fa	3b 6c 24 1c	 cmp	 ebp, DWORD PTR _pbTargetMax$[esp+1076]
  012fe	0f 86 4c ff ff
	ff		 jbe	 $LL84@Railgun_Qu@6

; 3375 :             return(NULL);

  01304	e9 8c 00 00 00	 jmp	 $LN88@Railgun_Qu@6
$LN26@Railgun_Qu@6:

; 3376 :     }
; 3377 : } else { //if (cbTarget<961)
; 3378 :         //countSTATIC = cbPattern-2; //r.6+
; 3379 :         //countSTATIC = cbPattern-2-3;
; 3380 :         //countSTATIC = cbPattern-2-2; // r.6+++ I suppose that the awful degradation comes from 2bytes more (from either 'if (countSTATIC<0) countSTATIC=0;' or 'count >0' fixes) which make the function unfittable in code cache lines?!
; 3381 :         //countSTATIC = cbPattern-2-3; // r.7- At last no recompared bytes in-between chars
; 3382 :         countSTATIC = cbPattern-2-2; // r.7 
; 3383 :         ulHashPattern = *(unsigned long *)(pbPattern);

  01309	8b 12		 mov	 edx, DWORD PTR [edx]
  0130b	8d 4e fc	 lea	 ecx, DWORD PTR [esi-4]
  0130e	89 4c 24 1c	 mov	 DWORD PTR _countSTATIC$[esp+1076], ecx

; 3384 : 
; 3385 :         //chPTR=(unsigned char *)&chchchch+3;
; 3386 : // Next line fixes the BUG from r.6++: but with awful speed degradation! So the bug is fixed in the definitions by setting 'countSTATIC = cbPattern-2-2;', bug appears only for patterns with lengths of 4, The setback is one unnecessary comparison for 5bytes patterns, stupidly such setback exists (from before) for 4bytes as well.
; 3387 : //if (countSTATIC<0) countSTATIC=0;
; 3388 :     /* Preprocessing */
; 3389 :     for (a=0; a < ASIZE; a++) bm_bc[a]=cbPattern;

  01312	8b c6		 mov	 eax, esi
  01314	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  01319	8d 7c 24 30	 lea	 edi, DWORD PTR _bm_bc$[esp+1076]
  0131d	f3 ab		 rep stosd

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

  0131f	8d 4e ff	 lea	 ecx, DWORD PTR [esi-1]
  01322	33 c0		 xor	 eax, eax
  01324	89 54 24 14	 mov	 DWORD PTR _ulHashPattern$[esp+1076], edx
  01328	85 c9		 test	 ecx, ecx
  0132a	74 16		 je	 SHORT $LN7@Railgun_Qu@6
  0132c	8d 56 ff	 lea	 edx, DWORD PTR [esi-1]
  0132f	90		 npad	 1
$LL9@Railgun_Qu@6:
  01330	8b 7c 24 10	 mov	 edi, DWORD PTR _pbPattern$GSCopy$[esp+1076]
  01334	0f be 3c 07	 movsx	 edi, BYTE PTR [edi+eax]
  01338	89 54 bc 30	 mov	 DWORD PTR _bm_bc$[esp+edi*4+1076], edx
  0133c	40		 inc	 eax
  0133d	4a		 dec	 edx
  0133e	3b c1		 cmp	 eax, ecx
  01340	72 ee		 jb	 SHORT $LL9@Railgun_Qu@6
$LN7@Railgun_Qu@6:

; 3391 : 
; 3392 :     /* Searching */
; 3393 :     //lastch=pbPattern[cbPattern-1];
; 3394 :     //firstch=pbPattern[0];
; 3395 :     i=0;

  01342	33 d2		 xor	 edx, edx

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

  01344	2b de		 sub	 ebx, esi
  01346	89 5c 24 20	 mov	 DWORD PTR $T7309[esp+1076], ebx
  0134a	8d 74 2e ff	 lea	 esi, DWORD PTR [esi+ebp-1]
  0134e	8b ff		 npad	 2
$LL6@Railgun_Qu@6:

; 3397 :        //ch=pbTarget[i+cbPattern-1];
; 3398 :        //ch=pbTarget[i];
; 3399 :           //if ( pbTarget[i] == pbPattern[0] && *(unsigned long *)&pbTarget[i+cbPattern-1-3] == ulHashPattern) // No problema here since we have 4[+] long pattern here. Overlapping (1 byte recompared) when length=4, grmbl.
; 3400 :           if ( *(unsigned long *)&pbTarget[i] == ulHashPattern ) // The lesson I learned from r.7- now applied in r.7: instead of extracting 'ch' having higher address now the lower address is extracted first in order (hopefully, the test confirms it) the next 32bytes (including 'ch') to be cached i.e. to comparison part is faster.

  01350	8b 44 24 14	 mov	 eax, DWORD PTR _ulHashPattern$[esp+1076]
  01354	39 04 2a	 cmp	 DWORD PTR [edx+ebp], eax
  01357	75 2e		 jne	 SHORT $LN79@Railgun_Qu@6

; 3401 :              {
; 3402 :          count = countSTATIC;

  01359	8b 44 24 1c	 mov	 eax, DWORD PTR _countSTATIC$[esp+1076]

; 3403 :          while ( count !=0 && *(char *)(pbPattern+(countSTATIC-count)+4) == *(char *)(&pbTarget[i]+(countSTATIC-count)+4) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.

  0135d	85 c0		 test	 eax, eax
  0135f	74 20		 je	 SHORT $LN81@Railgun_Qu@6

; 3401 :              {
; 3402 :          count = countSTATIC;

  01361	8b 7c 24 10	 mov	 edi, DWORD PTR _pbPattern$GSCopy$[esp+1076]
  01365	83 c7 04	 add	 edi, 4
  01368	8d 4c 2a 04	 lea	 ecx, DWORD PTR [edx+ebp+4]
  0136c	8d 64 24 00	 npad	 4
$LL3@Railgun_Qu@6:

; 3403 :          while ( count !=0 && *(char *)(pbPattern+(countSTATIC-count)+4) == *(char *)(&pbTarget[i]+(countSTATIC-count)+4) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.

  01370	8a 1f		 mov	 bl, BYTE PTR [edi]
  01372	3a 19		 cmp	 bl, BYTE PTR [ecx]
  01374	75 07		 jne	 SHORT $LN2@Railgun_Qu@6

; 3404 :                count--;

  01376	41		 inc	 ecx
  01377	47		 inc	 edi
  01378	48		 dec	 eax
  01379	75 f5		 jne	 SHORT $LL3@Railgun_Qu@6

; 3405 :          }
; 3406 :          if ( count == 0) Railgunhits++; //return(pbTarget+i);

  0137b	eb 04		 jmp	 SHORT $LN81@Railgun_Qu@6
$LN2@Railgun_Qu@6:
  0137d	85 c0		 test	 eax, eax
  0137f	75 06		 jne	 SHORT $LN79@Railgun_Qu@6
$LN81@Railgun_Qu@6:
  01381	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits
$LN79@Railgun_Qu@6:

; 3407 : 	     }
; 3408 :        i= i + bm_bc[(unsigned char)pbTarget[i+cbPattern-1]];

  01387	0f b6 0c 16	 movzx	 ecx, BYTE PTR [esi+edx]
  0138b	03 54 8c 30	 add	 edx, DWORD PTR _bm_bc$[esp+ecx*4+1076]
  0138f	3b 54 24 20	 cmp	 edx, DWORD PTR $T7309[esp+1076]
  01393	76 bb		 jbe	 SHORT $LL6@Railgun_Qu@6
$LN88@Railgun_Qu@6:

; 3409 :     }
; 3410 :     return(NULL);
; 3411 : } //if (cbTarget<961)
; 3412 : } //if ( cbPattern<4)
; 3413 : }

  01395	8b 8c 24 30 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1076]
  0139c	5f		 pop	 edi
  0139d	5e		 pop	 esi
  0139e	5d		 pop	 ebp
  0139f	5b		 pop	 ebx
  013a0	33 cc		 xor	 ecx, esp
  013a2	33 c0		 xor	 eax, eax
  013a4	e8 00 00 00 00	 call	 @__security_check_cookie@4
  013a9	81 c4 24 04 00
	00		 add	 esp, 1060		; 00000424H
  013af	c3		 ret	 0
_Railgun_Quadruplet_7_count_hits ENDP
_TEXT	ENDS
PUBLIC	_pbPattern$GSCopy$
PUBLIC	__$ArrayPad$
PUBLIC	_Railgun_Quadruplet_7
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
tv660 = -1061						; size = 1
_ulHashPattern$ = -1060					; size = 4
_AdvanceHopperGrass$ = -1056				; size = 4
$T7363 = -1052						; size = 4
_Quadruplet2nd$ = -1052					; size = 4
_pbPattern$GSCopy$ = -1048				; size = 4
tv531 = -1044						; size = 4
_pbTargetMax$ = -1040					; size = 4
_Quadruplet3rd$ = -1036					; size = 4
_Quadruplet4th$ = -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_7 PROC

; 3423 : {

  013b0	81 ec 28 04 00
	00		 sub	 esp, 1064		; 00000428H
  013b6	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  013bb	33 c4		 xor	 eax, esp
  013bd	89 84 24 24 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1064], eax

; 3424 :     char * pbTargetMax = pbTarget + cbTarget;

  013c4	8b 84 24 34 04
	00 00		 mov	 eax, DWORD PTR _cbTarget$[esp+1060]

; 3425 :     register unsigned long  ulHashPattern;
; 3426 :     unsigned long ulHashTarget;
; 3427 :     //unsigned long count; //r.6+
; 3428 :     signed long count;
; 3429 :     //unsigned long countSTATIC; //r.6+
; 3430 :     signed long countSTATIC;
; 3431 : //  unsigned long countRemainder;
; 3432 : 
; 3433 : /*
; 3434 :     const unsigned char SINGLET = *(char *)(pbPattern);
; 3435 :     const unsigned long Quadruplet2nd = SINGLET<<8;
; 3436 :     const unsigned long Quadruplet3rd = SINGLET<<16;
; 3437 :     const unsigned long Quadruplet4th = SINGLET<<24;
; 3438 : */
; 3439 :     unsigned char SINGLET;
; 3440 :     unsigned long Quadruplet2nd;
; 3441 :     unsigned long Quadruplet3rd;
; 3442 :     unsigned long Quadruplet4th;
; 3443 : 
; 3444 :     unsigned long  AdvanceHopperGrass;
; 3445 : 
; 3446 :     long i; //BMH needed
; 3447 :     int a, j, bm_bc[ASIZE]; //BMH needed
; 3448 :     unsigned char ch; //BMH needed
; 3449 :     unsigned long chchchch; //BMH needed
; 3450 : //    unsigned char lastch, firstch; //BMH needed
; 3451 : 
; 3452 :     if (cbPattern > cbTarget)

  013cb	8b 94 24 38 04
	00 00		 mov	 edx, DWORD PTR _cbPattern$[esp+1060]
  013d2	53		 push	 ebx
  013d3	8b 9c 24 34 04
	00 00		 mov	 ebx, DWORD PTR _pbPattern$[esp+1064]
  013da	56		 push	 esi
  013db	8b b4 24 34 04
	00 00		 mov	 esi, DWORD PTR _pbTarget$[esp+1068]
  013e2	57		 push	 edi
  013e3	8d 3c 06	 lea	 edi, DWORD PTR [esi+eax]
  013e6	89 5c 24 1c	 mov	 DWORD PTR _pbPattern$GSCopy$[esp+1076], ebx
  013ea	89 7c 24 24	 mov	 DWORD PTR _pbTargetMax$[esp+1076], edi
  013ee	3b d0		 cmp	 edx, eax
  013f0	76 1a		 jbe	 SHORT $LN42@Railgun_Qu@7

; 3453 :         return(NULL);

  013f2	5f		 pop	 edi
  013f3	5e		 pop	 esi
  013f4	33 c0		 xor	 eax, eax
  013f6	5b		 pop	 ebx

; 3615 : } //if (cbTarget<961)
; 3616 : } //if ( cbPattern<4)
; 3617 : }

  013f7	8b 8c 24 24 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1064]
  013fe	33 cc		 xor	 ecx, esp
  01400	e8 00 00 00 00	 call	 @__security_check_cookie@4
  01405	81 c4 28 04 00
	00		 add	 esp, 1064		; 00000428H
  0140b	c3		 ret	 0
$LN42@Railgun_Qu@7:
  0140c	55		 push	 ebp

; 3454 : 
; 3455 : // Doesn't work when cbPattern = 1
; 3456 : // 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!
; 3457 : 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.

  0140d	83 fa 04	 cmp	 edx, 4
  01410	0f 83 9d 00 00
	00		 jae	 $LN41@Railgun_Qu@7

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

  01416	0f be 03	 movsx	 eax, BYTE PTR [ebx]
  01419	0f be 4c 13 ff	 movsx	 ecx, BYTE PTR [ebx+edx-1]
  0141e	c1 e0 08	 shl	 eax, 8
  01421	03 f2		 add	 esi, edx
  01423	03 c8		 add	 ecx, eax

; 3460 : //        countSTATIC = cbPattern-2;
; 3461 : 
; 3462 : if ( cbPattern==3) {

  01425	83 fa 03	 cmp	 edx, 3
  01428	75 4f		 jne	 SHORT $LN46@Railgun_Qu@7
  0142a	8d 9b 00 00 00
	00		 npad	 6
$LL39@Railgun_Qu@7:

; 3463 :     for ( ;; )
; 3464 :     {
; 3465 :         if ( ulHashPattern == ( (*(char *)(pbTarget-3))<<8 ) + *(pbTarget-1) ) {

  01430	0f be 56 fd	 movsx	 edx, BYTE PTR [esi-3]
  01434	0f be 46 ff	 movsx	 eax, BYTE PTR [esi-1]
  01438	c1 e2 08	 shl	 edx, 8
  0143b	03 d0		 add	 edx, eax
  0143d	3b ca		 cmp	 ecx, edx
  0143f	75 08		 jne	 SHORT $LN36@Railgun_Qu@7

; 3466 :          if ( *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) return((pbTarget-3));

  01441	8a 53 01	 mov	 dl, BYTE PTR [ebx+1]
  01444	3a 56 fe	 cmp	 dl, BYTE PTR [esi-2]
  01447	74 2b		 je	 SHORT $LN53@Railgun_Qu@7
$LN36@Railgun_Qu@7:

; 3467 :         }
; 3468 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-2) ) pbTarget++;

  01449	8b c1		 mov	 eax, ecx
  0144b	c1 e8 08	 shr	 eax, 8
  0144e	3a 46 fe	 cmp	 al, BYTE PTR [esi-2]
  01451	74 01		 je	 SHORT $LN35@Railgun_Qu@7
  01453	46		 inc	 esi
$LN35@Railgun_Qu@7:

; 3469 :         pbTarget++;

  01454	46		 inc	 esi

; 3470 :         if (pbTarget > pbTargetMax)

  01455	3b f7		 cmp	 esi, edi
  01457	76 d7		 jbe	 SHORT $LL39@Railgun_Qu@7
$LN5@Railgun_Qu@7:

; 3613 :     }
; 3614 :     return(NULL);

  01459	33 c0		 xor	 eax, eax
$LN73@Railgun_Qu@7:

; 3615 : } //if (cbTarget<961)
; 3616 : } //if ( cbPattern<4)
; 3617 : }

  0145b	8b 8c 24 34 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1080]
  01462	5d		 pop	 ebp
  01463	5f		 pop	 edi
  01464	5e		 pop	 esi
  01465	5b		 pop	 ebx
  01466	33 cc		 xor	 ecx, esp
  01468	e8 00 00 00 00	 call	 @__security_check_cookie@4
  0146d	81 c4 28 04 00
	00		 add	 esp, 1064		; 00000428H
  01473	c3		 ret	 0
$LN53@Railgun_Qu@7:

; 3466 :          if ( *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) return((pbTarget-3));

  01474	8d 46 fd	 lea	 eax, DWORD PTR [esi-3]

; 3471 :             return(NULL);

  01477	eb e2		 jmp	 SHORT $LN73@Railgun_Qu@7
$LN46@Railgun_Qu@7:

; 3472 :     }
; 3473 : } else {
; 3474 : }
; 3475 :     for ( ;; )
; 3476 :     {
; 3477 :         // The line below gives for 'cbPattern'>=1:
; 3478 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 3479 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 3480 : /*
; 3481 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 3482 :             return((long)(pbTarget-cbPattern));
; 3483 : */
; 3484 : 
; 3485 :         // The fragment below gives for 'cbPattern'>=2:
; 3486 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 3487 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 3488 : 
; 3489 : /*
; 3490 : //For 2 and 3 [
; 3491 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 3492 : //         count = countSTATIC;
; 3493 :          count = cbPattern-2;
; 3494 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 3495 :          while ( count && *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) { // Crippling i.e. only 2 and 3 chars are allowed!
; 3496 :                count--;
; 3497 :          }
; 3498 :          if ( count == 0) return((pbTarget-cbPattern));
; 3499 :         }
; 3500 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-cbPattern+1) ) pbTarget++;
; 3501 : //For 2 and 3 ]
; 3502 : */
; 3503 : 
; 3504 : 
; 3505 :         if ( ulHashPattern == ( (*(char *)(pbTarget-2))<<8 ) + *(pbTarget-1) )

  01479	8a 46 ff	 mov	 al, BYTE PTR [esi-1]
  0147c	0f be 56 fe	 movsx	 edx, BYTE PTR [esi-2]
  01480	0f be d8	 movsx	 ebx, al
  01483	c1 e2 08	 shl	 edx, 8
  01486	03 d3		 add	 edx, ebx
  01488	3b ca		 cmp	 ecx, edx
  0148a	74 22		 je	 SHORT $LN55@Railgun_Qu@7
  0148c	8b d1		 mov	 edx, ecx
  0148e	c1 ea 08	 shr	 edx, 8
$LL32@Railgun_Qu@7:

; 3507 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-1) ) pbTarget++;

  01491	3a d0		 cmp	 dl, al
  01493	74 01		 je	 SHORT $LN72@Railgun_Qu@7
  01495	46		 inc	 esi
$LN72@Railgun_Qu@7:

; 3508 : 
; 3509 : 
; 3510 :         // The fragment below gives for 'cbPattern'>=2:
; 3511 : 	// Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/554
; 3512 : 	// Karp_Rabin_Kaze_4_OCTETS performance: 364KB/clock
; 3513 : /*
; 3514 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 3515 :          count = countSTATIC>>2;
; 3516 :          countRemainder = countSTATIC % 4;
; 3517 : 
; 3518 :          while ( count && *(unsigned long *)(pbPattern+1+((count-1)<<2)) == *(unsigned long *)(pbTarget-cbPattern+1+((count-1)<<2)) ) {
; 3519 :                count--;
; 3520 :          }
; 3521 : 	 //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.
; 3522 :          while ( countRemainder && *(char *)(pbPattern+1+(countSTATIC-countRemainder)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-countRemainder)) ) {
; 3523 :                countRemainder--;
; 3524 :          }
; 3525 :          //if ( countRemainder == 0) return((long)(pbTarget-cbPattern));
; 3526 :          if ( count+countRemainder == 0) return((long)(pbTarget-cbPattern));
; 3527 :          //}
; 3528 :         }
; 3529 : */
; 3530 : 
; 3531 :         pbTarget++;

  01496	46		 inc	 esi

; 3532 :         if (pbTarget > pbTargetMax)

  01497	3b f7		 cmp	 esi, edi
  01499	77 be		 ja	 SHORT $LN5@Railgun_Qu@7

; 3472 :     }
; 3473 : } else {
; 3474 : }
; 3475 :     for ( ;; )
; 3476 :     {
; 3477 :         // The line below gives for 'cbPattern'>=1:
; 3478 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 3479 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 3480 : /*
; 3481 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 3482 :             return((long)(pbTarget-cbPattern));
; 3483 : */
; 3484 : 
; 3485 :         // The fragment below gives for 'cbPattern'>=2:
; 3486 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 3487 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 3488 : 
; 3489 : /*
; 3490 : //For 2 and 3 [
; 3491 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 3492 : //         count = countSTATIC;
; 3493 :          count = cbPattern-2;
; 3494 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 3495 :          while ( count && *(char *)(pbPattern+1) == *(char *)(pbTarget-2) ) { // Crippling i.e. only 2 and 3 chars are allowed!
; 3496 :                count--;
; 3497 :          }
; 3498 :          if ( count == 0) return((pbTarget-cbPattern));
; 3499 :         }
; 3500 :         if ( (char)(ulHashPattern>>8) != *(pbTarget-cbPattern+1) ) pbTarget++;
; 3501 : //For 2 and 3 ]
; 3502 : */
; 3503 : 
; 3504 : 
; 3505 :         if ( ulHashPattern == ( (*(char *)(pbTarget-2))<<8 ) + *(pbTarget-1) )

  0149b	8a 46 ff	 mov	 al, BYTE PTR [esi-1]
  0149e	0f be 5e fe	 movsx	 ebx, BYTE PTR [esi-2]
  014a2	0f be e8	 movsx	 ebp, al
  014a5	c1 e3 08	 shl	 ebx, 8
  014a8	03 dd		 add	 ebx, ebp
  014aa	3b cb		 cmp	 ecx, ebx
  014ac	75 e3		 jne	 SHORT $LL32@Railgun_Qu@7
$LN55@Railgun_Qu@7:

; 3506 :             return((pbTarget-2));

  014ae	8d 46 fe	 lea	 eax, DWORD PTR [esi-2]

; 3533 :             return(NULL);

  014b1	eb a8		 jmp	 SHORT $LN73@Railgun_Qu@7
$LN41@Railgun_Qu@7:

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

  014b3	3d c1 03 00 00	 cmp	 eax, 961		; 000003c1H

; 3537 : {
; 3538 :         pbTarget = pbTarget+cbPattern;
; 3539 :         ulHashPattern = *(unsigned long *)(pbPattern);

  014b8	8b 03		 mov	 eax, DWORD PTR [ebx]
  014ba	89 44 24 14	 mov	 DWORD PTR _ulHashPattern$[esp+1080], eax
  014be	0f 83 dc 00 00
	00		 jae	 $LN26@Railgun_Qu@7

; 3540 : //        countSTATIC = cbPattern-1;
; 3541 : 
; 3542 :     //SINGLET = *(char *)(pbPattern);
; 3543 :     SINGLET = ulHashPattern & 0xFF;
; 3544 :     Quadruplet2nd = SINGLET<<8;

  014c4	0f b6 c0	 movzx	 eax, al
  014c7	8b f8		 mov	 edi, eax

; 3545 :     Quadruplet3rd = SINGLET<<16;

  014c9	8b c8		 mov	 ecx, eax
  014cb	c1 e7 08	 shl	 edi, 8
  014ce	c1 e1 10	 shl	 ecx, 16			; 00000010H
  014d1	03 f2		 add	 esi, edx
  014d3	89 44 24 24	 mov	 DWORD PTR tv531[esp+1080], eax

; 3546 :     Quadruplet4th = SINGLET<<24;

  014d7	c1 e0 18	 shl	 eax, 24			; 00000018H
  014da	89 7c 24 1c	 mov	 DWORD PTR _Quadruplet2nd$[esp+1080], edi
  014de	89 4c 24 2c	 mov	 DWORD PTR _Quadruplet3rd$[esp+1080], ecx
  014e2	89 44 24 30	 mov	 DWORD PTR _Quadruplet4th$[esp+1080], eax
$LL25@Railgun_Qu@7:

; 3547 : 
; 3548 :     for ( ;; )
; 3549 :     {
; 3550 : 	AdvanceHopperGrass = 0;
; 3551 : 	ulHashTarget = *(unsigned long *)(pbTarget-cbPattern);

  014e6	8b c6		 mov	 eax, esi
  014e8	2b c2		 sub	 eax, edx
  014ea	8b 00		 mov	 eax, DWORD PTR [eax]
  014ec	33 ed		 xor	 ebp, ebp
  014ee	89 6c 24 18	 mov	 DWORD PTR _AdvanceHopperGrass$[esp+1080], ebp

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

  014f2	39 44 24 14	 cmp	 DWORD PTR _ulHashPattern$[esp+1080], eax
  014f6	75 5d		 jne	 SHORT $LN23@Railgun_Qu@7

; 3554 : //         count = countSTATIC;
; 3555 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 3556 : //	       if ( countSTATIC==AdvanceHopperGrass+count && SINGLET != *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) AdvanceHopperGrass++;
; 3557 : //               count--;
; 3558 : //         }
; 3559 :          count = cbPattern-1;

  014f8	8d 42 ff	 lea	 eax, DWORD PTR [edx-1]

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

  014fb	85 c0		 test	 eax, eax
  014fd	74 43		 je	 SHORT $LN65@Railgun_Qu@7

; 3554 : //         count = countSTATIC;
; 3555 : //         while ( count && *(char *)(pbPattern+1+(countSTATIC-count)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) {
; 3556 : //	       if ( countSTATIC==AdvanceHopperGrass+count && SINGLET != *(char *)(pbTarget-cbPattern+1+(countSTATIC-count)) ) AdvanceHopperGrass++;
; 3557 : //               count--;
; 3558 : //         }
; 3559 :          count = cbPattern-1;

  014ff	8b cb		 mov	 ecx, ebx
  01501	8b fe		 mov	 edi, esi
  01503	2b c8		 sub	 ecx, eax
  01505	2b f8		 sub	 edi, eax
  01507	03 ca		 add	 ecx, edx
  01509	8d a4 24 00 00
	00 00		 npad	 7
$LL22@Railgun_Qu@7:

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

  01510	8a 1f		 mov	 bl, BYTE PTR [edi]
  01512	88 5c 24 13	 mov	 BYTE PTR tv660[esp+1080], bl
  01516	38 19		 cmp	 BYTE PTR [ecx], bl
  01518	75 31		 jne	 SHORT $LN21@Railgun_Qu@7

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

  0151a	8d 5a ff	 lea	 ebx, DWORD PTR [edx-1]
  0151d	03 e8		 add	 ebp, eax
  0151f	3b dd		 cmp	 ebx, ebp
  01521	75 16		 jne	 SHORT $LN68@Railgun_Qu@7
  01523	0f be 5c 24 13	 movsx	 ebx, BYTE PTR tv660[esp+1080]
  01528	39 5c 24 24	 cmp	 DWORD PTR tv531[esp+1080], ebx
  0152c	74 0b		 je	 SHORT $LN68@Railgun_Qu@7
  0152e	8b 6c 24 18	 mov	 ebp, DWORD PTR _AdvanceHopperGrass$[esp+1080]
  01532	45		 inc	 ebp
  01533	89 6c 24 18	 mov	 DWORD PTR _AdvanceHopperGrass$[esp+1080], ebp
  01537	eb 04		 jmp	 SHORT $LN20@Railgun_Qu@7
$LN68@Railgun_Qu@7:
  01539	8b 6c 24 18	 mov	 ebp, DWORD PTR _AdvanceHopperGrass$[esp+1080]
$LN20@Railgun_Qu@7:

; 3562 :                count--;

  0153d	41		 inc	 ecx
  0153e	47		 inc	 edi
  0153f	48		 dec	 eax
  01540	75 ce		 jne	 SHORT $LL22@Railgun_Qu@7
$LN65@Railgun_Qu@7:

; 3563 :          }
; 3564 :          if ( count == 0) return((pbTarget-cbPattern));

  01542	8b c6		 mov	 eax, esi
  01544	2b c2		 sub	 eax, edx

; 3579 :             return(NULL);

  01546	e9 10 ff ff ff	 jmp	 $LN73@Railgun_Qu@7
$LN21@Railgun_Qu@7:

; 3563 :          }
; 3564 :          if ( count == 0) return((pbTarget-cbPattern));

  0154b	85 c0		 test	 eax, eax
  0154d	74 f3		 je	 SHORT $LN65@Railgun_Qu@7

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

  0154f	8b 5c 24 20	 mov	 ebx, DWORD PTR _pbPattern$GSCopy$[esp+1080]
  01553	eb 34		 jmp	 SHORT $LN69@Railgun_Qu@7
$LN23@Railgun_Qu@7:

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

  01555	8b c8		 mov	 ecx, eax
  01557	81 e1 00 ff 00
	00		 and	 ecx, 65280		; 0000ff00H
  0155d	3b f9		 cmp	 edi, ecx
  0155f	74 28		 je	 SHORT $LN69@Railgun_Qu@7

; 3567 :          AdvanceHopperGrass++;
; 3568 :          if ( Quadruplet3rd != (ulHashTarget & 0x00FF0000) ) {

  01561	8b c8		 mov	 ecx, eax
  01563	81 e1 00 00 ff
	00		 and	 ecx, 16711680		; 00ff0000H
  01569	bd 01 00 00 00	 mov	 ebp, 1
  0156e	39 4c 24 2c	 cmp	 DWORD PTR _Quadruplet3rd$[esp+1080], ecx
  01572	74 15		 je	 SHORT $LN69@Railgun_Qu@7

; 3569 :               AdvanceHopperGrass++;
; 3570 :               if ( Quadruplet4th != (ulHashTarget & 0xFF000000) ) AdvanceHopperGrass++;

  01574	25 00 00 00 ff	 and	 eax, -16777216		; ff000000H
  01579	bd 02 00 00 00	 mov	 ebp, 2
  0157e	39 44 24 30	 cmp	 DWORD PTR _Quadruplet4th$[esp+1080], eax
  01582	74 05		 je	 SHORT $LN69@Railgun_Qu@7
  01584	bd 03 00 00 00	 mov	 ebp, 3
$LN69@Railgun_Qu@7:

; 3571 :          }
; 3572 :     }
; 3573 : 	}
; 3574 : 
; 3575 : 	AdvanceHopperGrass++;
; 3576 : 
; 3577 : 	pbTarget = pbTarget + AdvanceHopperGrass;

  01589	8d 74 2e 01	 lea	 esi, DWORD PTR [esi+ebp+1]

; 3578 :         if (pbTarget > pbTargetMax)

  0158d	3b 74 24 28	 cmp	 esi, DWORD PTR _pbTargetMax$[esp+1080]
  01591	0f 87 c2 fe ff
	ff		 ja	 $LN5@Railgun_Qu@7

; 3580 :     }

  01597	8b 7c 24 1c	 mov	 edi, DWORD PTR _Quadruplet2nd$[esp+1080]
  0159b	e9 46 ff ff ff	 jmp	 $LL25@Railgun_Qu@7
$LN26@Railgun_Qu@7:

; 3581 : } else { //if (cbTarget<961)
; 3582 :         //countSTATIC = cbPattern-2; //r.6+
; 3583 :         //countSTATIC = cbPattern-2-3;
; 3584 :         //countSTATIC = cbPattern-2-2; // r.6+++ I suppose that the awful degradation comes from 2bytes more (from either 'if (countSTATIC<0) countSTATIC=0;' or 'count >0' fixes) which make the function unfittable in code cache lines?!
; 3585 :         //countSTATIC = cbPattern-2-3; // r.7- At last no recompared bytes in-between chars
; 3586 :         countSTATIC = cbPattern-2-2; // r.7 
; 3587 :         ulHashPattern = *(unsigned long *)(pbPattern);
; 3588 : 
; 3589 :         //chPTR=(unsigned char *)&chchchch+3;
; 3590 : // Next line fixes the BUG from r.6++: but with awful speed degradation! So the bug is fixed in the definitions by setting 'countSTATIC = cbPattern-2-2;', bug appears only for patterns with lengths of 4, The setback is one unnecessary comparison for 5bytes patterns, stupidly such setback exists (from before) for 4bytes as well.
; 3591 : //if (countSTATIC<0) countSTATIC=0;
; 3592 :     /* Preprocessing */
; 3593 :     for (a=0; a < ASIZE; a++) bm_bc[a]=cbPattern;

  015a0	8b c2		 mov	 eax, edx
  015a2	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  015a7	8d 7c 24 34	 lea	 edi, DWORD PTR _bm_bc$[esp+1080]
  015ab	f3 ab		 rep stosd

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

  015ad	8d 4a ff	 lea	 ecx, DWORD PTR [edx-1]
  015b0	33 c0		 xor	 eax, eax
  015b2	85 c9		 test	 ecx, ecx
  015b4	74 18		 je	 SHORT $LN7@Railgun_Qu@7
  015b6	8d 7a ff	 lea	 edi, DWORD PTR [edx-1]
  015b9	8d a4 24 00 00
	00 00		 npad	 7
$LL9@Railgun_Qu@7:
  015c0	0f be 2c 03	 movsx	 ebp, BYTE PTR [ebx+eax]
  015c4	89 7c ac 34	 mov	 DWORD PTR _bm_bc$[esp+ebp*4+1080], edi
  015c8	40		 inc	 eax
  015c9	4f		 dec	 edi
  015ca	3b c1		 cmp	 eax, ecx
  015cc	72 f2		 jb	 SHORT $LL9@Railgun_Qu@7
$LN7@Railgun_Qu@7:

; 3595 : 
; 3596 :     /* Searching */
; 3597 :     //lastch=pbPattern[cbPattern-1];
; 3598 :     //firstch=pbPattern[0];
; 3599 :     i=0;
; 3600 :     while (i <= cbTarget-cbPattern) {

  015ce	8b 84 24 44 04
	00 00		 mov	 eax, DWORD PTR _cbTarget$[esp+1076]
  015d5	33 ed		 xor	 ebp, ebp
  015d7	2b c2		 sub	 eax, edx
  015d9	89 44 24 1c	 mov	 DWORD PTR $T7363[esp+1080], eax
  015dd	8d 49 00	 npad	 3
$LL6@Railgun_Qu@7:

; 3601 :        //ch=pbTarget[i+cbPattern-1];
; 3602 :        //ch=pbTarget[i];
; 3603 :           //if ( pbTarget[i] == pbPattern[0] && *(unsigned long *)&pbTarget[i+cbPattern-1-3] == ulHashPattern) // No problema here since we have 4[+] long pattern here. Overlapping (1 byte recompared) when length=4, grmbl.
; 3604 :           if ( *(unsigned long *)&pbTarget[i] == ulHashPattern ) // The lesson I learned from r.7- now applied in r.7: instead of extracting 'ch' having higher address now the lower address is extracted first in order (hopefully, the test confirms it) the next 32bytes (including 'ch') to be cached i.e. to comparison part is faster.

  015e0	8b 4c 24 14	 mov	 ecx, DWORD PTR _ulHashPattern$[esp+1080]
  015e4	39 0c 2e	 cmp	 DWORD PTR [esi+ebp], ecx
  015e7	75 29		 jne	 SHORT $LN1@Railgun_Qu@7

; 3605 :              {
; 3606 :          count = countSTATIC;

  015e9	8d 42 fc	 lea	 eax, DWORD PTR [edx-4]

; 3607 :          while ( count !=0 && *(char *)(pbPattern+(countSTATIC-count)+4) == *(char *)(&pbTarget[i]+(countSTATIC-count)+4) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.

  015ec	85 c0		 test	 eax, eax
  015ee	74 12		 je	 SHORT $LN59@Railgun_Qu@7

; 3605 :              {
; 3606 :          count = countSTATIC;

  015f0	8d 7b 04	 lea	 edi, DWORD PTR [ebx+4]
  015f3	8d 4c 2e 04	 lea	 ecx, DWORD PTR [esi+ebp+4]
$LL3@Railgun_Qu@7:

; 3607 :          while ( count !=0 && *(char *)(pbPattern+(countSTATIC-count)+4) == *(char *)(&pbTarget[i]+(countSTATIC-count)+4) ) { // if pattern length is 4 or 5 we have count=-1 and count=0 respectively i.e. no need of comparing in-between chars.

  015f7	8a 1f		 mov	 bl, BYTE PTR [edi]
  015f9	3a 19		 cmp	 bl, BYTE PTR [ecx]
  015fb	75 0d		 jne	 SHORT $LN2@Railgun_Qu@7

; 3608 :                count--;

  015fd	41		 inc	 ecx
  015fe	47		 inc	 edi
  015ff	48		 dec	 eax
  01600	75 f5		 jne	 SHORT $LL3@Railgun_Qu@7
$LN59@Railgun_Qu@7:

; 3609 :          }
; 3610 :          if ( count == 0) return(pbTarget+i);

  01602	8d 04 2e	 lea	 eax, DWORD PTR [esi+ebp]
  01605	e9 51 fe ff ff	 jmp	 $LN73@Railgun_Qu@7
$LN2@Railgun_Qu@7:
  0160a	85 c0		 test	 eax, eax
  0160c	74 f4		 je	 SHORT $LN59@Railgun_Qu@7
  0160e	8b 5c 24 20	 mov	 ebx, DWORD PTR _pbPattern$GSCopy$[esp+1080]
$LN1@Railgun_Qu@7:

; 3611 : 	     }
; 3612 :        i= i + bm_bc[(unsigned char)pbTarget[i+cbPattern-1]];

  01612	8d 04 2e	 lea	 eax, DWORD PTR [esi+ebp]
  01615	0f b6 4c 10 ff	 movzx	 ecx, BYTE PTR [eax+edx-1]
  0161a	03 6c 8c 34	 add	 ebp, DWORD PTR _bm_bc$[esp+ecx*4+1080]
  0161e	3b 6c 24 1c	 cmp	 ebp, DWORD PTR $T7363[esp+1080]
  01622	76 bc		 jbe	 SHORT $LL6@Railgun_Qu@7

; 3595 : 
; 3596 :     /* Searching */
; 3597 :     //lastch=pbPattern[cbPattern-1];
; 3598 :     //firstch=pbPattern[0];
; 3599 :     i=0;
; 3600 :     while (i <= cbTarget-cbPattern) {

  01624	e9 30 fe ff ff	 jmp	 $LN5@Railgun_Qu@7
_Railgun_Quadruplet_7 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
$T7392 = -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

; 3628 : {

  01630	81 ec 18 04 00
	00		 sub	 esp, 1048		; 00000418H
  01636	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  0163b	33 c4		 xor	 eax, esp
  0163d	89 84 24 14 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1048], eax

; 3629 :     char *  pbTargetMax = pbTarget + cbTarget;
; 3630 :     register unsigned long  ulHashPattern;
; 3631 :     unsigned long  ulHashTarget;
; 3632 :     unsigned long  count;
; 3633 :     unsigned long  countSTATIC, countRemainder;
; 3634 : 
; 3635 :     long i; //BMH needed
; 3636 :     int a, j, bm_bc[ASIZE]; //BMH needed
; 3637 :     unsigned char ch; //BMH needed
; 3638 : //    unsigned char lastch, firstch; //BMH needed
; 3639 : 
; 3640 :     if (cbPattern > cbTarget)

  01644	8b 94 24 28 04
	00 00		 mov	 edx, DWORD PTR _cbPattern$[esp+1044]
  0164b	53		 push	 ebx
  0164c	8b 9c 24 24 04
	00 00		 mov	 ebx, DWORD PTR _pbPattern$[esp+1048]
  01653	55		 push	 ebp
  01654	8b ac 24 24 04
	00 00		 mov	 ebp, DWORD PTR _pbTarget$[esp+1052]
  0165b	56		 push	 esi
  0165c	8b b4 24 30 04
	00 00		 mov	 esi, DWORD PTR _cbTarget$[esp+1056]
  01663	8d 04 2e	 lea	 eax, DWORD PTR [esi+ebp]

; 3719 :          }
; 3720 :          if ( count == 0) return(pbTarget+i);

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

; 3641 :         return(NULL);

  01672	5e		 pop	 esi
  01673	5d		 pop	 ebp
  01674	33 c0		 xor	 eax, eax
  01676	5b		 pop	 ebx

; 3725 : }
; 3726 : }

  01677	8b 8c 24 14 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1048]
  0167e	33 cc		 xor	 ecx, esp
  01680	e8 00 00 00 00	 call	 @__security_check_cookie@4
  01685	81 c4 18 04 00
	00		 add	 esp, 1048		; 00000418H
  0168b	c3		 ret	 0
$LN22@Railgun:

; 3642 : 
; 3643 :         countSTATIC = cbPattern-2;

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

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

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

; 3647 : {
; 3648 :         pbTarget = pbTarget+cbPattern;
; 3649 :         ulHashPattern = ( (*(char *)(pbPattern))<<8 ) + *(pbPattern+(cbPattern-1));

  016a0	0f be 03	 movsx	 eax, BYTE PTR [ebx]
  016a3	0f be 4c 13 ff	 movsx	 ecx, BYTE PTR [ebx+edx-1]
  016a8	c1 e0 08	 shl	 eax, 8
  016ab	03 c8		 add	 ecx, eax

; 3697 :     }

  016ad	b8 02 00 00 00	 mov	 eax, 2
  016b2	2b c2		 sub	 eax, edx
  016b4	bf 01 00 00 00	 mov	 edi, 1
  016b9	03 ea		 add	 ebp, edx
  016bb	2b fa		 sub	 edi, edx
  016bd	89 4c 24 14	 mov	 DWORD PTR _ulHashPattern$[esp+1064], ecx
  016c1	89 44 24 10	 mov	 DWORD PTR tv542[esp+1064], eax
  016c5	89 7c 24 18	 mov	 DWORD PTR tv545[esp+1064], edi
  016c9	8d a4 24 00 00
	00 00		 npad	 7
$LL20@Railgun:

; 3650 : 
; 3651 :     for ( ;; )
; 3652 :     {
; 3653 :         // The line below gives for 'cbPattern'>=1:
; 3654 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 3655 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 3656 : /*
; 3657 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 3658 :             return((long)(pbTarget-cbPattern));
; 3659 : */
; 3660 : 
; 3661 :         // The fragment below gives for 'cbPattern'>=2:
; 3662 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 3663 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 3664 : 
; 3665 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {

  016d0	0f be 44 2f ff	 movsx	 eax, BYTE PTR [edi+ebp-1]
  016d5	0f be 75 ff	 movsx	 esi, BYTE PTR [ebp-1]
  016d9	c1 e0 08	 shl	 eax, 8
  016dc	03 c6		 add	 eax, esi
  016de	3b c8		 cmp	 ecx, eax
  016e0	75 30		 jne	 SHORT $LN43@Railgun

; 3666 :          count = countSTATIC;

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

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

  016e6	85 c0		 test	 eax, eax
  016e8	74 16		 je	 SHORT $LN39@Railgun

; 3666 :          count = countSTATIC;

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

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

  016f5	8a 0f		 mov	 cl, BYTE PTR [edi]
  016f7	3a 0e		 cmp	 cl, BYTE PTR [esi]
  016f9	75 0b		 jne	 SHORT $LN16@Railgun

; 3668 :                count--;

  016fb	46		 inc	 esi
  016fc	47		 inc	 edi
  016fd	48		 dec	 eax
  016fe	75 f5		 jne	 SHORT $LL17@Railgun
$LN39@Railgun:

; 3669 :          }
; 3670 :          if ( count == 0) return((pbTarget-cbPattern));

  01700	8b c5		 mov	 eax, ebp
  01702	2b c2		 sub	 eax, edx

; 3696 :             return(NULL);

  01704	eb 15		 jmp	 SHORT $LN44@Railgun
$LN16@Railgun:

; 3669 :          }
; 3670 :          if ( count == 0) return((pbTarget-cbPattern));

  01706	85 c0		 test	 eax, eax
  01708	74 f6		 je	 SHORT $LN39@Railgun
  0170a	8b 4c 24 14	 mov	 ecx, DWORD PTR _ulHashPattern$[esp+1064]
  0170e	8b 7c 24 18	 mov	 edi, DWORD PTR tv545[esp+1064]
$LN43@Railgun:

; 3671 :         }
; 3672 : 
; 3673 :         // The fragment below gives for 'cbPattern'>=2:
; 3674 : 	// Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/554
; 3675 : 	// Karp_Rabin_Kaze_4_OCTETS performance: 364KB/clock
; 3676 : /*
; 3677 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 3678 :          count = countSTATIC>>2;
; 3679 :          countRemainder = countSTATIC % 4;
; 3680 : 
; 3681 :          while ( count && *(unsigned long *)(pbPattern+1+((count-1)<<2)) == *(unsigned long *)(pbTarget-cbPattern+1+((count-1)<<2)) ) {
; 3682 :                count--;
; 3683 :          }
; 3684 : 	 //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.
; 3685 :          while ( countRemainder && *(char *)(pbPattern+1+(countSTATIC-countRemainder)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-countRemainder)) ) {
; 3686 :                countRemainder--;
; 3687 :          }
; 3688 :          //if ( countRemainder == 0) return((long)(pbTarget-cbPattern));
; 3689 :          if ( count+countRemainder == 0) return((long)(pbTarget-cbPattern));
; 3690 :          //}
; 3691 :         }
; 3692 : */
; 3693 : 
; 3694 :         pbTarget++;

  01712	45		 inc	 ebp

; 3695 :         if (pbTarget > pbTargetMax)

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

; 3723 :     }
; 3724 :     return(NULL);

  01719	33 c0		 xor	 eax, eax
$LN44@Railgun:

; 3725 : }
; 3726 : }

  0171b	8b 8c 24 24 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1064]
  01722	5f		 pop	 edi
  01723	5e		 pop	 esi
  01724	5d		 pop	 ebp
  01725	5b		 pop	 ebx
  01726	33 cc		 xor	 ecx, esp
  01728	e8 00 00 00 00	 call	 @__security_check_cookie@4
  0172d	81 c4 18 04 00
	00		 add	 esp, 1048		; 00000418H
  01733	c3		 ret	 0
$LN21@Railgun:

; 3698 : }
; 3699 : else
; 3700 : {
; 3701 :     /* Preprocessing */
; 3702 :     for (a=0; a < ASIZE; a++) bm_bc[a]=cbPattern;

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

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

  01741	8d 7a ff	 lea	 edi, DWORD PTR [edx-1]
  01744	33 c0		 xor	 eax, eax
  01746	85 ff		 test	 edi, edi
  01748	74 18		 je	 SHORT $LN7@Railgun
  0174a	8d 4a ff	 lea	 ecx, DWORD PTR [edx-1]
  0174d	8d 49 00	 npad	 3
$LL42@Railgun:
  01750	0f be 1c 03	 movsx	 ebx, BYTE PTR [ebx+eax]
  01754	89 4c 9c 24	 mov	 DWORD PTR _bm_bc$[esp+ebx*4+1064], ecx
  01758	8b 5c 24 10	 mov	 ebx, DWORD PTR _pbPattern$GSCopy$[esp+1064]
  0175c	40		 inc	 eax
  0175d	49		 dec	 ecx
  0175e	3b c7		 cmp	 eax, edi
  01760	72 ee		 jb	 SHORT $LL42@Railgun
$LN7@Railgun:

; 3704 : 
; 3705 :     /* Searching */
; 3706 :     //lastch=pbPattern[cbPattern-1];
; 3707 :     //firstch=pbPattern[0];
; 3708 :     i=0;

  01762	33 ff		 xor	 edi, edi

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

  01764	2b f2		 sub	 esi, edx
  01766	8d 44 2a ff	 lea	 eax, DWORD PTR [edx+ebp-1]
  0176a	0f be 54 13 ff	 movsx	 edx, BYTE PTR [ebx+edx-1]
  0176f	89 74 24 14	 mov	 DWORD PTR $T7392[esp+1064], esi
  01773	89 44 24 18	 mov	 DWORD PTR tv413[esp+1064], eax
  01777	89 54 24 1c	 mov	 DWORD PTR tv297[esp+1064], edx
  0177b	eb 03 8d 49 00	 npad	 5
$LL6@Railgun:

; 3710 :        ch=pbTarget[i+cbPattern-1];
; 3711 :        //if (ch ==lastch)
; 3712 :           //if (memcmp(&pbTarget[i],pbPattern,cbPattern-1) == 0) OUTPUT(i);
; 3713 :           //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".
; 3714 :           if (ch == pbPattern[cbPattern-1] && pbTarget[i] == pbPattern[0])

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

; 3715 :              {
; 3716 :          count = countSTATIC;

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

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

  01795	85 c0		 test	 eax, eax
  01797	74 12		 je	 SHORT $LN33@Railgun

; 3715 :              {
; 3716 :          count = countSTATIC;

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

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

  017a0	8a 16		 mov	 dl, BYTE PTR [esi]
  017a2	3a 11		 cmp	 dl, BYTE PTR [ecx]
  017a4	75 0d		 jne	 SHORT $LN2@Railgun

; 3718 :                count--;

  017a6	41		 inc	 ecx
  017a7	46		 inc	 esi
  017a8	48		 dec	 eax
  017a9	75 f5		 jne	 SHORT $LL3@Railgun
$LN33@Railgun:

; 3719 :          }
; 3720 :          if ( count == 0) return(pbTarget+i);

  017ab	8d 04 2f	 lea	 eax, DWORD PTR [edi+ebp]
  017ae	e9 68 ff ff ff	 jmp	 $LN44@Railgun
$LN2@Railgun:
  017b3	85 c0		 test	 eax, eax
  017b5	74 f4		 je	 SHORT $LN33@Railgun
  017b7	8b 44 24 18	 mov	 eax, DWORD PTR tv413[esp+1064]
$LN1@Railgun:

; 3721 : 	     }
; 3722 :        i+=bm_bc[ch];

  017bb	0f b6 0c 38	 movzx	 ecx, BYTE PTR [eax+edi]
  017bf	03 7c 8c 24	 add	 edi, DWORD PTR _bm_bc$[esp+ecx*4+1064]
  017c3	3b 7c 24 14	 cmp	 edi, DWORD PTR $T7392[esp+1064]
  017c7	76 b7		 jbe	 SHORT $LL6@Railgun

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

  017c9	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
$T7416 = -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

; 3735 : {

  017d0	55		 push	 ebp
  017d1	8b ec		 mov	 ebp, esp
  017d3	83 e4 f8	 and	 esp, -8			; fffffff8H
  017d6	81 ec 1c 04 00
	00		 sub	 esp, 1052		; 0000041cH
  017dc	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  017e1	33 c4		 xor	 eax, esp
  017e3	89 84 24 18 04
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+1052], eax

; 3736 :     char *  pbTargetMax = pbTarget + cbTarget;

  017ea	8b 55 10	 mov	 edx, DWORD PTR _cbTarget$[ebp]
  017ed	53		 push	 ebx
  017ee	8b 5d 08	 mov	 ebx, DWORD PTR _pbTarget$[ebp]
  017f1	8d 04 13	 lea	 eax, DWORD PTR [ebx+edx]
  017f4	56		 push	 esi
  017f5	8b 75 0c	 mov	 esi, DWORD PTR _pbPattern$[ebp]
  017f8	89 44 24 10	 mov	 DWORD PTR _pbTargetMax$[esp+1060], eax

; 3737 :     register unsigned long  ulHashPattern;
; 3738 :     unsigned long  ulHashTarget;
; 3739 :     unsigned long  count;
; 3740 :     unsigned long  countSTATIC, countRemainder;
; 3741 : 
; 3742 :     long i; //BMH needed
; 3743 :     int a, j, bm_bc[ASIZE]; //BMH needed
; 3744 :     unsigned char ch; //BMH needed
; 3745 : //    unsigned char lastch, firstch; //BMH needed
; 3746 : 
; 3747 :     if (cbPattern > cbTarget)

  017fc	8b 45 14	 mov	 eax, DWORD PTR _cbPattern$[ebp]
  017ff	57		 push	 edi

; 3828 : 	     }
; 3829 :        i+=bm_bc[ch];

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

; 3748 :         return(NULL);
; 3749 : 
; 3750 :         countSTATIC = cbPattern-2;

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

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

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

; 3754 : {
; 3755 :         pbTarget = pbTarget+cbPattern;
; 3756 :         ulHashPattern = ( (*(char *)(pbPattern))<<8 ) + *(pbPattern+(cbPattern-1));

  0181f	0f be 16	 movsx	 edx, BYTE PTR [esi]
  01822	0f be 7c 06 ff	 movsx	 edi, BYTE PTR [esi+eax-1]
  01827	c1 e2 08	 shl	 edx, 8
  0182a	03 fa		 add	 edi, edx

; 3802 :         if (pbTarget > pbTargetMax)

  0182c	b9 02 00 00 00	 mov	 ecx, 2
  01831	2b c8		 sub	 ecx, eax
  01833	ba 01 00 00 00	 mov	 edx, 1
  01838	03 d8		 add	 ebx, eax
  0183a	2b d0		 sub	 edx, eax
  0183c	89 4c 24 0c	 mov	 DWORD PTR tv547[esp+1064], ecx
  01840	89 54 24 10	 mov	 DWORD PTR tv550[esp+1064], edx
  01844	eb 16		 jmp	 SHORT $LN20@Railgun_to
  01846	eb 08 8d a4 24
	00 00 00 00 90	 npad	 10
$LL44@Railgun_to:
  01850	8b 4c 24 0c	 mov	 ecx, DWORD PTR tv547[esp+1064]
  01854	8b 54 24 10	 mov	 edx, DWORD PTR tv550[esp+1064]
  01858	8b 74 24 18	 mov	 esi, DWORD PTR _pbPattern$GSCopy$[esp+1064]
$LN20@Railgun_to:

; 3757 : 
; 3758 :     for ( ;; )
; 3759 :     {
; 3760 :         // The line below gives for 'cbPattern'>=1:
; 3761 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/543
; 3762 :         // Karp_Rabin_Kaze_4_OCTETS performance: 372KB/clock
; 3763 : /*
; 3764 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 3765 :             return((long)(pbTarget-cbPattern));
; 3766 : */
; 3767 : 
; 3768 :         // The fragment below gives for 'cbPattern'>=2:
; 3769 :         // Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/546
; 3770 :         // Karp_Rabin_Kaze_4_OCTETS performance: 370KB/clock
; 3771 : 
; 3772 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {

  0185c	0f be 44 1a ff	 movsx	 eax, BYTE PTR [edx+ebx-1]
  01861	0f be 53 ff	 movsx	 edx, BYTE PTR [ebx-1]
  01865	c1 e0 08	 shl	 eax, 8
  01868	03 c2		 add	 eax, edx
  0186a	3b f8		 cmp	 edi, eax
  0186c	75 29		 jne	 SHORT $LN15@Railgun_to

; 3773 :          count = countSTATIC;

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

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

  01872	85 c0		 test	 eax, eax
  01874	74 1b		 je	 SHORT $LN38@Railgun_to

; 3773 :          count = countSTATIC;

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

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

  01880	8a 16		 mov	 dl, BYTE PTR [esi]
  01882	3a 11		 cmp	 dl, BYTE PTR [ecx]
  01884	75 07		 jne	 SHORT $LN16@Railgun_to

; 3775 :                count--;

  01886	41		 inc	 ecx
  01887	46		 inc	 esi
  01888	48		 dec	 eax
  01889	75 f5		 jne	 SHORT $LL17@Railgun_to

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

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

; 3778 :         }
; 3779 : 
; 3780 :         // The fragment below gives for 'cbPattern'>=2:
; 3781 : 	// Karp_Rabin_Kaze_4_OCTETS_hits/Karp_Rabin_Kaze_4_OCTETS_clocks: 4/554
; 3782 : 	// Karp_Rabin_Kaze_4_OCTETS performance: 364KB/clock
; 3783 : /*
; 3784 :         if ( ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1) ) {
; 3785 :          count = countSTATIC>>2;
; 3786 :          countRemainder = countSTATIC % 4;
; 3787 : 
; 3788 :          while ( count && *(unsigned long *)(pbPattern+1+((count-1)<<2)) == *(unsigned long *)(pbTarget-cbPattern+1+((count-1)<<2)) ) {
; 3789 :                count--;
; 3790 :          }
; 3791 : 	 //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.
; 3792 :          while ( countRemainder && *(char *)(pbPattern+1+(countSTATIC-countRemainder)) == *(char *)(pbTarget-cbPattern+1+(countSTATIC-countRemainder)) ) {
; 3793 :                countRemainder--;
; 3794 :          }
; 3795 :          //if ( countRemainder == 0) return((long)(pbTarget-cbPattern));
; 3796 :          if ( count+countRemainder == 0) return((long)(pbTarget-cbPattern));
; 3797 :          //}
; 3798 :         }
; 3799 : */
; 3800 : 
; 3801 :         pbTarget++;

  01897	43		 inc	 ebx

; 3802 :         if (pbTarget > pbTargetMax)

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

; 3830 :     }
; 3831 :     return(NULL);

  0189e	33 c0		 xor	 eax, eax

; 3832 : }
; 3833 : }

  018a0	5f		 pop	 edi
  018a1	5e		 pop	 esi
  018a2	5b		 pop	 ebx
  018a3	8b 8c 24 18 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1052]
  018aa	33 cc		 xor	 ecx, esp
  018ac	e8 00 00 00 00	 call	 @__security_check_cookie@4
  018b1	8b e5		 mov	 esp, ebp
  018b3	5d		 pop	 ebp
  018b4	c3		 ret	 0
$LN21@Railgun_to:

; 3803 :             return(NULL);
; 3804 :     }
; 3805 : }
; 3806 : else
; 3807 : {
; 3808 :     /* Preprocessing */
; 3809 :     for (a=0; a < ASIZE; a++) bm_bc[a]=cbPattern;

  018b5	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  018ba	8d 7c 24 20	 lea	 edi, DWORD PTR _bm_bc$[esp+1064]
  018be	f3 ab		 rep stosd

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

  018c0	8d 70 ff	 lea	 esi, DWORD PTR [eax-1]
  018c3	33 c9		 xor	 ecx, ecx
  018c5	85 f6		 test	 esi, esi
  018c7	74 18		 je	 SHORT $LN7@Railgun_to
  018c9	8d 78 ff	 lea	 edi, DWORD PTR [eax-1]
$LN9@Railgun_to:
  018cc	8b 74 24 18	 mov	 esi, DWORD PTR _pbPattern$GSCopy$[esp+1064]
  018d0	0f be 34 0e	 movsx	 esi, BYTE PTR [esi+ecx]
  018d4	89 7c b4 20	 mov	 DWORD PTR _bm_bc$[esp+esi*4+1064], edi
  018d8	41		 inc	 ecx
  018d9	8d 70 ff	 lea	 esi, DWORD PTR [eax-1]
  018dc	4f		 dec	 edi
  018dd	3b ce		 cmp	 ecx, esi
  018df	72 eb		 jb	 SHORT $LN9@Railgun_to
$LN7@Railgun_to:

; 3811 : 
; 3812 :     /* Searching */
; 3813 :     //lastch=pbPattern[cbPattern-1];
; 3814 :     //firstch=pbPattern[0];
; 3815 :     i=0;

  018e1	33 ff		 xor	 edi, edi

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

  018e3	2b d0		 sub	 edx, eax
  018e5	8d 4c 03 ff	 lea	 ecx, DWORD PTR [ebx+eax-1]
  018e9	89 54 24 0c	 mov	 DWORD PTR $T7416[esp+1064], edx
  018ed	89 4c 24 14	 mov	 DWORD PTR tv415[esp+1064], ecx
$LN6@Railgun_to:

; 3817 :        ch=pbTarget[i+cbPattern-1];
; 3818 :        //if (ch ==lastch)
; 3819 :           //if (memcmp(&pbTarget[i],pbPattern,cbPattern-1) == 0) OUTPUT(i);
; 3820 :           //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".
; 3821 :           if (ch == pbPattern[cbPattern-1] && pbTarget[i] == pbPattern[0])

  018f1	8b 54 24 14	 mov	 edx, DWORD PTR tv415[esp+1064]
  018f5	0f b6 0c 3a	 movzx	 ecx, BYTE PTR [edx+edi]
  018f9	8b 74 24 18	 mov	 esi, DWORD PTR _pbPattern$GSCopy$[esp+1064]
  018fd	0f be 54 06 ff	 movsx	 edx, BYTE PTR [esi+eax-1]
  01902	89 4c 24 10	 mov	 DWORD PTR tv357[esp+1064], ecx
  01906	3b ca		 cmp	 ecx, edx
  01908	75 3e		 jne	 SHORT $LN1@Railgun_to
  0190a	8a 0c 1f	 mov	 cl, BYTE PTR [edi+ebx]
  0190d	3a 0e		 cmp	 cl, BYTE PTR [esi]
  0190f	75 37		 jne	 SHORT $LN1@Railgun_to

; 3822 :              {
; 3823 :          count = countSTATIC;

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

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

  01915	85 c9		 test	 ecx, ecx
  01917	74 24		 je	 SHORT $LN37@Railgun_to

; 3822 :              {
; 3823 :          count = countSTATIC;

  01919	46		 inc	 esi
  0191a	8d 54 1f 01	 lea	 edx, DWORD PTR [edi+ebx+1]
  0191e	8b ff		 npad	 2
$LL3@Railgun_to:

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

  01920	8a 1e		 mov	 bl, BYTE PTR [esi]
  01922	3a 1a		 cmp	 bl, BYTE PTR [edx]
  01924	75 10		 jne	 SHORT $LN2@Railgun_to

; 3825 :                count--;

  01926	42		 inc	 edx
  01927	46		 inc	 esi
  01928	49		 dec	 ecx
  01929	75 f5		 jne	 SHORT $LL3@Railgun_to

; 3826 :          }
; 3827 :          if ( count == 0) Railgunhits++; //return(pbTarget+i);

  0192b	8b 5d 08	 mov	 ebx, DWORD PTR _pbTarget$[ebp]
  0192e	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits
  01934	eb 12		 jmp	 SHORT $LN1@Railgun_to
$LN2@Railgun_to:
  01936	85 c9		 test	 ecx, ecx
  01938	75 0b		 jne	 SHORT $LN39@Railgun_to
  0193a	8b 5d 08	 mov	 ebx, DWORD PTR _pbTarget$[ebp]
$LN37@Railgun_to:
  0193d	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits
  01943	eb 03		 jmp	 SHORT $LN1@Railgun_to
$LN39@Railgun_to:
  01945	8b 5d 08	 mov	 ebx, DWORD PTR _pbTarget$[ebp]
$LN1@Railgun_to:

; 3828 : 	     }
; 3829 :        i+=bm_bc[ch];

  01948	8b 54 24 10	 mov	 edx, DWORD PTR tv357[esp+1064]
  0194c	03 7c 94 20	 add	 edi, DWORD PTR _bm_bc$[esp+edx*4+1064]
  01950	3b 7c 24 0c	 cmp	 edi, DWORD PTR $T7416[esp+1064]
  01954	76 9b		 jbe	 SHORT $LN6@Railgun_to
$LN47@Railgun_to:

; 3832 : }
; 3833 : }

  01956	8b 8c 24 24 04
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+1064]
  0195d	5f		 pop	 edi
  0195e	5e		 pop	 esi
  0195f	5b		 pop	 ebx
  01960	33 cc		 xor	 ecx, esp
  01962	33 c0		 xor	 eax, eax
  01964	e8 00 00 00 00	 call	 @__security_check_cookie@4
  01969	8b e5		 mov	 esp, ebp
  0196b	5d		 pop	 ebp
  0196c	c3		 ret	 0
_Railgun_totalhits ENDP
_TEXT	ENDS
PUBLIC	_maxSuf
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_x$ = 8							; size = 4
_m$ = 12						; size = 4
_p$ = 16						; size = 4
_maxSuf	PROC

; 3842 :    int ms, j, k;
; 3843 :    char a, b;
; 3844 : 
; 3845 :    ms = -1;
; 3846 :    j = 0;
; 3847 :    k = *p = 1;

  01970	8b 54 24 0c	 mov	 edx, DWORD PTR _p$[esp-4]
  01974	b9 01 00 00 00	 mov	 ecx, 1
  01979	56		 push	 esi
  0197a	83 c8 ff	 or	 eax, -1
  0197d	33 f6		 xor	 esi, esi
  0197f	89 0a		 mov	 DWORD PTR [edx], ecx

; 3848 :    while (j + k < m) {

  01981	39 4c 24 0c	 cmp	 DWORD PTR _m$[esp], ecx
  01985	7e 58		 jle	 SHORT $LN7@maxSuf
  01987	53		 push	 ebx
  01988	55		 push	 ebp
  01989	8b 6c 24 10	 mov	 ebp, DWORD PTR _x$[esp+8]
  0198d	57		 push	 edi
  0198e	8b ff		 npad	 2
$LL8@maxSuf:

; 3849 :       a = x[j + k];

  01990	8d 3c 31	 lea	 edi, DWORD PTR [ecx+esi]
  01993	8a 14 2f	 mov	 dl, BYTE PTR [edi+ebp]

; 3850 :       b = x[ms + k];

  01996	8d 1c 01	 lea	 ebx, DWORD PTR [ecx+eax]
  01999	8a 1c 2b	 mov	 bl, BYTE PTR [ebx+ebp]

; 3851 :       if (a < b) {

  0199c	3a d3		 cmp	 dl, bl
  0199e	7d 0e		 jge	 SHORT $LN13@maxSuf

; 3852 :          j += k;

  019a0	8b f7		 mov	 esi, edi

; 3853 :          k = 1;
; 3854 :          *p = j - ms;

  019a2	8b 7c 24 1c	 mov	 edi, DWORD PTR _p$[esp+12]
  019a6	8b d6		 mov	 edx, esi
  019a8	2b d0		 sub	 edx, eax
  019aa	89 17		 mov	 DWORD PTR [edi], edx

; 3855 :       }
; 3856 :       else

  019ac	eb 20		 jmp	 SHORT $LN14@maxSuf
$LN13@maxSuf:

; 3857 :          if (a == b)

  019ae	75 11		 jne	 SHORT $LN4@maxSuf

; 3858 :             if (k != *p)

  019b0	8b 54 24 1c	 mov	 edx, DWORD PTR _p$[esp+12]
  019b4	8b 12		 mov	 edx, DWORD PTR [edx]
  019b6	3b ca		 cmp	 ecx, edx
  019b8	74 03		 je	 SHORT $LN3@maxSuf

; 3859 :                ++k;

  019ba	41		 inc	 ecx

; 3860 :             else {

  019bb	eb 16		 jmp	 SHORT $LN1@maxSuf
$LN3@maxSuf:

; 3861 :                j += *p;

  019bd	03 f2		 add	 esi, edx

; 3862 :                k = 1;
; 3863 :             }
; 3864 :          else { /* a > b */

  019bf	eb 0d		 jmp	 SHORT $LN14@maxSuf
$LN4@maxSuf:

; 3865 :             ms = j;
; 3866 :             j = ms + 1;
; 3867 :             k = *p = 1;

  019c1	8b 4c 24 1c	 mov	 ecx, DWORD PTR _p$[esp+12]
  019c5	8b c6		 mov	 eax, esi
  019c7	46		 inc	 esi
  019c8	c7 01 01 00 00
	00		 mov	 DWORD PTR [ecx], 1
$LN14@maxSuf:
  019ce	b9 01 00 00 00	 mov	 ecx, 1
$LN1@maxSuf:

; 3848 :    while (j + k < m) {

  019d3	8d 14 31	 lea	 edx, DWORD PTR [ecx+esi]
  019d6	3b 54 24 18	 cmp	 edx, DWORD PTR _m$[esp+12]
  019da	7c b4		 jl	 SHORT $LL8@maxSuf
  019dc	5f		 pop	 edi
  019dd	5d		 pop	 ebp
  019de	5b		 pop	 ebx
$LN7@maxSuf:
  019df	5e		 pop	 esi

; 3868 :          }
; 3869 :    }
; 3870 :    return(ms);
; 3871 : }

  019e0	c3		 ret	 0
_maxSuf	ENDP
_TEXT	ENDS
PUBLIC	_maxSufTilde
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_x$ = 8							; size = 4
_m$ = 12						; size = 4
_p$ = 16						; size = 4
_maxSufTilde PROC

; 3875 :    int ms, j, k;
; 3876 :    char a, b;
; 3877 : 
; 3878 :    ms = -1;
; 3879 :    j = 0;
; 3880 :    k = *p = 1;

  019f0	8b 54 24 0c	 mov	 edx, DWORD PTR _p$[esp-4]
  019f4	b9 01 00 00 00	 mov	 ecx, 1
  019f9	56		 push	 esi
  019fa	83 c8 ff	 or	 eax, -1
  019fd	33 f6		 xor	 esi, esi
  019ff	89 0a		 mov	 DWORD PTR [edx], ecx

; 3881 :    while (j + k < m) {

  01a01	39 4c 24 0c	 cmp	 DWORD PTR _m$[esp], ecx
  01a05	7e 58		 jle	 SHORT $LN7@maxSufTild
  01a07	53		 push	 ebx
  01a08	55		 push	 ebp
  01a09	8b 6c 24 10	 mov	 ebp, DWORD PTR _x$[esp+8]
  01a0d	57		 push	 edi
  01a0e	8b ff		 npad	 2
$LL8@maxSufTild:

; 3882 :       a = x[j + k];

  01a10	8d 3c 31	 lea	 edi, DWORD PTR [ecx+esi]
  01a13	8a 14 2f	 mov	 dl, BYTE PTR [edi+ebp]

; 3883 :       b = x[ms + k];

  01a16	8d 1c 01	 lea	 ebx, DWORD PTR [ecx+eax]
  01a19	8a 1c 2b	 mov	 bl, BYTE PTR [ebx+ebp]

; 3884 :       if (a > b) {

  01a1c	3a d3		 cmp	 dl, bl
  01a1e	7e 0e		 jle	 SHORT $LN13@maxSufTild

; 3885 :          j += k;

  01a20	8b f7		 mov	 esi, edi

; 3886 :          k = 1;
; 3887 :          *p = j - ms;

  01a22	8b 7c 24 1c	 mov	 edi, DWORD PTR _p$[esp+12]
  01a26	8b d6		 mov	 edx, esi
  01a28	2b d0		 sub	 edx, eax
  01a2a	89 17		 mov	 DWORD PTR [edi], edx

; 3888 :       }
; 3889 :       else

  01a2c	eb 20		 jmp	 SHORT $LN14@maxSufTild
$LN13@maxSufTild:

; 3890 :          if (a == b)

  01a2e	75 11		 jne	 SHORT $LN4@maxSufTild

; 3891 :             if (k != *p)

  01a30	8b 54 24 1c	 mov	 edx, DWORD PTR _p$[esp+12]
  01a34	8b 12		 mov	 edx, DWORD PTR [edx]
  01a36	3b ca		 cmp	 ecx, edx
  01a38	74 03		 je	 SHORT $LN3@maxSufTild

; 3892 :                ++k;

  01a3a	41		 inc	 ecx

; 3893 :             else {

  01a3b	eb 16		 jmp	 SHORT $LN1@maxSufTild
$LN3@maxSufTild:

; 3894 :                j += *p;

  01a3d	03 f2		 add	 esi, edx

; 3895 :                k = 1;
; 3896 :             }
; 3897 :          else { /* a < b */

  01a3f	eb 0d		 jmp	 SHORT $LN14@maxSufTild
$LN4@maxSufTild:

; 3898 :             ms = j;
; 3899 :             j = ms + 1;
; 3900 :             k = *p = 1;

  01a41	8b 4c 24 1c	 mov	 ecx, DWORD PTR _p$[esp+12]
  01a45	8b c6		 mov	 eax, esi
  01a47	46		 inc	 esi
  01a48	c7 01 01 00 00
	00		 mov	 DWORD PTR [ecx], 1
$LN14@maxSufTild:
  01a4e	b9 01 00 00 00	 mov	 ecx, 1
$LN1@maxSufTild:

; 3881 :    while (j + k < m) {

  01a53	8d 14 31	 lea	 edx, DWORD PTR [ecx+esi]
  01a56	3b 54 24 18	 cmp	 edx, DWORD PTR _m$[esp+12]
  01a5a	7c b4		 jl	 SHORT $LL8@maxSufTild
  01a5c	5f		 pop	 edi
  01a5d	5d		 pop	 ebp
  01a5e	5b		 pop	 ebx
$LN7@maxSufTild:
  01a5f	5e		 pop	 esi

; 3901 :          }
; 3902 :    }
; 3903 :    return(ms);
; 3904 : }

  01a60	c3		 ret	 0
_maxSufTilde ENDP
_TEXT	ENDS
PUBLIC	_TW
; Function compile flags: /Ogtpy
_TEXT	SEGMENT
_ell$ = -12						; size = 4
_per$ = -8						; size = 4
_q$ = -8						; size = 4
tv295 = -4						; size = 4
_p$ = -4						; size = 4
_y$ = 8							; size = 4
_n$ = 12						; size = 4
_x$ = 16						; size = 4
_m$ = 20						; size = 4
_TW	PROC

; 3908 : char * TW(char *y,  int n, char *x, int m) {

  01a70	83 ec 0c	 sub	 esp, 12			; 0000000cH
  01a73	53		 push	 ebx
  01a74	55		 push	 ebp

; 3909 :    int i, j, ell, memory, p, per, q;
; 3910 : 
; 3911 :    /* Preprocessing */
; 3912 :    i = maxSuf(x, m, &p);

  01a75	8b 6c 24 24	 mov	 ebp, DWORD PTR _m$[esp+16]
  01a79	56		 push	 esi
  01a7a	57		 push	 edi
  01a7b	8b 7c 24 28	 mov	 edi, DWORD PTR _x$[esp+24]
  01a7f	8d 44 24 18	 lea	 eax, DWORD PTR _p$[esp+28]
  01a83	50		 push	 eax
  01a84	55		 push	 ebp
  01a85	57		 push	 edi
  01a86	e8 00 00 00 00	 call	 _maxSuf

; 3913 :    j = maxSufTilde(x, m, &q);

  01a8b	8d 4c 24 20	 lea	 ecx, DWORD PTR _q$[esp+40]
  01a8f	51		 push	 ecx
  01a90	55		 push	 ebp
  01a91	57		 push	 edi
  01a92	8b f0		 mov	 esi, eax
  01a94	e8 00 00 00 00	 call	 _maxSufTilde
  01a99	83 c4 18	 add	 esp, 24			; 00000018H

; 3914 :    if (i > j) {

  01a9c	3b f0		 cmp	 esi, eax
  01a9e	7e 0c		 jle	 SHORT $LN22@TW

; 3915 :       ell = i;
; 3916 :       per = p;

  01aa0	8b 4c 24 18	 mov	 ecx, DWORD PTR _p$[esp+28]
  01aa4	8b de		 mov	 ebx, esi
  01aa6	89 5c 24 10	 mov	 DWORD PTR _ell$[esp+28], ebx

; 3917 :    }
; 3918 :    else {

  01aaa	eb 0a		 jmp	 SHORT $LN61@TW
$LN22@TW:

; 3919 :       ell = j;
; 3920 :       per = q;

  01aac	8b 4c 24 14	 mov	 ecx, DWORD PTR _q$[esp+28]
  01ab0	8b d8		 mov	 ebx, eax
  01ab2	89 44 24 10	 mov	 DWORD PTR _ell$[esp+28], eax
$LN61@TW:

; 3921 :    }
; 3922 : 
; 3923 :    /* Searching */
; 3924 :    if (memcmp(x, x + per, ell + 1) == 0) {

  01ab6	8b 74 24 28	 mov	 esi, DWORD PTR _x$[esp+24]
  01aba	8d 7b 01	 lea	 edi, DWORD PTR [ebx+1]
  01abd	89 4c 24 14	 mov	 DWORD PTR _per$[esp+28], ecx
  01ac1	8b c7		 mov	 eax, edi
  01ac3	03 ce		 add	 ecx, esi
  01ac5	83 f8 04	 cmp	 eax, 4
  01ac8	72 1a		 jb	 SHORT $LN41@TW
  01aca	8d 9b 00 00 00
	00		 npad	 6
$LL30@TW:
  01ad0	8b 16		 mov	 edx, DWORD PTR [esi]
  01ad2	3b 11		 cmp	 edx, DWORD PTR [ecx]
  01ad4	75 42		 jne	 SHORT $LN20@TW
  01ad6	83 e8 04	 sub	 eax, 4
  01ad9	83 c1 04	 add	 ecx, 4
  01adc	83 c6 04	 add	 esi, 4
  01adf	83 f8 04	 cmp	 eax, 4
  01ae2	73 ec		 jae	 SHORT $LL30@TW
$LN41@TW:
  01ae4	85 c0		 test	 eax, eax
  01ae6	0f 84 db 00 00
	00		 je	 $LN54@TW
  01aec	8a 11		 mov	 dl, BYTE PTR [ecx]
  01aee	3a 16		 cmp	 dl, BYTE PTR [esi]
  01af0	75 26		 jne	 SHORT $LN20@TW
  01af2	83 f8 01	 cmp	 eax, 1
  01af5	0f 86 cc 00 00
	00		 jbe	 $LN54@TW
  01afb	8a 51 01	 mov	 dl, BYTE PTR [ecx+1]
  01afe	3a 56 01	 cmp	 dl, BYTE PTR [esi+1]
  01b01	75 15		 jne	 SHORT $LN20@TW
  01b03	83 f8 02	 cmp	 eax, 2
  01b06	0f 86 bb 00 00
	00		 jbe	 $LN54@TW
  01b0c	8a 41 02	 mov	 al, BYTE PTR [ecx+2]
  01b0f	3a 46 02	 cmp	 al, BYTE PTR [esi+2]
  01b12	0f 84 af 00 00
	00		 je	 $LN54@TW
$LN20@TW:

; 3943 :          }
; 3944 :       }
; 3945 :    }
; 3946 :    else {
; 3947 :       per = MAX(ell + 1, m - ell - 1) + 1;

  01b18	8b c5		 mov	 eax, ebp
  01b1a	2b c3		 sub	 eax, ebx
  01b1c	48		 dec	 eax
  01b1d	3b f8		 cmp	 edi, eax
  01b1f	7e 02		 jle	 SHORT $LN27@TW
  01b21	8b c7		 mov	 eax, edi
$LN27@TW:
  01b23	40		 inc	 eax
  01b24	89 44 24 14	 mov	 DWORD PTR _per$[esp+28], eax

; 3948 :       j = 0;
; 3949 :       while (j <= n - m) {

  01b28	8b 44 24 24	 mov	 eax, DWORD PTR _n$[esp+24]
  01b2c	33 f6		 xor	 esi, esi
  01b2e	2b c5		 sub	 eax, ebp
  01b30	89 44 24 18	 mov	 DWORD PTR tv295[esp+28], eax
  01b34	0f 88 11 01 00
	00		 js	 $LN18@TW
  01b3a	8b 54 24 20	 mov	 edx, DWORD PTR _y$[esp+24]
  01b3e	8b ff		 npad	 2
$LL9@TW:

; 3950 :          i = ell + 1;

  01b40	8b c7		 mov	 eax, edi

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

  01b42	3b c5		 cmp	 eax, ebp
  01b44	7d 25		 jge	 SHORT $LN50@TW
  01b46	8d 0c 16	 lea	 ecx, DWORD PTR [esi+edx]
  01b49	8d a4 24 00 00
	00 00		 npad	 7
$LL7@TW:
  01b50	8b 5c 24 28	 mov	 ebx, DWORD PTR _x$[esp+24]
  01b54	8a 1c 18	 mov	 bl, BYTE PTR [eax+ebx]
  01b57	3a 1c 01	 cmp	 bl, BYTE PTR [ecx+eax]
  01b5a	75 07		 jne	 SHORT $LN6@TW

; 3952 :             ++i;

  01b5c	40		 inc	 eax
  01b5d	3b c5		 cmp	 eax, ebp
  01b5f	7c ef		 jl	 SHORT $LL7@TW

; 3953 :          if (i >= m) {

  01b61	eb 04		 jmp	 SHORT $LN62@TW
$LN6@TW:
  01b63	3b c5		 cmp	 eax, ebp
  01b65	7c 4a		 jl	 SHORT $LN5@TW
$LN62@TW:
  01b67	8b 5c 24 10	 mov	 ebx, DWORD PTR _ell$[esp+28]
$LN50@TW:

; 3954 :             i = ell;

  01b6b	8b c3		 mov	 eax, ebx

; 3955 :             while (i >= 0 && x[i] == y[i + j])

  01b6d	85 db		 test	 ebx, ebx
  01b6f	78 2a		 js	 SHORT $LN49@TW
  01b71	8d 0c 16	 lea	 ecx, DWORD PTR [esi+edx]
$LL4@TW:
  01b74	8b 5c 24 28	 mov	 ebx, DWORD PTR _x$[esp+24]
  01b78	8a 1c 18	 mov	 bl, BYTE PTR [eax+ebx]
  01b7b	3a 1c 01	 cmp	 bl, BYTE PTR [ecx+eax]
  01b7e	75 13		 jne	 SHORT $LN3@TW

; 3956 :                --i;

  01b80	48		 dec	 eax

; 3955 :             while (i >= 0 && x[i] == y[i + j])

  01b81	79 f1		 jns	 SHORT $LL4@TW

; 3957 :             if (i < 0) Railgunhits++; //return (y+j);

  01b83	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits
  01b89	8b 5c 24 10	 mov	 ebx, DWORD PTR _ell$[esp+28]

; 3958 :                //OUTPUT(j);
; 3959 :             j += per;

  01b8d	03 74 24 14	 add	 esi, DWORD PTR _per$[esp+28]

; 3960 :          }
; 3961 :          else

  01b91	eb 26		 jmp	 SHORT $LN1@TW
$LN3@TW:

; 3957 :             if (i < 0) Railgunhits++; //return (y+j);

  01b93	85 c0		 test	 eax, eax
  01b95	79 10		 jns	 SHORT $LN53@TW
  01b97	8b 5c 24 10	 mov	 ebx, DWORD PTR _ell$[esp+28]
$LN49@TW:
  01b9b	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits

; 3958 :                //OUTPUT(j);
; 3959 :             j += per;

  01ba1	03 74 24 14	 add	 esi, DWORD PTR _per$[esp+28]

; 3960 :          }
; 3961 :          else

  01ba5	eb 12		 jmp	 SHORT $LN1@TW
$LN53@TW:

; 3957 :             if (i < 0) Railgunhits++; //return (y+j);

  01ba7	8b 5c 24 10	 mov	 ebx, DWORD PTR _ell$[esp+28]

; 3958 :                //OUTPUT(j);
; 3959 :             j += per;

  01bab	03 74 24 14	 add	 esi, DWORD PTR _per$[esp+28]

; 3960 :          }
; 3961 :          else

  01baf	eb 08		 jmp	 SHORT $LN1@TW
$LN5@TW:

; 3962 :             j += (i - ell);

  01bb1	8b 5c 24 10	 mov	 ebx, DWORD PTR _ell$[esp+28]
  01bb5	2b c3		 sub	 eax, ebx
  01bb7	03 f0		 add	 esi, eax
$LN1@TW:

; 3948 :       j = 0;
; 3949 :       while (j <= n - m) {

  01bb9	3b 74 24 18	 cmp	 esi, DWORD PTR tv295[esp+28]
  01bbd	7e 81		 jle	 SHORT $LL9@TW
  01bbf	5f		 pop	 edi
  01bc0	5e		 pop	 esi
  01bc1	5d		 pop	 ebp
  01bc2	5b		 pop	 ebx

; 3963 :       }
; 3964 :    }
; 3965 : }

  01bc3	83 c4 0c	 add	 esp, 12			; 0000000cH
  01bc6	c3		 ret	 0
$LN54@TW:

; 3925 :       j = 0;
; 3926 :       memory = -1;
; 3927 :       while (j <= n - m) {

  01bc7	8b 44 24 24	 mov	 eax, DWORD PTR _n$[esp+24]
  01bcb	33 ff		 xor	 edi, edi
  01bcd	83 c9 ff	 or	 ecx, -1
  01bd0	2b c5		 sub	 eax, ebp
  01bd2	89 44 24 18	 mov	 DWORD PTR tv295[esp+28], eax
  01bd6	78 73		 js	 SHORT $LN18@TW
$LL19@TW:

; 3928 :          i = MAX(ell, memory) + 1;

  01bd8	8b c3		 mov	 eax, ebx
  01bda	3b d9		 cmp	 ebx, ecx
  01bdc	7f 02		 jg	 SHORT $LN26@TW
  01bde	8b c1		 mov	 eax, ecx
$LN26@TW:
  01be0	40		 inc	 eax

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

  01be1	3b c5		 cmp	 eax, ebp
  01be3	7d 22		 jge	 SHORT $LN48@TW
  01be5	8b 54 24 20	 mov	 edx, DWORD PTR _y$[esp+24]
  01be9	8d 34 17	 lea	 esi, DWORD PTR [edi+edx]
  01bec	8d 64 24 00	 npad	 4
$LL17@TW:
  01bf0	8b 54 24 28	 mov	 edx, DWORD PTR _x$[esp+24]
  01bf4	8a 14 10	 mov	 dl, BYTE PTR [eax+edx]
  01bf7	3a 14 06	 cmp	 dl, BYTE PTR [esi+eax]
  01bfa	75 07		 jne	 SHORT $LN16@TW

; 3930 :             ++i;

  01bfc	40		 inc	 eax
  01bfd	3b c5		 cmp	 eax, ebp
  01bff	7c ef		 jl	 SHORT $LL17@TW

; 3931 :          if (i >= m) {

  01c01	eb 04		 jmp	 SHORT $LN48@TW
$LN16@TW:
  01c03	3b c5		 cmp	 eax, ebp
  01c05	7c 37		 jl	 SHORT $LN15@TW
$LN48@TW:

; 3932 :             i = ell;

  01c07	8b c3		 mov	 eax, ebx

; 3933 :             while (i > memory && x[i] == y[i + j])

  01c09	3b d9		 cmp	 ebx, ecx
  01c0b	7e 1e		 jle	 SHORT $LN47@TW
  01c0d	8b 54 24 20	 mov	 edx, DWORD PTR _y$[esp+24]
  01c11	8d 34 17	 lea	 esi, DWORD PTR [edi+edx]
$LL14@TW:
  01c14	8b 54 24 28	 mov	 edx, DWORD PTR _x$[esp+24]
  01c18	8a 14 10	 mov	 dl, BYTE PTR [eax+edx]
  01c1b	3a 14 06	 cmp	 dl, BYTE PTR [esi+eax]
  01c1e	75 07		 jne	 SHORT $LN13@TW

; 3934 :                --i;

  01c20	48		 dec	 eax
  01c21	3b c1		 cmp	 eax, ecx
  01c23	7f ef		 jg	 SHORT $LL14@TW

; 3935 :             if (i <= memory) Railgunhits++; //return (y+j);

  01c25	eb 04		 jmp	 SHORT $LN47@TW
$LN13@TW:
  01c27	3b c1		 cmp	 eax, ecx
  01c29	7f 06		 jg	 SHORT $LN59@TW
$LN47@TW:
  01c2b	ff 05 00 00 00
	00		 inc	 DWORD PTR _Railgunhits
$LN59@TW:

; 3936 :                //OUTPUT(j);
; 3937 :             j += per;

  01c31	8b 44 24 14	 mov	 eax, DWORD PTR _per$[esp+28]

; 3938 :             memory = m - per - 1;

  01c35	8b cd		 mov	 ecx, ebp
  01c37	2b c8		 sub	 ecx, eax
  01c39	03 f8		 add	 edi, eax
  01c3b	49		 dec	 ecx

; 3939 :          }
; 3940 :          else {

  01c3c	eb 07		 jmp	 SHORT $LN11@TW
$LN15@TW:

; 3941 :             j += (i - ell);

  01c3e	2b c3		 sub	 eax, ebx
  01c40	03 f8		 add	 edi, eax

; 3942 :             memory = -1;

  01c42	83 c9 ff	 or	 ecx, -1
$LN11@TW:

; 3925 :       j = 0;
; 3926 :       memory = -1;
; 3927 :       while (j <= n - m) {

  01c45	3b 7c 24 18	 cmp	 edi, DWORD PTR tv295[esp+28]
  01c49	7e 8d		 jle	 SHORT $LL19@TW
$LN18@TW:
  01c4b	5f		 pop	 edi
  01c4c	5e		 pop	 esi
  01c4d	5d		 pop	 ebp
  01c4e	5b		 pop	 ebx

; 3963 :       }
; 3964 :    }
; 3965 : }

  01c4f	83 c4 0c	 add	 esp, 12			; 0000000cH
  01c52	c3		 ret	 0
_TW	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

; 3977 :     char *  pbTargetMax = pbTarget + cbTarget;

  01c60	8b 4c 24 0c	 mov	 ecx, DWORD PTR _cbTarget$[esp-4]
  01c64	8b 44 24 04	 mov	 eax, DWORD PTR _pbTarget$[esp-4]
  01c68	57		 push	 edi

; 3978 :     register unsigned long  ulHashPattern;
; 3979 :     unsigned long  ulHashTarget;
; 3980 : 
; 3981 :     if (cbPattern > cbTarget)

  01c69	8b 7c 24 14	 mov	 edi, DWORD PTR _cbPattern$[esp]
  01c6d	8d 14 08	 lea	 edx, DWORD PTR [eax+ecx]
  01c70	89 54 24 10	 mov	 DWORD PTR _pbTargetMax$[esp], edx
  01c74	3b f9		 cmp	 edi, ecx
  01c76	76 04		 jbe	 SHORT $LN5@KarpRabinK@2

; 3982 :         return(NULL);

  01c78	33 c0		 xor	 eax, eax
  01c7a	5f		 pop	 edi

; 3999 :     }
; 4000 : }

  01c7b	c3		 ret	 0
$LN5@KarpRabinK@2:
  01c7c	55		 push	 ebp
  01c7d	56		 push	 esi

; 3983 : 
; 3984 :         pbTarget = pbTarget+cbPattern;
; 3985 :         ulHashPattern = ( (*(char *)(pbPattern))<<8 ) + *(pbPattern+(cbPattern-1));

  01c7e	8b 74 24 14	 mov	 esi, DWORD PTR _pbPattern$[esp+8]
  01c82	0f be 16	 movsx	 edx, BYTE PTR [esi]
  01c85	0f be 4c 3e ff	 movsx	 ecx, BYTE PTR [esi+edi-1]
  01c8a	03 c7		 add	 eax, edi
  01c8c	c1 e2 08	 shl	 edx, 8
  01c8f	03 ca		 add	 ecx, edx
  01c91	8b e8		 mov	 ebp, eax
  01c93	89 4c 24 10	 mov	 DWORD PTR _ulHashPattern$[esp+8], ecx
  01c97	2b ef		 sub	 ebp, edi
  01c99	53		 push	 ebx
  01c9a	8d 9b 00 00 00
	00		 npad	 6
$LL4@KarpRabinK@2:

; 3986 : 
; 3987 :     for ( ;; )
; 3988 :     {
; 3989 :         // 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'.
; 3990 :         // The line below gives: 314KB/clock
; 3991 :         //if ( *pbPattern == *(char *)(pbTarget-cbPattern) && (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )
; 3992 :         // The line below gives: 370KB/clock
; 3993 :         if ( (ulHashPattern == ( (*(char *)(pbTarget-cbPattern))<<8 ) + *(pbTarget-1)) && !memcmp(pbPattern, pbTarget-cbPattern, (unsigned int)cbPattern) )

  01ca0	0f be 5d 00	 movsx	 ebx, BYTE PTR [ebp]
  01ca4	0f be 54 2f ff	 movsx	 edx, BYTE PTR [edi+ebp-1]
  01ca9	c1 e3 08	 shl	 ebx, 8
  01cac	03 d3		 add	 edx, ebx
  01cae	3b ca		 cmp	 ecx, edx
  01cb0	75 4e		 jne	 SHORT $LN20@KarpRabinK@2
  01cb2	8b cf		 mov	 ecx, edi
  01cb4	8b d5		 mov	 edx, ebp
  01cb6	83 ff 04	 cmp	 edi, 4
  01cb9	72 19		 jb	 SHORT $LN16@KarpRabinK@2
  01cbb	eb 03 8d 49 00	 npad	 5
$LL9@KarpRabinK@2:
  01cc0	8b 1e		 mov	 ebx, DWORD PTR [esi]
  01cc2	3b 1a		 cmp	 ebx, DWORD PTR [edx]
  01cc4	75 32		 jne	 SHORT $LN19@KarpRabinK@2
  01cc6	83 e9 04	 sub	 ecx, 4
  01cc9	83 c2 04	 add	 edx, 4
  01ccc	83 c6 04	 add	 esi, 4
  01ccf	83 f9 04	 cmp	 ecx, 4
  01cd2	73 ec		 jae	 SHORT $LL9@KarpRabinK@2
$LN16@KarpRabinK@2:
  01cd4	85 c9		 test	 ecx, ecx
  01cd6	74 37		 je	 SHORT $LN11@KarpRabinK@2
  01cd8	8a 1a		 mov	 bl, BYTE PTR [edx]
  01cda	3a 1e		 cmp	 bl, BYTE PTR [esi]
  01cdc	75 1a		 jne	 SHORT $LN19@KarpRabinK@2
  01cde	83 f9 01	 cmp	 ecx, 1
  01ce1	76 2c		 jbe	 SHORT $LN11@KarpRabinK@2
  01ce3	8a 5a 01	 mov	 bl, BYTE PTR [edx+1]
  01ce6	3a 5e 01	 cmp	 bl, BYTE PTR [esi+1]
  01ce9	75 0d		 jne	 SHORT $LN19@KarpRabinK@2
  01ceb	83 f9 02	 cmp	 ecx, 2
  01cee	76 1f		 jbe	 SHORT $LN11@KarpRabinK@2
  01cf0	8a 4a 02	 mov	 cl, BYTE PTR [edx+2]
  01cf3	3a 4e 02	 cmp	 cl, BYTE PTR [esi+2]
  01cf6	74 17		 je	 SHORT $LN11@KarpRabinK@2
$LN19@KarpRabinK@2:
  01cf8	8b 74 24 18	 mov	 esi, DWORD PTR _pbPattern$[esp+12]
  01cfc	8b 4c 24 14	 mov	 ecx, DWORD PTR _ulHashPattern$[esp+12]
$LN20@KarpRabinK@2:

; 3995 : 
; 3996 :         pbTarget++;

  01d00	40		 inc	 eax
  01d01	45		 inc	 ebp

; 3997 :         if (pbTarget > pbTargetMax)

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

; 3998 :             return(NULL);

  01d08	5b		 pop	 ebx
  01d09	5e		 pop	 esi
  01d0a	5d		 pop	 ebp
  01d0b	33 c0		 xor	 eax, eax
  01d0d	5f		 pop	 edi

; 3999 :     }
; 4000 : }

  01d0e	c3		 ret	 0
$LN11@KarpRabinK@2:
  01d0f	5b		 pop	 ebx
  01d10	5e		 pop	 esi
  01d11	5d		 pop	 ebp

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

  01d12	2b c7		 sub	 eax, edi
  01d14	5f		 pop	 edi

; 3999 :     }
; 4000 : }

  01d15	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

; 4007 : {

  01d20	56		 push	 esi

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

  01d21	8b 74 24 08	 mov	 esi, DWORD PTR _str1$[esp]
  01d25	57		 push	 edi

; 4009 :         char *s1, *s2;
; 4010 : 
; 4011 :         if ( !*str2 )

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

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

  01d2f	74 3d		 je	 SHORT $LN7@strstr_Mic

; 4013 : 
; 4014 :         while (*cp)

  01d31	8a 16		 mov	 dl, BYTE PTR [esi]
  01d33	53		 push	 ebx
  01d34	84 d2		 test	 dl, dl
  01d36	74 33		 je	 SHORT $LN4@strstr_Mic
  01d38	2b f7		 sub	 esi, edi
  01d3a	8d 9b 00 00 00
	00		 npad	 6
$LL5@strstr_Mic:

; 4015 :         {
; 4016 :                 s1 = cp;
; 4017 :                 s2 = (char *) str2;

  01d40	8b cf		 mov	 ecx, edi

; 4018 : 
; 4019 :                 while ( *s1 && *s2 && !(*s1-*s2) )

  01d42	84 d2		 test	 dl, dl
  01d44	74 17		 je	 SHORT $LN2@strstr_Mic
$LL3@strstr_Mic:
  01d46	8a 11		 mov	 dl, BYTE PTR [ecx]
  01d48	84 d2		 test	 dl, dl
  01d4a	74 21		 je	 SHORT $LN14@strstr_Mic
  01d4c	0f be 1c 0e	 movsx	 ebx, BYTE PTR [esi+ecx]
  01d50	0f be d2	 movsx	 edx, dl
  01d53	2b da		 sub	 ebx, edx
  01d55	75 06		 jne	 SHORT $LN2@strstr_Mic

; 4020 :                         s1++, s2++;

  01d57	41		 inc	 ecx
  01d58	38 1c 0e	 cmp	 BYTE PTR [esi+ecx], bl
  01d5b	75 e9		 jne	 SHORT $LL3@strstr_Mic
$LN2@strstr_Mic:

; 4021 : 
; 4022 :                 if (!*s2)

  01d5d	80 39 00	 cmp	 BYTE PTR [ecx], 0
  01d60	74 0b		 je	 SHORT $LN14@strstr_Mic

; 4023 :                         return(cp);
; 4024 : 
; 4025 :                 cp++;

  01d62	8a 50 01	 mov	 dl, BYTE PTR [eax+1]
  01d65	40		 inc	 eax
  01d66	46		 inc	 esi
  01d67	84 d2		 test	 dl, dl
  01d69	75 d5		 jne	 SHORT $LL5@strstr_Mic
$LN4@strstr_Mic:

; 4026 :         }
; 4027 :         return(NULL);

  01d6b	33 c0		 xor	 eax, eax
$LN14@strstr_Mic:
  01d6d	5b		 pop	 ebx
$LN7@strstr_Mic:
  01d6e	5f		 pop	 edi
  01d6f	5e		 pop	 esi

; 4028 : }

  01d70	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$6115 = 12						; size = 1
_pneedle$ = 12						; size = 4
_strstr_GNU_C_Library PROC

; 4035 :   const unsigned char *haystack, *needle;
; 4036 :   char b;
; 4037 :   const unsigned char *rneedle;
; 4038 : 
; 4039 :   haystack = (const unsigned char *) phaystack;

  01d80	8b 44 24 04	 mov	 eax, DWORD PTR _phaystack$[esp-4]
  01d84	53		 push	 ebx
  01d85	55		 push	 ebp
  01d86	56		 push	 esi

; 4040 : 
; 4041 :   if ((b = *(needle = (const unsigned char *) pneedle)))

  01d87	8b 74 24 14	 mov	 esi, DWORD PTR _pneedle$[esp+8]
  01d8b	8a 16		 mov	 dl, BYTE PTR [esi]
  01d8d	57		 push	 edi
  01d8e	88 54 24 14	 mov	 BYTE PTR _b$[esp+12], dl
  01d92	84 d2		 test	 dl, dl
  01d94	0f 84 a8 00 00
	00		 je	 $foundneedle$6123

; 4042 :     {
; 4043 :       char c;
; 4044 :       haystack--;		/* possible ANSI violation */

  01d9a	48		 dec	 eax
  01d9b	eb 03 8d 49 00	 npad	 5
$LL27@strstr_GNU:

; 4045 : 
; 4046 :       {
; 4047 : 	char a;
; 4048 : 	do
; 4049 : 	  if (!(a = *++haystack))

  01da0	8a 48 01	 mov	 cl, BYTE PTR [eax+1]
  01da3	40		 inc	 eax
  01da4	84 c9		 test	 cl, cl
  01da6	0f 84 94 00 00
	00		 je	 $ret0$6121

; 4050 : 	    goto ret0;
; 4051 : 	while (a != b);

  01dac	3a ca		 cmp	 cl, dl
  01dae	75 f0		 jne	 SHORT $LL27@strstr_GNU

; 4052 :       }
; 4053 : 
; 4054 :       if (!(c = *++needle))

  01db0	8a 5e 01	 mov	 bl, BYTE PTR [esi+1]
  01db3	88 5c 24 18	 mov	 BYTE PTR _c$6115[esp+12], bl
  01db7	84 db		 test	 bl, bl
  01db9	0f 84 83 00 00
	00		 je	 $foundneedle$6123

; 4055 : 	goto foundneedle;
; 4056 :       ++needle;
; 4057 :       goto jin;
; 4058 : 
; 4059 :       for (;;)
; 4060 : 	{
; 4061 : 	  {
; 4062 : 	    char a;
; 4063 : 	    if (0)
; 4064 : 	    jin:{
; 4065 : 		if ((a = *++haystack) == c)

  01dbf	8a 48 01	 mov	 cl, BYTE PTR [eax+1]
  01dc2	40		 inc	 eax
  01dc3	83 c6 02	 add	 esi, 2
$jin$6124:
  01dc6	3a cb		 cmp	 cl, bl
  01dc8	74 26		 je	 SHORT $crest$6131
$LN17@strstr_GNU:

; 4070 : 	    do
; 4071 : 	      {
; 4072 : 		for (; a != b; a = *++haystack)

  01dca	3a ca		 cmp	 cl, dl
  01dcc	74 1a		 je	 SHORT $LN16@strstr_GNU
  01dce	8b ff		 npad	 2
$LL14@strstr_GNU:

; 4073 : 		  {
; 4074 : 		    if (!a)

  01dd0	84 c9		 test	 cl, cl
  01dd2	74 6c		 je	 SHORT $ret0$6121

; 4075 : 		      goto ret0;
; 4076 : 		    if ((a = *++haystack) == b)

  01dd4	8a 48 01	 mov	 cl, BYTE PTR [eax+1]
  01dd7	40		 inc	 eax
  01dd8	3a ca		 cmp	 cl, dl
  01dda	74 0c		 je	 SHORT $LN16@strstr_GNU

; 4077 : 		      break;
; 4078 : 		    if (!a)

  01ddc	84 c9		 test	 cl, cl
  01dde	74 60		 je	 SHORT $ret0$6121

; 4070 : 	    do
; 4071 : 	      {
; 4072 : 		for (; a != b; a = *++haystack)

  01de0	8a 48 01	 mov	 cl, BYTE PTR [eax+1]
  01de3	40		 inc	 eax
  01de4	3a ca		 cmp	 cl, dl
  01de6	75 e8		 jne	 SHORT $LL14@strstr_GNU
$LN16@strstr_GNU:

; 4079 : 		      goto ret0;
; 4080 : 		  }
; 4081 : 	      }
; 4082 : 	    while ((a = *++haystack) != c);

  01de8	8a 48 01	 mov	 cl, BYTE PTR [eax+1]
  01deb	40		 inc	 eax
  01dec	3a cb		 cmp	 cl, bl
  01dee	75 da		 jne	 SHORT $LN17@strstr_GNU
$crest$6131:

; 4083 : 	  }
; 4084 : 	crest:
; 4085 : 	  {
; 4086 : 	    char a;
; 4087 : 	    {
; 4088 : 	      const unsigned char *rhaystack;
; 4089 : 	      if (*(rhaystack = haystack-- + 1) == (a = *(rneedle = needle)))

  01df0	8a 0e		 mov	 cl, BYTE PTR [esi]
  01df2	0f b6 58 01	 movzx	 ebx, BYTE PTR [eax+1]
  01df6	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
  01df9	0f be e9	 movsx	 ebp, cl
  01dfc	48		 dec	 eax
  01dfd	8b fe		 mov	 edi, esi
  01dff	3b dd		 cmp	 ebx, ebp
  01e01	75 29		 jne	 SHORT $LN5@strstr_GNU
$LL7@strstr_GNU:

; 4090 : 		do
; 4091 : 		  {
; 4092 : 		    if (!a)

  01e03	84 c9		 test	 cl, cl
  01e05	74 3b		 je	 SHORT $foundneedle$6123

; 4093 : 		      goto foundneedle;
; 4094 : 		    if (*++rhaystack != (a = *++needle))

  01e07	8a 4e 01	 mov	 cl, BYTE PTR [esi+1]
  01e0a	0f b6 5a 01	 movzx	 ebx, BYTE PTR [edx+1]
  01e0e	42		 inc	 edx
  01e0f	0f be e9	 movsx	 ebp, cl
  01e12	3b dd		 cmp	 ebx, ebp
  01e14	75 16		 jne	 SHORT $LN5@strstr_GNU

; 4095 : 		      break;
; 4096 : 		    if (!a)

  01e16	84 c9		 test	 cl, cl
  01e18	74 28		 je	 SHORT $foundneedle$6123

; 4097 : 		      goto foundneedle;
; 4098 : 		  }
; 4099 : 		while (*++rhaystack == (a = *++needle));

  01e1a	8a 4e 02	 mov	 cl, BYTE PTR [esi+2]
  01e1d	0f b6 5a 01	 movzx	 ebx, BYTE PTR [edx+1]
  01e21	83 c6 02	 add	 esi, 2
  01e24	42		 inc	 edx
  01e25	0f be e9	 movsx	 ebp, cl
  01e28	3b dd		 cmp	 ebx, ebp
  01e2a	74 d7		 je	 SHORT $LL7@strstr_GNU
$LN5@strstr_GNU:

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

  01e2c	8b f7		 mov	 esi, edi

; 4101 : 	    }
; 4102 : 	    if (!a)

  01e2e	84 c9		 test	 cl, cl
  01e30	74 10		 je	 SHORT $foundneedle$6123

; 4066 : 		  goto crest;
; 4067 : 	      }
; 4068 : 	    else
; 4069 : 	      a = *++haystack;

  01e32	8a 48 01	 mov	 cl, BYTE PTR [eax+1]
  01e35	8a 54 24 14	 mov	 dl, BYTE PTR _b$[esp+12]
  01e39	8a 5c 24 18	 mov	 bl, BYTE PTR _c$6115[esp+12]
  01e3d	40		 inc	 eax
  01e3e	eb 8a		 jmp	 SHORT $LN17@strstr_GNU
$ret0$6121:

; 4103 : 	      break;
; 4104 : 	  }
; 4105 : 	}
; 4106 :     }
; 4107 : foundneedle:
; 4108 :   return (char *) haystack;
; 4109 : ret0:
; 4110 :   return 0;

  01e40	33 c0		 xor	 eax, eax
$foundneedle$6123:
  01e42	5f		 pop	 edi
  01e43	5e		 pop	 esi
  01e44	5d		 pop	 ebp
  01e45	5b		 pop	 ebx

; 4111 : }

  01e46	c3		 ret	 0
_strstr_GNU_C_Library 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

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

  01e50	8b 44 24 08	 mov	 eax, DWORD PTR _val$[esp]
  01e54	83 ec 08	 sub	 esp, 8
  01e57	83 7c 24 1c 00	 cmp	 DWORD PTR _is_neg$[esp+4], 0
  01e5c	55		 push	 ebp
  01e5d	56		 push	 esi
  01e5e	8b 74 24 1c	 mov	 esi, DWORD PTR _buf$[esp+12]
  01e62	57		 push	 edi
  01e63	8b 7c 24 18	 mov	 edi, DWORD PTR _val$[esp+16]
  01e67	74 0b		 je	 SHORT $LN9@x64toaKAZE

; 4121 :         char *p;                /* pointer to traverse string */
; 4122 :         char *firstdig;         /* pointer to first digit */
; 4123 :         char temp;              /* temp char */
; 4124 :         unsigned digval;        /* value of digit */
; 4125 : 
; 4126 :         p = buf;
; 4127 : 
; 4128 :         if ( is_neg )
; 4129 :         {
; 4130 :             *p++ = '-';         /* negative, so output '-' and negate */

  01e69	c6 06 2d	 mov	 BYTE PTR [esi], 45	; 0000002dH
  01e6c	46		 inc	 esi

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

  01e6d	f7 df		 neg	 edi
  01e6f	83 d0 00	 adc	 eax, 0
  01e72	f7 d8		 neg	 eax
$LN9@x64toaKAZE:

; 4132 :         }
; 4133 : 
; 4134 :         firstdig = p;           /* save pointer to first digit */

  01e74	8b ee		 mov	 ebp, esi

; 4145 :         } while (val > 0);

  01e76	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR tv164[esp+20], 0
  01e7e	53		 push	 ebx
  01e7f	90		 npad	 1
$LL8@x64toaKAZE:

; 4135 : 
; 4136 :         do {
; 4137 :             digval = (unsigned) (val % radix);

  01e80	8b 4c 24 20	 mov	 ecx, DWORD PTR tv164[esp+24]
  01e84	51		 push	 ecx
  01e85	8b 4c 24 2c	 mov	 ecx, DWORD PTR _radix$[esp+24]
  01e89	51		 push	 ecx
  01e8a	50		 push	 eax
  01e8b	57		 push	 edi
  01e8c	e8 00 00 00 00	 call	 __aulldvrm
  01e91	8b f8		 mov	 edi, eax
  01e93	89 5c 24 14	 mov	 DWORD PTR tv65[esp+28], ebx
  01e97	8b c2		 mov	 eax, edx

; 4138 :             val /= radix;       /* get next digit */
; 4139 : 
; 4140 :             /* convert to ascii and store */
; 4141 :             if (digval > 9)

  01e99	83 f9 09	 cmp	 ecx, 9
  01e9c	76 05		 jbe	 SHORT $LN5@x64toaKAZE

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

  01e9e	80 c1 57	 add	 cl, 87			; 00000057H

; 4143 :             else

  01ea1	eb 03		 jmp	 SHORT $LN17@x64toaKAZE
$LN5@x64toaKAZE:

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

  01ea3	80 c1 30	 add	 cl, 48			; 00000030H
$LN17@x64toaKAZE:
  01ea6	88 0e		 mov	 BYTE PTR [esi], cl
  01ea8	46		 inc	 esi

; 4145 :         } while (val > 0);

  01ea9	85 c0		 test	 eax, eax
  01eab	77 d3		 ja	 SHORT $LL8@x64toaKAZE
  01ead	72 04		 jb	 SHORT $LN14@x64toaKAZE
  01eaf	85 ff		 test	 edi, edi
  01eb1	75 cd		 jne	 SHORT $LL8@x64toaKAZE
$LN14@x64toaKAZE:

; 4146 : 
; 4147 :         /* We now have the digit of the number in the buffer, but in reverse
; 4148 :            order.  Thus we reverse them now. */
; 4149 : 
; 4150 :         *p-- = '\0';            /* terminate string; p points to last digit */

  01eb3	c6 06 00	 mov	 BYTE PTR [esi], 0
  01eb6	4e		 dec	 esi
  01eb7	5b		 pop	 ebx
$LL3@x64toaKAZE:

; 4151 : 
; 4152 :         do {
; 4153 :             temp = *p;
; 4154 :             *p = *firstdig;

  01eb8	8a 55 00	 mov	 dl, BYTE PTR [ebp]
  01ebb	8a 06		 mov	 al, BYTE PTR [esi]
  01ebd	88 16		 mov	 BYTE PTR [esi], dl

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

  01ebf	88 45 00	 mov	 BYTE PTR [ebp], al

; 4156 :             --p;

  01ec2	4e		 dec	 esi

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

  01ec3	45		 inc	 ebp

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

  01ec4	3b ee		 cmp	 ebp, esi
  01ec6	72 f0		 jb	 SHORT $LL3@x64toaKAZE
  01ec8	5f		 pop	 edi
  01ec9	5e		 pop	 esi
  01eca	5d		 pop	 ebp

; 4159 : }

  01ecb	83 c4 08	 add	 esp, 8
  01ece	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

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

  01ed0	8b 4c 24 10	 mov	 ecx, DWORD PTR _radix$[esp-4]
  01ed4	8b 54 24 08	 mov	 edx, DWORD PTR _val$[esp]
  01ed8	56		 push	 esi
  01ed9	57		 push	 edi
  01eda	8b 7c 24 0c	 mov	 edi, DWORD PTR _val$[esp+4]
  01ede	83 f9 0a	 cmp	 ecx, 10			; 0000000aH
  01ee1	75 11		 jne	 SHORT $LN3@i64toaKAZE
  01ee3	85 d2		 test	 edx, edx
  01ee5	7f 0d		 jg	 SHORT $LN3@i64toaKAZE
  01ee7	7c 04		 jl	 SHORT $LN5@i64toaKAZE
  01ee9	85 ff		 test	 edi, edi
  01eeb	73 07		 jae	 SHORT $LN3@i64toaKAZE
$LN5@i64toaKAZE:
  01eed	b8 01 00 00 00	 mov	 eax, 1
  01ef2	eb 02		 jmp	 SHORT $LN4@i64toaKAZE
$LN3@i64toaKAZE:
  01ef4	33 c0		 xor	 eax, eax
$LN4@i64toaKAZE:
  01ef6	8b 74 24 14	 mov	 esi, DWORD PTR _buf$[esp+4]
  01efa	50		 push	 eax
  01efb	51		 push	 ecx
  01efc	56		 push	 esi
  01efd	52		 push	 edx
  01efe	57		 push	 edi
  01eff	e8 00 00 00 00	 call	 _x64toaKAZE
  01f04	83 c4 14	 add	 esp, 20			; 00000014H
  01f07	5f		 pop	 edi

; 4171 :         return buf;

  01f08	8b c6		 mov	 eax, esi
  01f0a	5e		 pop	 esi

; 4172 : }

  01f0b	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

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

  01f10	8b 44 24 10	 mov	 eax, DWORD PTR _radix$[esp-4]
  01f14	8b 4c 24 08	 mov	 ecx, DWORD PTR _val$[esp]
  01f18	8b 54 24 04	 mov	 edx, DWORD PTR _val$[esp-4]
  01f1c	56		 push	 esi
  01f1d	8b 74 24 10	 mov	 esi, DWORD PTR _buf$[esp]
  01f21	6a 00		 push	 0
  01f23	50		 push	 eax
  01f24	56		 push	 esi
  01f25	51		 push	 ecx
  01f26	52		 push	 edx
  01f27	e8 00 00 00 00	 call	 _x64toaKAZE
  01f2c	83 c4 14	 add	 esp, 20			; 00000014H

; 4181 :         return buf;

  01f2f	8b c6		 mov	 eax, esi
  01f31	5e		 pop	 esi

; 4182 : }

  01f32	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

; 4190 :                         char *p;
; 4191 :                         char temp;
; 4192 :                         int txpman;
; 4193 :                         int pxnman;
; 4194 :         x64toaKAZE(val, buf, radix, 0);

  01f40	8b 44 24 10	 mov	 eax, DWORD PTR _radix$[esp-4]
  01f44	8b 4c 24 08	 mov	 ecx, DWORD PTR _val$[esp]
  01f48	8b 54 24 04	 mov	 edx, DWORD PTR _val$[esp-4]
  01f4c	53		 push	 ebx
  01f4d	55		 push	 ebp
  01f4e	8b 6c 24 14	 mov	 ebp, DWORD PTR _buf$[esp+4]
  01f52	56		 push	 esi
  01f53	57		 push	 edi
  01f54	6a 00		 push	 0
  01f56	50		 push	 eax
  01f57	55		 push	 ebp
  01f58	51		 push	 ecx
  01f59	52		 push	 edx
  01f5a	e8 00 00 00 00	 call	 _x64toaKAZE
  01f5f	83 c4 14	 add	 esp, 20			; 00000014H

; 4195 :                         p = buf;

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

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

  01f64	47		 inc	 edi
  01f65	80 3f 00	 cmp	 BYTE PTR [edi], 0
  01f68	75 fa		 jne	 SHORT $LL10@ui64toaKAZ

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

  01f6a	4f		 dec	 edi

; 4199 :                              // buf points to first digit
; 4200 :                         buf[26] = 0;

  01f6b	c6 45 1a 00	 mov	 BYTE PTR [ebp+26], 0

; 4201 :                         txpman = 1;

  01f6f	bb 01 00 00 00	 mov	 ebx, 1

; 4202 :                         pxnman = 0;

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

; 4203 :                         do
; 4204 :                         { if (buf <= p)
; 4205 :                           { temp = *p;
; 4206 :                             buf[26-txpman] = temp; pxnman++;

  01f80	41		 inc	 ecx
  01f81	3b ef		 cmp	 ebp, edi
  01f83	77 07		 ja	 SHORT $LN4@ui64toaKAZ
  01f85	8a 07		 mov	 al, BYTE PTR [edi]
  01f87	88 06		 mov	 BYTE PTR [esi], al

; 4207 :                             p--;

  01f89	4f		 dec	 edi

; 4208 :                             if (pxnman % 3 == 0)
; 4209 :                             { txpman++;
; 4210 :                               buf[26-txpman] = (char) (',');
; 4211 :                             }
; 4212 :                           }
; 4213 :                           else

  01f8a	eb 03		 jmp	 SHORT $LN18@ui64toaKAZ
$LN4@ui64toaKAZ:

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

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

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

  01f8f	b8 56 55 55 55	 mov	 eax, 1431655766		; 55555556H
  01f94	f7 e9		 imul	 ecx
  01f96	8b c2		 mov	 eax, edx
  01f98	c1 e8 1f	 shr	 eax, 31			; 0000001fH
  01f9b	03 c2		 add	 eax, edx
  01f9d	8d 14 40	 lea	 edx, DWORD PTR [eax+eax*2]
  01fa0	8b c1		 mov	 eax, ecx
  01fa2	2b c2		 sub	 eax, edx
  01fa4	75 05		 jne	 SHORT $LN16@ui64toaKAZ

; 4216 :                             { txpman++;

  01fa6	43		 inc	 ebx
  01fa7	4e		 dec	 esi

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

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

; 4218 :                             }
; 4219 :                           }
; 4220 :                           txpman++;

  01fab	43		 inc	 ebx
  01fac	4e		 dec	 esi

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

  01fad	83 fb 1a	 cmp	 ebx, 26			; 0000001aH
  01fb0	7e ce		 jle	 SHORT $LL7@ui64toaKAZ

; 4222 :         return buf;

  01fb2	5f		 pop	 edi
  01fb3	5e		 pop	 esi
  01fb4	8b c5		 mov	 eax, ebp
  01fb6	5d		 pop	 ebp
  01fb7	5b		 pop	 ebx

; 4223 : }

  01fb8	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

; 4231 :                         char *p;
; 4232 :                         char temp;
; 4233 :                         int txpman;
; 4234 :                         int pxnman;
; 4235 :         x64toaKAZE(val, buf, radix, 0);

  01fc0	8b 44 24 10	 mov	 eax, DWORD PTR _radix$[esp-4]
  01fc4	8b 4c 24 08	 mov	 ecx, DWORD PTR _val$[esp]
  01fc8	8b 54 24 04	 mov	 edx, DWORD PTR _val$[esp-4]
  01fcc	53		 push	 ebx
  01fcd	8b 5c 24 10	 mov	 ebx, DWORD PTR _buf$[esp]
  01fd1	55		 push	 ebp
  01fd2	57		 push	 edi
  01fd3	6a 00		 push	 0
  01fd5	50		 push	 eax
  01fd6	53		 push	 ebx
  01fd7	51		 push	 ecx
  01fd8	52		 push	 edx
  01fd9	e8 00 00 00 00	 call	 _x64toaKAZE
  01fde	83 c4 14	 add	 esp, 20			; 00000014H

; 4236 :                         p = buf;

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

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

  01fe3	41		 inc	 ecx
  01fe4	80 39 00	 cmp	 BYTE PTR [ecx], 0
  01fe7	75 fa		 jne	 SHORT $LL6@ui64toaKAZ@2

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

  01fe9	49		 dec	 ecx

; 4240 :                              // buf points to first digit
; 4241 :                         buf[26] = 0;
; 4242 :                         txpman = 1;
; 4243 :                         pxnman = 0;

  01fea	33 ff		 xor	 edi, edi
  01fec	c6 43 1a 00	 mov	 BYTE PTR [ebx+26], 0
  01ff0	bd 01 00 00 00	 mov	 ebp, 1

; 4244 :                         while (buf <= p)

  01ff5	3b d9		 cmp	 ebx, ecx
  01ff7	77 34		 ja	 SHORT $LN2@ui64toaKAZ@2

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

  01ff9	56		 push	 esi
  01ffa	8d 73 19	 lea	 esi, DWORD PTR [ebx+25]
  01ffd	8d 49 00	 npad	 3
$LL3@ui64toaKAZ@2:

; 4245 :                         { temp = *p;
; 4246 :                           buf[26-txpman] = temp; pxnman++;

  02000	8a 01		 mov	 al, BYTE PTR [ecx]
  02002	88 06		 mov	 BYTE PTR [esi], al
  02004	47		 inc	 edi

; 4247 :                           p--;
; 4248 :                           if (pxnman % 3 == 0 && buf <= p)

  02005	b8 56 55 55 55	 mov	 eax, 1431655766		; 55555556H
  0200a	f7 ef		 imul	 edi
  0200c	8b c2		 mov	 eax, edx
  0200e	c1 e8 1f	 shr	 eax, 31			; 0000001fH
  02011	03 c2		 add	 eax, edx
  02013	8d 14 40	 lea	 edx, DWORD PTR [eax+eax*2]
  02016	8b c7		 mov	 eax, edi
  02018	49		 dec	 ecx
  02019	2b c2		 sub	 eax, edx
  0201b	75 09		 jne	 SHORT $LN13@ui64toaKAZ@2
  0201d	3b d9		 cmp	 ebx, ecx
  0201f	77 05		 ja	 SHORT $LN13@ui64toaKAZ@2

; 4249 :                           { txpman++;

  02021	45		 inc	 ebp
  02022	4e		 dec	 esi

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

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

; 4251 :                           }
; 4252 :                           txpman++;

  02026	45		 inc	 ebp
  02027	4e		 dec	 esi
  02028	3b cb		 cmp	 ecx, ebx
  0202a	73 d4		 jae	 SHORT $LL3@ui64toaKAZ@2
  0202c	5e		 pop	 esi
$LN2@ui64toaKAZ@2:

; 4253 :                         } 
; 4254 :         return buf+26-(txpman-1);

  0202d	8b c3		 mov	 eax, ebx
  0202f	5f		 pop	 edi
  02030	2b c5		 sub	 eax, ebp
  02032	5d		 pop	 ebp
  02033	83 c0 1b	 add	 eax, 27			; 0000001bH
  02036	5b		 pop	 ebx

; 4255 : }

  02037	c3		 ret	 0
__ui64toaKAZEcomma ENDP
_TEXT	ENDS
PUBLIC	__real@3ff0000000000000
PUBLIC	__$ArrayPad$
PUBLIC	_main
EXTRN	_clock:PROC
EXTRN	_gets:PROC
EXTRN	_fread:PROC
EXTRN	_ftell:PROC
EXTRN	_fseek:PROC
EXTRN	_fopen:PROC
EXTRN	_puts:PROC
EXTRN	_malloc:PROC
EXTRN	_printf:PROC
EXTRN	__fltused:DWORD
EXTRN	__chkstk:PROC
EXTRN	__ftol2:PROC
EXTRN	__aulldiv:PROC
EXTRN	__ftol2_sse:PROC
;	COMDAT __real@3ff0000000000000
CONST	SEGMENT
__real@3ff0000000000000 DQ 03ff0000000000000r	; 1
; Function compile flags: /Ogtpy
CONST	ENDS
_TEXT	SEGMENT
_AdvanceHopperGrass$7691 = -4496			; size = 4
_AdvanceHopperGrass$7626 = -4496			; size = 4
_AdvanceHopperGrass$7561 = -4496			; size = 4
_StrnglenTRAVERSED$ = -4496				; size = 4
tv8817 = -4492						; size = 4
tv8293 = -4492						; size = 4
tv8231 = -4492						; size = 4
tv8210 = -4492						; size = 4
tv8135 = -4492						; size = 4
tv8096 = -4492						; size = 4
tv8082 = -4492						; size = 4
tv8061 = -4492						; size = 4
tv7976 = -4492						; size = 4
tv7956 = -4492						; size = 4
tv7867 = -4492						; size = 4
tv7847 = -4492						; size = 4
tv7777 = -4492						; size = 4
tv7753 = -4492						; size = 4
tv7741 = -4492						; size = 4
tv7678 = -4492						; size = 4
tv7652 = -4492						; size = 4
tv7639 = -4492						; size = 4
tv7590 = -4492						; size = 4
tv7566 = -4492						; size = 4
tv7554 = -4492						; size = 4
tv7512 = -4492						; size = 4
tv7491 = -4492						; size = 4
tv7469 = -4492						; size = 4
tv7437 = -4492						; size = 4
tv7405 = -4492						; size = 4
tv7383 = -4492						; size = 4
tv7361 = -4492						; size = 4
tv7338 = -4492						; size = 4
tv7316 = -4492						; size = 4
tv7295 = -4492						; size = 4
tv7274 = -4492						; size = 4
tv7240 = -4492						; size = 4
tv7218 = -4492						; size = 4
tv7196 = -4492						; size = 4
tv7161 = -4492						; size = 4
tv7129 = -4492						; size = 4
tv6978 = -4492						; size = 4
tv6246 = -4492						; size = 4
tv6209 = -4492						; size = 4
tv4833 = -4492						; size = 4
tv4808 = -4492						; size = 4
tv4692 = -4492						; size = 4
tv4667 = -4492						; size = 4
tv4517 = -4492						; size = 4
$T8337 = -4492						; size = 4
_Quadruplet3rd$7983 = -4492				; size = 4
_Quadruplet3rd$7919 = -4492				; size = 4
_Quadruplet3rd$7831 = -4492				; size = 4
_countSTATIC$7764 = -4492				; size = 4
_Quadruplet3rd$7767 = -4492				; size = 4
_Quadruplet4th$7560 = -4492				; size = 4
_Bozan$ = -4488						; size = 4
_LinesEncountered$ = -4484				; size = 4
tv4799 = -4480						; size = 4
tv4658 = -4480						; size = 4
tv4508 = -4480						; size = 4
_ThunderwithR$ = -4480					; size = 4
tv4941 = -4476						; size = 4
_i$ = -4476						; size = 4
_Strng$ = -4472						; size = 4
tv4483 = -4468						; size = 4
_Patternlen$ = -4468					; size = 4
tv6163 = -4464						; size = 4
_ThunderwithL$ = -4464					; size = 4
tv8370 = -4460						; size = 4
tv8351 = -4460						; size = 4
tv4485 = -4460						; size = 4
$T8334 = -4460						; size = 4
tv3008 = -4460						; size = 4
tv2572 = -4460						; size = 4
$T7883 = -4460						; size = 4
$T7819 = -4460						; size = 4
$T7741 = -4460						; size = 4
$T7676 = -4460						; size = 4
_ulHashPattern$7553 = -4460				; size = 4
tv4934 = -4456						; size = 8
_ReallyTraversed$ = -4456				; size = 8
tv7809 = -4448						; size = 4
tv5464 = -4448						; size = 4
tv5358 = -4448						; size = 4
tv4904 = -4448						; size = 4
$T8328 = -4448						; size = 4
$T8330 = -4448						; size = 4
$T8336 = -4448						; size = 4
_Quadruplet2nd$7982 = -4448				; size = 4
_Quadruplet2nd$7918 = -4448				; size = 4
_Quadruplet2nd$7830 = -4448				; size = 4
_Quadruplet2nd$7766 = -4448				; size = 4
_Quadruplet3rd$7689 = -4448				; size = 4
_Quadruplet3rd$7624 = -4448				; size = 4
_Quadruplet2nd$7558 = -4448				; size = 4
tv8528 = -4444						; size = 4
tv6979 = -4444						; size = 4
tv6977 = -4444						; size = 4
tv5188 = -4444						; size = 4
tv4763 = -4444						; size = 4
tv4614 = -4444						; size = 4
$T8332 = -4444						; size = 4
_Quadruplet4th$7984 = -4444				; size = 4
_Quadruplet4th$7920 = -4444				; size = 4
_Quadruplet4th$7832 = -4444				; size = 4
_Quadruplet4th$7768 = -4444				; size = 4
_Quadruplet2nd$7688 = -4444				; size = 4
_Quadruplet2nd$7623 = -4444				; size = 4
_Quadruplet3rd$7559 = -4444				; size = 4
_Strnglen$ = -4440					; size = 4
tv6297 = -4436						; size = 4
tv4989 = -4436						; size = 4
_Karp_Rabin_Kaze_4_OCTETShits$ = -4436			; size = 4
_pbTargetMax$7824 = -4432				; size = 4
_pbTargetMax$7760 = -4432				; size = 4
_ulHashPattern$7683 = -4432				; size = 4
_ulHashPattern$7618 = -4432				; size = 4
$T7611 = -4432						; size = 4
_Karp_Rabin_Kaze_4_OCTETShits_DOUBLET$ = -4428		; size = 4
$T8035 = -4424						; size = 4
$T7971 = -4424						; size = 4
_HORSPOOL_Kazehits$ = -4424				; size = 4
tv6172 = -4420						; size = 4
tv5078 = -4420						; size = 4
$T8339 = -4420						; size = 4
$T8341 = -4420						; size = 4
_Quadruplet4th$7690 = -4420				; size = 4
_Quadruplet4th$7625 = -4420				; size = 4
_pbTargetMax$7976 = -4416				; size = 4
_pbTargetMax$7912 = -4416				; size = 4
_BruteForceDummyhits$ = -4416				; size = 4
_strstrGNUCLibraryhits$ = -4412				; size = 4
_j$ = -4408						; size = 4
_HORSPOOLhits$ = -4408					; size = 4
_strstrMicrosofthits$ = -4404				; size = 4
_KarpRabinKaze_BOOSTEDhits$ = -4400			; size = 4
_Railgun_Quadruplet_6pp_GO$ = -4396			; size = 4
_KarpRabinhits$ = -4392					; size = 4
_KarpRabinKazehits$ = -4388				; size = 4
_DumboBox$ = -4384					; size = 64
_Dumbino$ = -4320					; size = 208
_bm_bc$7925 = -4112					; size = 1024
_bm_bc$7837 = -4112					; size = 1024
_bm_bc$7773 = -4112					; size = 1024
_bm_bc$7695 = -4112					; size = 1024
_bm_bc$7630 = -4112					; size = 1024
_bm_bc$7989 = -3088					; size = 1024
_bm_bc$7565 = -3088					; size = 1024
_llTOaDigits$ = -2060					; size = 27
_Pattern$ = -2032					; size = 2020
__$ArrayPad$ = -4					; size = 4
_argc$ = 8						; size = 4
_argv$ = 12						; size = 4
_main	PROC

; 4258 :   {

  02040	55		 push	 ebp
  02041	8b ec		 mov	 ebp, esp
  02043	83 e4 f8	 and	 esp, -8			; fffffff8H
  02046	b8 94 11 00 00	 mov	 eax, 4500		; 00001194H
  0204b	e8 00 00 00 00	 call	 __chkstk
  02050	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  02055	33 c4		 xor	 eax, esp
  02057	89 84 24 90 11
	00 00		 mov	 DWORD PTR __$ArrayPad$[esp+4500], eax
  0205e	53		 push	 ebx
  0205f	56		 push	 esi

; 4259 : FILE *fp_inLINE;
; 4260 : int Bozan;
; 4261 : long ThunderwithL, ThunderwithR;
; 4262 : char *Strng;
; 4263 : long Strnglen;
; 4264 : long StrnglenTRAVERSED;
; 4265 : char Pattern[20+2000]; // skillessness=12 human consciousness=19 I should have known=19
; 4266 : // In the East, enlightenment is described as a state of ultimate=62
; 4267 : int Patternlen;      
; 4268 : long LinesEncountered=0;

  02060	33 f6		 xor	 esi, esi
  02062	57		 push	 edi
  02063	89 74 24 1c	 mov	 DWORD PTR _LinesEncountered$[esp+4512], esi

; 4269 : long BruteForceDummyhits=0;

  02067	89 74 24 60	 mov	 DWORD PTR _BruteForceDummyhits$[esp+4512], esi

; 4270 : long KarpRabinKazehits=0;

  0206b	89 74 24 7c	 mov	 DWORD PTR _KarpRabinKazehits$[esp+4512], esi

; 4271 : long KarpRabinKaze_BOOSTEDhits=0;

  0206f	89 74 24 70	 mov	 DWORD PTR _KarpRabinKaze_BOOSTEDhits$[esp+4512], esi

; 4272 : long Karp_Rabin_Kaze_4_OCTETShits=0;

  02073	89 74 24 4c	 mov	 DWORD PTR _Karp_Rabin_Kaze_4_OCTETShits$[esp+4512], esi

; 4273 : long Karp_Rabin_Kaze_4_OCTETShits_DOUBLET=0;

  02077	89 74 24 54	 mov	 DWORD PTR _Karp_Rabin_Kaze_4_OCTETShits_DOUBLET$[esp+4512], esi

; 4274 : long KarpRabinhits=0;

  0207b	89 74 24 78	 mov	 DWORD PTR _KarpRabinhits$[esp+4512], esi

; 4275 : long HORSPOOLhits=0;

  0207f	89 74 24 68	 mov	 DWORD PTR _HORSPOOLhits$[esp+4512], esi

; 4276 : long HORSPOOL_Kazehits=0;

  02083	89 74 24 58	 mov	 DWORD PTR _HORSPOOL_Kazehits$[esp+4512], esi

; 4277 : long strstrMicrosofthits=0;

  02087	89 74 24 6c	 mov	 DWORD PTR _strstrMicrosofthits$[esp+4512], esi

; 4278 : long strstrGNUCLibraryhits=0;

  0208b	89 74 24 64	 mov	 DWORD PTR _strstrGNUCLibraryhits$[esp+4512], esi

; 4279 : long Railgun_Quadruplet_6pp_GO=0;

  0208f	89 74 24 74	 mov	 DWORD PTR _Railgun_Quadruplet_6pp_GO$[esp+4512], esi

; 4280 : long Railgun_Quadruplet_6pp_GOtws=0;
; 4281 : long Railgun_Quadruplet_6pp_GOtwl=0;
; 4282 : 
; 4283 : long dummy;
; 4284 : unsigned long long ReallyTraversed;
; 4285 :       char llTOaDigits[27]; // 9,223,372,036,854,775,807: 1(sign or carry)+19(digits)+1('\0')+6(,)
; 4286 : 
; 4287 : int i, j;
; 4288 : char *DumboBox[8][2] = { "an\0", "to\0",

  02093	c7 84 24 80 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4512], OFFSET $SG6279
  0209e	c7 84 24 84 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4516], OFFSET $SG6281

; 4289 :                          "TDK\0", "the\0",

  020a9	c7 84 24 88 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4520], OFFSET $SG6283
  020b4	c7 84 24 8c 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4524], OFFSET $SG6285

; 4290 :                          "fast\0", "easy\0",

  020bf	c7 84 24 90 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4528], OFFSET $SG6287
  020ca	c7 84 24 94 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4532], OFFSET $SG6289

; 4291 :                          "grmbl\0", "email\0",

  020d5	c7 84 24 98 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4536], OFFSET $SG6291
  020e0	c7 84 24 9c 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4540], OFFSET $SG6293

; 4292 :                          "pasting\0", "amazing\0",

  020eb	c7 84 24 a0 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4544], OFFSET $SG6295
  020f6	c7 84 24 a4 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4548], OFFSET $SG6297

; 4293 :                          "underdog\0", "superdog\0",

  02101	c7 84 24 a8 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4552], OFFSET $SG6299
  0210c	c7 84 24 ac 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4556], OFFSET $SG6301

; 4294 :                          "participants\0", "skillessness\0",

  02117	c7 84 24 b0 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4560], OFFSET $SG6303
  02122	c7 84 24 b4 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4564], OFFSET $SG6305

; 4295 :                          "I should have known\0", "human consciousness\0"

  0212d	c7 84 24 b8 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4568], OFFSET $SG6307

; 4296 : };

  02138	c7 84 24 bc 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _DumboBox$[esp+4572], OFFSET $SG6309

; 4297 : 
; 4298 : 
; 4299 : char *Dumbino[52] = { 
; 4300 : "fast\0",

  02143	c7 84 24 c0 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4512], OFFSET $SG6312

; 4301 : "from\0",

  0214e	c7 84 24 c4 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4516], OFFSET $SG6314

; 4302 : "SR71\0",

  02159	c7 84 24 c8 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4520], OFFSET $SG6316

; 4303 : "SONY\0",

  02164	c7 84 24 cc 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4524], OFFSET $SG6318

; 4304 : "Lexx\0",

  0216f	c7 84 24 d0 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4528], OFFSET $SG6320

; 4305 : "Rabea\0",

  0217a	c7 84 24 d4 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4532], OFFSET $SG6322

; 4306 : "makes\0",

  02185	c7 84 24 d8 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4536], OFFSET $SG6324

; 4307 : "punny\0",

  02190	c7 84 24 dc 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4540], OFFSET $SG6326

; 4308 : "funny\0",

  0219b	c7 84 24 e0 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4544], OFFSET $SG6328

; 4309 : "Orion\0",

  021a6	c7 84 24 e4 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4548], OFFSET $SG6330

; 4310 : "lemon\0",

  021b1	c7 84 24 e8 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4552], OFFSET $SG6332

; 4311 : "Hi-Fi\0",

  021bc	c7 84 24 ec 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4556], OFFSET $SG6334

; 4312 : "Tesla\0",

  021c7	c7 84 24 f0 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4560], OFFSET $SG6336

; 4313 : "Apache\0",

  021d2	c7 84 24 f4 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4564], OFFSET $SG6338

; 4314 : "monkey\0",

  021dd	c7 84 24 f8 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4568], OFFSET $SG6340

; 4315 : "ramjet\0",

  021e8	c7 84 24 fc 00
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4572], OFFSET $SG6342

; 4316 : "fallen\0",

  021f3	c7 84 24 00 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4576], OFFSET $SG6344

; 4317 : "Albert\0",

  021fe	c7 84 24 04 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4580], OFFSET $SG6346

; 4318 : "Toshiba\0",

  02209	c7 84 24 08 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4584], OFFSET $SG6348

; 4319 : "grammar\0",

  02214	c7 84 24 0c 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4588], OFFSET $SG6350

; 4320 : "pharaoh\0",

  0221f	c7 84 24 10 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4592], OFFSET $SG6352

; 4321 : "decades\0",

  0222a	c7 84 24 14 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4596], OFFSET $SG6354

; 4322 : "#define\0",

  02235	c7 84 24 18 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4600], OFFSET $SG6356

; 4323 : "Delerium\0",

  02240	c7 84 24 1c 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4604], OFFSET $SG6358

; 4324 : "numberly\0",

  0224b	c7 84 24 20 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4608], OFFSET $SG6360

; 4325 : "stellify\0",

  02256	c7 84 24 24 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4612], OFFSET $SG6362

; 4326 : "elephant\0",

  02261	c7 84 24 28 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4616], OFFSET $SG6364

; 4327 : "Layalina\0",

  0226c	c7 84 24 2c 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4620], OFFSET $SG6366

; 4328 : "Fibonacci\0",

  02277	c7 84 24 30 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4624], OFFSET $SG6368

; 4329 : "profanism\0",

  02282	c7 84 24 34 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4628], OFFSET $SG6370

; 4330 : "butterfly\0",

  0228d	c7 84 24 38 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4632], OFFSET $SG6372

; 4331 : "Beth Ditto\0",

  02298	c7 84 24 3c 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4636], OFFSET $SG6374

; 4332 : "Got Nuffin\0",

  022a3	c7 84 24 40 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4640], OFFSET $SG6376

; 4333 : "fly fly fly\0",

  022ae	c7 84 24 44 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4644], OFFSET $SG6378

; 4334 : "quintillion\0",

  022b9	c7 84 24 48 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4648], OFFSET $SG6380

; 4335 : "Sick Of Love\0",

  022c4	c7 84 24 4c 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4652], OFFSET $SG6382

; 4336 : "Love Lockdown\0",

  022cf	c7 84 24 50 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4656], OFFSET $SG6384

; 4337 : "Dannii Minogue\0",

  022da	c7 84 24 54 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4660], OFFSET $SG6386

; 4338 : "299,792,458 m/s\0",

  022e5	c7 84 24 58 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4664], OFFSET $SG6388

; 4339 : "Extreme-Fidelity\0",

  022f0	c7 84 24 5c 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4668], OFFSET $SG6390

; 4340 : "I should have known\0",

  022fb	c7 84 24 60 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4672], OFFSET $SG6392

; 4341 : "human consciousness\0",

  02306	c7 84 24 64 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4676], OFFSET $SG6394

; 4342 : "Truth's your only fear\0",

  02311	c7 84 24 68 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4680], OFFSET $SG6396

; 4343 : "Never thought I'd do it\0",

  0231c	c7 84 24 6c 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4684], OFFSET $SG6398

; 4344 : "innocence over fading fast\0",

  02327	c7 84 24 70 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4688], OFFSET $SG6400

; 4345 : "I hit the ground runnin' free\0",

  02332	c7 84 24 74 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4692], OFFSET $SG6402

; 4346 : "I colour out the darkest clouds\0",

  0233d	c7 84 24 78 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4696], OFFSET $SG6404

; 4347 : "But he's looking right through me\0",

  02348	c7 84 24 7c 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4700], OFFSET $SG6406

; 4348 : "I'm living in an age that calls darkness light\0",

  02353	c7 84 24 80 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4704], OFFSET $SG6408

; 4349 : "Following the wanderings of a dream - a dream that keeps my soul alive\0",
; 4350 : "I notice what matters and I got nothing to lose but darkness and shadows\0",
; 4351 : "Then, singing among the savage branches, it impales itself upon the longest, sharpest spine. And, dying, it rises above its own agony to outcarol the lark and the nightingale.\0"
; 4352 : };
; 4353 : 
; 4354 : 
; 4355 : long FoundIn;
; 4356 : char *FoundInPTR;
; 4357 : 
; 4358 : printf("strstr_SHORT-SHOWDOWN, revision 7, written by Kaze.\n");

  0235e	68 00 00 00 00	 push	 OFFSET $SG6417
  02363	c7 84 24 88 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4712], OFFSET $SG6410
  0236e	c7 84 24 8c 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4716], OFFSET $SG6412
  02379	c7 84 24 90 01
	00 00 00 00 00
	00		 mov	 DWORD PTR _Dumbino$[esp+4720], OFFSET $SG6414
  02384	e8 00 00 00 00	 call	 _printf

; 4359 : printf("Note: There is something very inconsistent even wrong with all timings, still can't figure out the reason!\n");

  02389	68 00 00 00 00	 push	 OFFSET $SG6418
  0238e	e8 00 00 00 00	 call	 _printf

; 4360 : Pattern[0]=0x00;
; 4361 : Strng = (char *)malloc( 200*1024*1024 );

  02393	68 00 00 80 0c	 push	 209715200		; 0c800000H
  02398	c6 84 24 bc 09
	00 00 00	 mov	 BYTE PTR _Pattern$[esp+4524], 0
  023a0	e8 00 00 00 00	 call	 _malloc
  023a5	8b d8		 mov	 ebx, eax
  023a7	83 c4 0c	 add	 esp, 12			; 0000000cH
  023aa	89 5c 24 28	 mov	 DWORD PTR _Strng$[esp+4512], ebx

; 4362 : if( Strng == NULL )

  023ae	3b de		 cmp	 ebx, esi
  023b0	75 25		 jne	 SHORT $LN284@main

; 4363 : { puts( "strstr_SHORT-SHOWDOWN: Needed memory allocation denied!\n" ); return( 1 ); }

  023b2	68 00 00 00 00	 push	 OFFSET $SG6422
  023b7	e8 00 00 00 00	 call	 _puts
  023bc	83 c4 04	 add	 esp, 4
  023bf	8d 46 01	 lea	 eax, DWORD PTR [esi+1]

; 5231 : // Z]
; 5232 : 
; 5233 :    }
; 5234 :    }
; 5235 : // DUMBO ... ]
; 5236 : 
; 5237 : } //if (argc==1) {
; 5238 : 
; 5239 : //exit(1); // Comment it to get on!
; 5240 : 
; 5241 : return(0);
; 5242 :   }

  023c2	5f		 pop	 edi
  023c3	5e		 pop	 esi
  023c4	5b		 pop	 ebx
  023c5	8b 8c 24 90 11
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+4500]
  023cc	33 cc		 xor	 ecx, esp
  023ce	e8 00 00 00 00	 call	 @__security_check_cookie@4
  023d3	8b e5		 mov	 esp, ebp
  023d5	5d		 pop	 ebp
  023d6	c3		 ret	 0
$LN284@main:

; 4364 : if( ( fp_inLINE = fopen( "OSHO.TXT", "rb" ) ) == NULL )

  023d7	68 00 00 00 00	 push	 OFFSET $SG6425
  023dc	68 00 00 00 00	 push	 OFFSET $SG6426
  023e1	e8 00 00 00 00	 call	 _fopen
  023e6	8b f8		 mov	 edi, eax
  023e8	83 c4 08	 add	 esp, 8
  023eb	3b fe		 cmp	 edi, esi
  023ed	75 27		 jne	 SHORT $LN283@main

; 4365 : { printf( "strstr_SHORT-SHOWDOWN: Can't open 'OSHO.TXT' file.\n" ); return( 1 ); }

  023ef	68 00 00 00 00	 push	 OFFSET $SG6427
  023f4	e8 00 00 00 00	 call	 _printf
  023f9	83 c4 04	 add	 esp, 4
  023fc	b8 01 00 00 00	 mov	 eax, 1

; 5231 : // Z]
; 5232 : 
; 5233 :    }
; 5234 :    }
; 5235 : // DUMBO ... ]
; 5236 : 
; 5237 : } //if (argc==1) {
; 5238 : 
; 5239 : //exit(1); // Comment it to get on!
; 5240 : 
; 5241 : return(0);
; 5242 :   }

  02401	5f		 pop	 edi
  02402	5e		 pop	 esi
  02403	5b		 pop	 ebx
  02404	8b 8c 24 90 11
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+4500]
  0240b	33 cc		 xor	 ecx, esp
  0240d	e8 00 00 00 00	 call	 @__security_check_cookie@4
  02412	8b e5		 mov	 esp, ebp
  02414	5d		 pop	 ebp
  02415	c3		 ret	 0
$LN283@main:

; 4366 : 
; 4367 :    fseek(fp_inLINE, 0, SEEK_END);

  02416	6a 02		 push	 2
  02418	56		 push	 esi
  02419	57		 push	 edi
  0241a	e8 00 00 00 00	 call	 _fseek

; 4368 :    Strnglen = ftell(fp_inLINE);

  0241f	57		 push	 edi
  02420	e8 00 00 00 00	 call	 _ftell

; 4369 :    fseek(fp_inLINE, 0, SEEK_SET);

  02425	6a 00		 push	 0
  02427	8b f0		 mov	 esi, eax
  02429	6a 00		 push	 0
  0242b	57		 push	 edi
  0242c	89 74 24 64	 mov	 DWORD PTR _Strnglen$[esp+4540], esi
  02430	e8 00 00 00 00	 call	 _fseek

; 4370 :    fread(Strng, 1, Strnglen, fp_inLINE);

  02435	57		 push	 edi
  02436	56		 push	 esi
  02437	6a 01		 push	 1
  02439	53		 push	 ebx
  0243a	e8 00 00 00 00	 call	 _fread
  0243f	83 c4 2c	 add	 esp, 44			; 0000002cH

; 4371 : 
; 4372 : if (argc==1) {

  02442	83 7d 08 01	 cmp	 DWORD PTR _argc$[ebp], 1
  02446	75 39		 jne	 SHORT $LN937@main

; 4373 : printf("Input Pattern(up to 19+2000 chars): "); gets(Pattern); // char * __cdecl gets(char *);

  02448	68 00 00 00 00	 push	 OFFSET $SG6429
  0244d	e8 00 00 00 00	 call	 _printf
  02452	8d 84 24 b4 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4516]
  02459	50		 push	 eax
  0245a	e8 00 00 00 00	 call	 _gets

; 4374 : Patternlen = strlen(&Pattern[0]);

  0245f	8d 84 24 b8 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4520]
  02466	83 c4 08	 add	 esp, 8
  02469	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
  0246c	8d 64 24 00	 npad	 4
$LL923@main:
  02470	8a 08		 mov	 cl, BYTE PTR [eax]
  02472	40		 inc	 eax
  02473	84 c9		 test	 cl, cl
  02475	75 f9		 jne	 SHORT $LL923@main
  02477	2b c2		 sub	 eax, edx
  02479	8b f8		 mov	 edi, eax
  0247b	89 7c 24 2c	 mov	 DWORD PTR _Patternlen$[esp+4512], edi
  0247f	eb 04		 jmp	 SHORT $LN282@main
$LN937@main:
  02481	8b 7c 24 2c	 mov	 edi, DWORD PTR _Patternlen$[esp+4512]
$LN282@main:

; 4375 : }
; 4376 : 
; 4377 : // Replacing CR with NULL i.e. 13->0
; 4378 : 	for (ThunderwithL=0; ThunderwithL<Strnglen; ThunderwithL++)

  02485	33 c0		 xor	 eax, eax
  02487	85 f6		 test	 esi, esi
  02489	7e 14		 jle	 SHORT $LN279@main
  0248b	eb 03 8d 49 00	 npad	 5
$LL281@main:

; 4379 : 		if (Strng[ThunderwithL] == 13) Strng[ThunderwithL] = 0;

  02490	80 3c 18 0d	 cmp	 BYTE PTR [eax+ebx], 13	; 0000000dH
  02494	75 04		 jne	 SHORT $LN280@main
  02496	c6 04 18 00	 mov	 BYTE PTR [eax+ebx], 0
$LN280@main:

; 4375 : }
; 4376 : 
; 4377 : // Replacing CR with NULL i.e. 13->0
; 4378 : 	for (ThunderwithL=0; ThunderwithL<Strnglen; ThunderwithL++)

  0249a	40		 inc	 eax
  0249b	3b c6		 cmp	 eax, esi
  0249d	7c f1		 jl	 SHORT $LL281@main
$LN279@main:

; 4380 : ThunderwithL=0;ThunderwithR=0;
; 4381 : 
; 4382 : 
; 4383 : 
; 4384 : if (argc==1) {

  0249f	83 7d 08 01	 cmp	 DWORD PTR _argc$[ebp], 1
  024a3	0f 85 68 01 00
	00		 jne	 $LN277@main

; 4385 : 
; 4386 : goto zzzzzzzzzzzzzzzzz;
; 4387 : 
; 4388 : // As one line: [
; 4389 : Railgunhits=0;
; 4390 : printf( "\nDoing Search for Pattern(%dbytes) into String(%dbytes) as-one-line ...\n", Patternlen, Strnglen);
; 4391 : clocks1 = clock();
; 4392 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4
; 4393 : {
; 4394 : //Search area is between Strng[0] .. Strng[n-1]
; 4395 : 
; 4396 : 	FoundInPTR = TW(&Strng[0], Strnglen, &Pattern[0], Patternlen);
; 4397 : //printf("%s\n",FoundInPTR);
; 4398 : 
; 4399 : }
; 4400 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;
; 4401 : printf( "TW_hits/TW_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);
; 4402 : printf( "TW performance: %luKB/clock\n", (Strnglen/((long)(TotalRoughSearchTime)>>4))>>10);
; 4403 : // As one line: ]
; 4404 : 
; 4405 : 
; 4406 : 
; 4407 : 
; 4408 : // As one line: [
; 4409 : Railgunhits=0;
; 4410 : printf( "\nDoing Search for Pattern(%dbytes) into String(%dbytes) as-one-line ...\n", Patternlen, Strnglen);
; 4411 : clocks1 = clock();
; 4412 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4
; 4413 : {
; 4414 : //Search area is between Strng[0] .. Strng[n-1]
; 4415 : 
; 4416 : 	dummy = HORSPOOL_hits(&Strng[0], &Pattern[0], Strnglen, Patternlen);
; 4417 : 
; 4418 : }
; 4419 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;
; 4420 : printf( "BM_HORSPOOL_hits/BM_HORSPOOL_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);
; 4421 : printf( "BM_HORSPOOL performance: %luKB/clock\n", (Strnglen/((long)(TotalRoughSearchTime)>>4))>>10);
; 4422 : // As one line: ]
; 4423 : 
; 4424 : 
; 4425 : 
; 4426 : // As one line: [
; 4427 : Railgunhits=0;
; 4428 : printf( "\nDoing Search for Pattern(%dbytes) into String(%dbytes) as-one-line ...\n", Patternlen, Strnglen);
; 4429 : clocks1 = clock();
; 4430 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4
; 4431 : {
; 4432 : //Search area is between Strng[0] .. Strng[n-1]
; 4433 : 
; 4434 : 	FoundInPTR = Railgun_totalhits(&Strng[0], &Pattern[0], Strnglen, Patternlen);
; 4435 : 
; 4436 : }
; 4437 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;
; 4438 : printf( "Railgun_hits/Railgun_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);
; 4439 : printf( "Railgun performance: %luKB/clock\n", (Strnglen/((long)(TotalRoughSearchTime)>>4))>>10);
; 4440 : // As one line: ]
; 4441 : 
; 4442 : zzzzzzzzzzzzzzzzz:
; 4443 : 
; 4444 : // As one line: [
; 4445 : Railgunhits=0;
; 4446 : printf( "\nDoing Search for Pattern(%dbytes) into String(%dbytes) as-one-line ...\n", Patternlen, Strnglen);

  024a9	56		 push	 esi
  024aa	57		 push	 edi
  024ab	68 00 00 00 00	 push	 OFFSET $SG6460
$zzzzzzzzzzzzzzzzz$6435:
  024b0	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _Railgunhits, 0
  024ba	e8 00 00 00 00	 call	 _printf

; 4447 : printf( "WARNING! The next line works with BMH only for pattern 4[+] long, otherwise (for 2 and 3) other searcher takes over!\n");

  024bf	68 00 00 00 00	 push	 OFFSET $SG6461
  024c4	e8 00 00 00 00	 call	 _printf
  024c9	83 c4 10	 add	 esp, 16			; 00000010H

; 4448 : clocks1 = clock();

  024cc	e8 00 00 00 00	 call	 _clock
  024d1	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax
  024d6	c7 44 24 34 10
	00 00 00	 mov	 DWORD PTR tv3008[esp+4512], 16 ; 00000010H
  024de	8b ff		 npad	 2
$LL267@main:

; 4449 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4
; 4450 : {
; 4451 : //Search area is between Strng[0] .. Strng[n-1]
; 4452 : 
; 4453 : 	FoundInPTR = Railgun_Quadruplet_6pp_count_hits(&Strng[0], &Pattern[0], Strnglen, Patternlen);

  024e0	57		 push	 edi
  024e1	56		 push	 esi
  024e2	8d 8c 24 b8 09
	00 00		 lea	 ecx, DWORD PTR _Pattern$[esp+4520]
  024e9	51		 push	 ecx
  024ea	53		 push	 ebx
  024eb	e8 00 00 00 00	 call	 _Railgun_Quadruplet_6pp_count_hits
  024f0	83 c4 10	 add	 esp, 16			; 00000010H
  024f3	ff 4c 24 34	 dec	 DWORD PTR tv3008[esp+4512]
  024f7	75 e7		 jne	 SHORT $LL267@main

; 4454 : 
; 4455 : }
; 4456 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  024f9	e8 00 00 00 00	 call	 _clock
  024fe	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  02503	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  02509	89 44 24 34	 mov	 DWORD PTR tv8370[esp+4512], eax
  0250d	db 44 24 34	 fild	 DWORD PTR tv8370[esp+4512]
  02511	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  02517	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4457 : printf( "Railgun_6pp_hits/Railgun_6pp_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);

  0251d	e8 00 00 00 00	 call	 __ftol2_sse
  02522	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _Railgunhits
  02528	c1 f8 04	 sar	 eax, 4
  0252b	50		 push	 eax
  0252c	c1 fa 04	 sar	 edx, 4
  0252f	52		 push	 edx
  02530	68 00 00 00 00	 push	 OFFSET $SG6466
  02535	e8 00 00 00 00	 call	 _printf

; 4458 : printf( "Railgun_6pp performance: %luKB/clock\n", (Strnglen/((long)(TotalRoughSearchTime)>>4))>>10);

  0253a	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  02540	e8 00 00 00 00	 call	 __ftol2_sse
  02545	8b c8		 mov	 ecx, eax
  02547	8b c6		 mov	 eax, esi
  02549	99		 cdq
  0254a	c1 f9 04	 sar	 ecx, 4
  0254d	f7 f9		 idiv	 ecx
  0254f	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  02552	50		 push	 eax
  02553	68 00 00 00 00	 push	 OFFSET $SG6468
  02558	e8 00 00 00 00	 call	 _printf

; 4459 : // As one line: ]
; 4460 : 
; 4461 : 
; 4462 : /*
; 4463 : // As one line: [
; 4464 : Railgunhits=0;
; 4465 : printf( "\nDoing Search for Pattern(%dbytes) into String(%dbytes) as-one-line ...\n", Patternlen, Strnglen);
; 4466 : printf( "WARNING! The next line works with BMH only for pattern 4[+] long, otherwise (for 2 and 3) other searcher takes over!\n");
; 4467 : clocks1 = clock();
; 4468 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4
; 4469 : {
; 4470 : //Search area is between Strng[0] .. Strng[n-1]
; 4471 : 
; 4472 : 	FoundInPTR = Railgun_Quadruplet_7m_count_hits(&Strng[0], &Pattern[0], Strnglen, Patternlen);
; 4473 : 
; 4474 : }
; 4475 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;
; 4476 : printf( "Railgun_Quadruplet_7m_hits/Railgun_Quadruplet_7m_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);
; 4477 : printf( "Railgun_Quadruplet_7m performance: %luKB/clock\n", (Strnglen/((long)(TotalRoughSearchTime)>>4))>>10);
; 4478 : // As one line: ]
; 4479 : */
; 4480 : 
; 4481 : 
; 4482 : // As one line: [
; 4483 : Railgunhits=0;
; 4484 : printf( "\nDoing Search for Pattern(%dbytes) into String(%dbytes) as-one-line ...\n", Patternlen, Strnglen);

  0255d	56		 push	 esi
  0255e	57		 push	 edi
  0255f	68 00 00 00 00	 push	 OFFSET $SG6469
  02564	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _Railgunhits, 0
  0256e	e8 00 00 00 00	 call	 _printf

; 4485 : printf( "WARNING! The next line works with BMH only for pattern 4[+] long, otherwise (for 2 and 3) other searcher takes over!\n");

  02573	68 00 00 00 00	 push	 OFFSET $SG6470
  02578	e8 00 00 00 00	 call	 _printf
  0257d	83 c4 24	 add	 esp, 36			; 00000024H

; 4486 : clocks1 = clock();

  02580	e8 00 00 00 00	 call	 _clock
  02585	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax
  0258a	c7 44 24 34 10
	00 00 00	 mov	 DWORD PTR tv2572[esp+4512], 16 ; 00000010H
$LL264@main:

; 4487 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4
; 4488 : {
; 4489 : //Search area is between Strng[0] .. Strng[n-1]
; 4490 : 
; 4491 : 	FoundInPTR = Railgun_Quadruplet_7_count_hits(&Strng[0], &Pattern[0], Strnglen, Patternlen);

  02592	57		 push	 edi
  02593	56		 push	 esi
  02594	8d 94 24 b8 09
	00 00		 lea	 edx, DWORD PTR _Pattern$[esp+4520]
  0259b	52		 push	 edx
  0259c	53		 push	 ebx
  0259d	e8 00 00 00 00	 call	 _Railgun_Quadruplet_7_count_hits
  025a2	83 c4 10	 add	 esp, 16			; 00000010H
  025a5	ff 4c 24 34	 dec	 DWORD PTR tv2572[esp+4512]
  025a9	75 e7		 jne	 SHORT $LL264@main

; 4492 : 
; 4493 : }
; 4494 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  025ab	e8 00 00 00 00	 call	 _clock
  025b0	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  025b5	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  025bb	89 44 24 34	 mov	 DWORD PTR tv8351[esp+4512], eax
  025bf	db 44 24 34	 fild	 DWORD PTR tv8351[esp+4512]
  025c3	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  025c9	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4495 : printf( "Railgun_Quadruplet_7_hits/Railgun_Quadruplet_7_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);

  025cf	e8 00 00 00 00	 call	 __ftol2_sse
  025d4	c1 f8 04	 sar	 eax, 4
  025d7	50		 push	 eax
  025d8	a1 00 00 00 00	 mov	 eax, DWORD PTR _Railgunhits
  025dd	c1 f8 04	 sar	 eax, 4
  025e0	50		 push	 eax
  025e1	68 00 00 00 00	 push	 OFFSET $SG6475
  025e6	e8 00 00 00 00	 call	 _printf

; 4496 : printf( "Railgun_Quadruplet_7 performance: %luKB/clock\n", (Strnglen/((long)(TotalRoughSearchTime)>>4))>>10);

  025eb	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  025f1	e8 00 00 00 00	 call	 __ftol2_sse
  025f6	8b c8		 mov	 ecx, eax
  025f8	8b c6		 mov	 eax, esi
  025fa	99		 cdq
  025fb	c1 f9 04	 sar	 ecx, 4
  025fe	f7 f9		 idiv	 ecx
  02600	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  02603	50		 push	 eax
  02604	68 00 00 00 00	 push	 OFFSET $SG6477
  02609	e8 00 00 00 00	 call	 _printf
  0260e	83 c4 14	 add	 esp, 20			; 00000014H
$LN277@main:

; 4497 : // As one line: ]
; 4498 : 
; 4499 : 
; 4500 : 
; 4501 : 
; 4502 : 
; 4503 : 
; 4504 : 
; 4505 : 
; 4506 : } //if (argc==1) {
; 4507 : 
; 4508 : 
; 4509 : // NEW TEST APPROACH HERE - the old BMH loop of Railgun_Quadruplet_6pp is 67 bytes long whereas the new Railgun_Quadruplet_7mm has 61 i.e. under 64. [
; 4510 : // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; 4511 : 
; 4512 : printf( "\nNote: Executing the next two tests 256 times i.e. the search is for 256x8x2 patterns!\n");

  02611	68 00 00 00 00	 push	 OFFSET $SG6478
  02616	e8 00 00 00 00	 call	 _printf

; 4513 : 
; 4514 : ReallyTraversed=0;

  0261b	33 ff		 xor	 edi, edi

; 4515 : // As one line: [
; 4516 : printf( "\nDoing Search for 8x2 Patterns into String(%dbytes) as-one-line ... Not-Counting-Hits-Just-Returns-First-One\n", Strnglen);

  0261d	56		 push	 esi
  0261e	68 00 00 00 00	 push	 OFFSET $SG6479
  02623	89 7c 24 44	 mov	 DWORD PTR _ReallyTraversed$[esp+4524], edi
  02627	89 7c 24 48	 mov	 DWORD PTR _ReallyTraversed$[esp+4528], edi
  0262b	e8 00 00 00 00	 call	 _printf
  02630	83 c4 0c	 add	 esp, 12			; 0000000cH

; 4517 : clocks1 = clock();

  02633	e8 00 00 00 00	 call	 _clock

; 4519 : {
; 4520 : //Search area is between Strng[0] .. Strng[n-1]
; 4521 : 
; 4522 : for (i = 0; i<8; i++)

  02638	03 f3		 add	 esi, ebx
  0263a	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax
  0263f	89 7c 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], edi
  02643	89 74 24 30	 mov	 DWORD PTR tv6163[esp+4512], esi
$LL261@main:
  02647	c7 44 24 24 00
	00 00 00	 mov	 DWORD PTR _i$[esp+4512], 0
  0264f	90		 npad	 1
$LL258@main:

; 4523 :    {
; 4524 : Railgunhits=0;

  02650	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _Railgunhits, 0

; 4525 : clocks3 = clock();

  0265a	e8 00 00 00 00	 call	 _clock

; 4526 : 	FoundInPTR = Railgun_Quadruplet_6pp(&Strng[0], DumboBox[i][0], Strnglen, strlen(DumboBox[i][0]));

  0265f	8b 54 24 24	 mov	 edx, DWORD PTR _i$[esp+4512]
  02663	8b 94 d4 80 00
	00 00		 mov	 edx, DWORD PTR _DumboBox$[esp+edx*8+4512]
  0266a	8b f2		 mov	 esi, edx
  0266c	a3 00 00 00 00	 mov	 DWORD PTR _clocks3, eax
  02671	89 54 24 20	 mov	 DWORD PTR tv4508[esp+4512], edx
  02675	8d 4e 01	 lea	 ecx, DWORD PTR [esi+1]
$LL924@main:
  02678	8a 06		 mov	 al, BYTE PTR [esi]
  0267a	46		 inc	 esi
  0267b	84 c0		 test	 al, al
  0267d	75 f9		 jne	 SHORT $LL924@main
  0267f	8b 44 24 48	 mov	 eax, DWORD PTR _Strnglen$[esp+4512]
  02683	2b f1		 sub	 esi, ecx
  02685	3b f0		 cmp	 esi, eax
  02687	77 50		 ja	 SHORT $LN292@main
  02689	83 fe 04	 cmp	 esi, 4
  0268c	0f 83 a4 00 00
	00		 jae	 $LN328@main
  02692	8b 44 24 28	 mov	 eax, DWORD PTR _Strng$[esp+4512]
  02696	0f be 7c 16 ff	 movsx	 edi, BYTE PTR [esi+edx-1]
  0269b	8d 0c 06	 lea	 ecx, DWORD PTR [esi+eax]
  0269e	0f be 02	 movsx	 eax, BYTE PTR [edx]
  026a1	c1 e0 08	 shl	 eax, 8
  026a4	03 f8		 add	 edi, eax
  026a6	83 fe 03	 cmp	 esi, 3
  026a9	75 4f		 jne	 SHORT $LN626@main
  026ab	8b 44 24 30	 mov	 eax, DWORD PTR tv6163[esp+4512]
  026af	90		 npad	 1
$LL326@main:
  026b0	0f be 71 fd	 movsx	 esi, BYTE PTR [ecx-3]
  026b4	0f be 59 ff	 movsx	 ebx, BYTE PTR [ecx-1]
  026b8	c1 e6 08	 shl	 esi, 8
  026bb	03 f3		 add	 esi, ebx
  026bd	3b fe		 cmp	 edi, esi
  026bf	75 08		 jne	 SHORT $LN323@main
  026c1	8a 5a 01	 mov	 bl, BYTE PTR [edx+1]
  026c4	3a 59 fe	 cmp	 bl, BYTE PTR [ecx-2]
  026c7	74 2c		 je	 SHORT $LN766@main
$LN323@main:
  026c9	8b df		 mov	 ebx, edi
  026cb	c1 eb 08	 shr	 ebx, 8
  026ce	3a 59 fe	 cmp	 bl, BYTE PTR [ecx-2]
  026d1	74 01		 je	 SHORT $LN322@main
  026d3	41		 inc	 ecx
$LN322@main:
  026d4	41		 inc	 ecx
  026d5	3b c8		 cmp	 ecx, eax
  026d7	76 d7		 jbe	 SHORT $LL326@main
$LN292@main:
  026d9	33 c9		 xor	 ecx, ecx
$LN300@main:

; 4527 : if ((long)(FoundInPTR-&Strng[0])>=0) ReallyTraversed=ReallyTraversed+(long)(FoundInPTR-&Strng[0])+1;

  026db	8b f1		 mov	 esi, ecx
  026dd	2b 74 24 28	 sub	 esi, DWORD PTR _Strng$[esp+4512]
  026e1	0f 88 01 02 00
	00		 js	 $LN255@main
  026e7	8b c6		 mov	 eax, esi
  026e9	99		 cdq
  026ea	83 c0 01	 add	 eax, 1
  026ed	83 d2 00	 adc	 edx, 0
  026f0	e9 f8 01 00 00	 jmp	 $LN1079@main
$LN766@main:

; 4526 : 	FoundInPTR = Railgun_Quadruplet_6pp(&Strng[0], DumboBox[i][0], Strnglen, strlen(DumboBox[i][0]));

  026f5	83 c1 fd	 add	 ecx, -3			; fffffffdH
  026f8	eb e1		 jmp	 SHORT $LN300@main
$LN626@main:
  026fa	8a 41 ff	 mov	 al, BYTE PTR [ecx-1]
  026fd	0f be 51 fe	 movsx	 edx, BYTE PTR [ecx-2]
  02701	0f be f0	 movsx	 esi, al
  02704	c1 e2 08	 shl	 edx, 8
  02707	03 d6		 add	 edx, esi
  02709	3b fa		 cmp	 edi, edx
  0270b	74 24		 je	 SHORT $LN768@main
  0270d	8b d7		 mov	 edx, edi
  0270f	c1 ea 08	 shr	 edx, 8
$LN319@main:
  02712	3a d0		 cmp	 dl, al
  02714	74 01		 je	 SHORT $LN316@main
  02716	41		 inc	 ecx
$LN316@main:
  02717	41		 inc	 ecx
  02718	3b 4c 24 30	 cmp	 ecx, DWORD PTR tv6163[esp+4512]
  0271c	77 bb		 ja	 SHORT $LN292@main
  0271e	8a 41 ff	 mov	 al, BYTE PTR [ecx-1]
  02721	0f be 71 fe	 movsx	 esi, BYTE PTR [ecx-2]
  02725	0f be d8	 movsx	 ebx, al
  02728	c1 e6 08	 shl	 esi, 8
  0272b	03 f3		 add	 esi, ebx
  0272d	3b fe		 cmp	 edi, esi
  0272f	75 e1		 jne	 SHORT $LN319@main
$LN768@main:
  02731	83 c1 fe	 add	 ecx, -2			; fffffffeH
  02734	eb a5		 jmp	 SHORT $LN300@main
$LN328@main:
  02736	3d c1 03 00 00	 cmp	 eax, 961		; 000003c1H
  0273b	0f 83 ec 00 00
	00		 jae	 $LN313@main
  02741	8b 4c 24 20	 mov	 ecx, DWORD PTR tv4508[esp+4512]
  02745	8b 11		 mov	 edx, DWORD PTR [ecx]
  02747	8b 44 24 28	 mov	 eax, DWORD PTR _Strng$[esp+4512]
  0274b	8d 1c 06	 lea	 ebx, DWORD PTR [esi+eax]
  0274e	0f b6 c2	 movzx	 eax, dl
  02751	8b c8		 mov	 ecx, eax
  02753	c1 e1 08	 shl	 ecx, 8
  02756	89 4c 24 40	 mov	 DWORD PTR _Quadruplet2nd$7558[esp+4512], ecx
  0275a	8b c8		 mov	 ecx, eax
  0275c	c1 e1 10	 shl	 ecx, 16			; 00000010H
  0275f	89 44 24 5c	 mov	 DWORD PTR tv6172[esp+4512], eax
  02763	c1 e0 18	 shl	 eax, 24			; 00000018H
  02766	89 5c 24 50	 mov	 DWORD PTR $T7611[esp+4512], ebx
  0276a	89 54 24 34	 mov	 DWORD PTR _ulHashPattern$7553[esp+4512], edx
  0276e	89 4c 24 44	 mov	 DWORD PTR _Quadruplet3rd$7559[esp+4512], ecx
  02772	89 44 24 14	 mov	 DWORD PTR _Quadruplet4th$7560[esp+4512], eax
$LL312@main:
  02776	8b c3		 mov	 eax, ebx
  02778	2b c6		 sub	 eax, esi
  0277a	8b 08		 mov	 ecx, DWORD PTR [eax]
  0277c	33 ff		 xor	 edi, edi
  0277e	89 7c 24 10	 mov	 DWORD PTR _AdvanceHopperGrass$7561[esp+4512], edi
  02782	3b d1		 cmp	 edx, ecx
  02784	75 56		 jne	 SHORT $LN310@main
  02786	8d 4e ff	 lea	 ecx, DWORD PTR [esi-1]
  02789	85 c9		 test	 ecx, ecx
  0278b	74 3c		 je	 SHORT $LN910@main
  0278d	8b d6		 mov	 edx, esi
  0278f	8b fb		 mov	 edi, ebx
  02791	2b d1		 sub	 edx, ecx
  02793	2b f9		 sub	 edi, ecx
  02795	03 54 24 20	 add	 edx, DWORD PTR tv4508[esp+4512]
  02799	8d a4 24 00 00
	00 00		 npad	 7
$LL309@main:
  027a0	8a 07		 mov	 al, BYTE PTR [edi]
  027a2	38 02		 cmp	 BYTE PTR [edx], al
  027a4	75 2c		 jne	 SHORT $LN308@main
  027a6	8b 5c 24 10	 mov	 ebx, DWORD PTR _AdvanceHopperGrass$7561[esp+4512]
  027aa	8d 46 ff	 lea	 eax, DWORD PTR [esi-1]
  027ad	03 d9		 add	 ebx, ecx
  027af	3b c3		 cmp	 eax, ebx
  027b1	75 0d		 jne	 SHORT $LN307@main
  027b3	0f be 07	 movsx	 eax, BYTE PTR [edi]
  027b6	39 44 24 5c	 cmp	 DWORD PTR tv6172[esp+4512], eax
  027ba	74 04		 je	 SHORT $LN307@main
  027bc	ff 44 24 10	 inc	 DWORD PTR _AdvanceHopperGrass$7561[esp+4512]
$LN307@main:
  027c0	8b 5c 24 50	 mov	 ebx, DWORD PTR $T7611[esp+4512]
  027c4	42		 inc	 edx
  027c5	47		 inc	 edi
  027c6	49		 dec	 ecx
  027c7	75 d7		 jne	 SHORT $LL309@main
$LN910@main:
  027c9	2b de		 sub	 ebx, esi
  027cb	8b cb		 mov	 ecx, ebx
  027cd	e9 09 ff ff ff	 jmp	 $LN300@main
$LN308@main:
  027d2	85 c9		 test	 ecx, ecx
  027d4	74 f3		 je	 SHORT $LN910@main
  027d6	8b 7c 24 10	 mov	 edi, DWORD PTR _AdvanceHopperGrass$7561[esp+4512]
  027da	eb 36		 jmp	 SHORT $LN302@main
$LN310@main:
  027dc	8b d1		 mov	 edx, ecx
  027de	81 e2 00 ff 00
	00		 and	 edx, 65280		; 0000ff00H
  027e4	39 54 24 40	 cmp	 DWORD PTR _Quadruplet2nd$7558[esp+4512], edx
  027e8	74 28		 je	 SHORT $LN302@main
  027ea	8b c1		 mov	 eax, ecx
  027ec	25 00 00 ff 00	 and	 eax, 16711680		; 00ff0000H
  027f1	bf 01 00 00 00	 mov	 edi, 1
  027f6	39 44 24 44	 cmp	 DWORD PTR _Quadruplet3rd$7559[esp+4512], eax
  027fa	74 16		 je	 SHORT $LN302@main
  027fc	81 e1 00 00 00
	ff		 and	 ecx, -16777216		; ff000000H
  02802	bf 02 00 00 00	 mov	 edi, 2
  02807	39 4c 24 14	 cmp	 DWORD PTR _Quadruplet4th$7560[esp+4512], ecx
  0280b	74 05		 je	 SHORT $LN302@main
  0280d	bf 03 00 00 00	 mov	 edi, 3
$LN302@main:
  02812	8d 5c 3b 01	 lea	 ebx, DWORD PTR [ebx+edi+1]
  02816	89 5c 24 50	 mov	 DWORD PTR $T7611[esp+4512], ebx
  0281a	3b 5c 24 30	 cmp	 ebx, DWORD PTR tv6163[esp+4512]
  0281e	0f 87 b5 fe ff
	ff		 ja	 $LN292@main
  02824	8b 54 24 34	 mov	 edx, DWORD PTR _ulHashPattern$7553[esp+4512]
  02828	e9 49 ff ff ff	 jmp	 $LL312@main
$LN313@main:
  0282d	8b 5c 24 20	 mov	 ebx, DWORD PTR tv4508[esp+4512]
  02831	8b 0b		 mov	 ecx, DWORD PTR [ebx]
  02833	89 4c 24 34	 mov	 DWORD PTR _ulHashPattern$7553[esp+4512], ecx
  02837	8b c6		 mov	 eax, esi
  02839	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  0283e	8d bc 24 90 05
	00 00		 lea	 edi, DWORD PTR _bm_bc$7565[esp+4512]
  02845	f3 ab		 rep stosd
  02847	8d 4e ff	 lea	 ecx, DWORD PTR [esi-1]
  0284a	33 c0		 xor	 eax, eax
  0284c	85 c9		 test	 ecx, ecx
  0284e	74 14		 je	 SHORT $LN294@main
  02850	8d 56 ff	 lea	 edx, DWORD PTR [esi-1]
$LL296@main:
  02853	0f be 3c 18	 movsx	 edi, BYTE PTR [eax+ebx]
  02857	89 94 bc 90 05
	00 00		 mov	 DWORD PTR _bm_bc$7565[esp+edi*4+4512], edx
  0285e	40		 inc	 eax
  0285f	4a		 dec	 edx
  02860	3b c1		 cmp	 eax, ecx
  02862	72 ef		 jb	 SHORT $LL296@main
$LN294@main:
  02864	8b 7c 24 48	 mov	 edi, DWORD PTR _Strnglen$[esp+4512]
  02868	0f be 44 1e ff	 movsx	 eax, BYTE PTR [esi+ebx-1]
  0286d	33 d2		 xor	 edx, edx
  0286f	2b fe		 sub	 edi, esi
  02871	89 7c 24 40	 mov	 DWORD PTR $T8328[esp+4512], edi
  02875	89 44 24 14	 mov	 DWORD PTR tv4517[esp+4512], eax
  02879	8d a4 24 00 00
	00 00		 npad	 7
$LL973@main:
  02880	8b 44 24 28	 mov	 eax, DWORD PTR _Strng$[esp+4512]
  02884	8d 0c 16	 lea	 ecx, DWORD PTR [esi+edx]
  02887	0f b6 4c 01 ff	 movzx	 ecx, BYTE PTR [ecx+eax-1]
  0288c	89 4c 24 44	 mov	 DWORD PTR tv4614[esp+4512], ecx
  02890	3b 4c 24 14	 cmp	 ecx, DWORD PTR tv4517[esp+4512]
  02894	75 36		 jne	 SHORT $LN288@main
  02896	8b 5c 24 34	 mov	 ebx, DWORD PTR _ulHashPattern$7553[esp+4512]
  0289a	39 1c 02	 cmp	 DWORD PTR [edx+eax], ebx
  0289d	75 2d		 jne	 SHORT $LN288@main
  0289f	8d 46 fc	 lea	 eax, DWORD PTR [esi-4]
  028a2	85 c0		 test	 eax, eax
  028a4	74 36		 je	 SHORT $LN772@main
  028a6	8b 7c 24 20	 mov	 edi, DWORD PTR tv4508[esp+4512]
  028aa	8b 4c 24 28	 mov	 ecx, DWORD PTR _Strng$[esp+4512]
  028ae	83 c7 04	 add	 edi, 4
  028b1	8d 4c 0a 04	 lea	 ecx, DWORD PTR [edx+ecx+4]
$LL290@main:
  028b5	8a 1f		 mov	 bl, BYTE PTR [edi]
  028b7	3a 19		 cmp	 bl, BYTE PTR [ecx]
  028b9	75 05		 jne	 SHORT $LN289@main
  028bb	41		 inc	 ecx
  028bc	47		 inc	 edi
  028bd	48		 dec	 eax
  028be	75 f5		 jne	 SHORT $LL290@main
$LN289@main:
  028c0	85 c0		 test	 eax, eax
  028c2	7e 18		 jle	 SHORT $LN772@main
  028c4	8b 4c 24 44	 mov	 ecx, DWORD PTR tv4614[esp+4512]
  028c8	8b 7c 24 40	 mov	 edi, DWORD PTR $T8328[esp+4512]
$LN288@main:
  028cc	03 94 8c 90 05
	00 00		 add	 edx, DWORD PTR _bm_bc$7565[esp+ecx*4+4512]
  028d3	3b d7		 cmp	 edx, edi
  028d5	76 a9		 jbe	 SHORT $LL973@main

; 5222 : 	if (ThunderwithR >= Strnglen-1) break;

  028d7	e9 fd fd ff ff	 jmp	 $LN292@main
$LN772@main:

; 4526 : 	FoundInPTR = Railgun_Quadruplet_6pp(&Strng[0], DumboBox[i][0], Strnglen, strlen(DumboBox[i][0]));

  028dc	8b 44 24 28	 mov	 eax, DWORD PTR _Strng$[esp+4512]
  028e0	8d 0c 02	 lea	 ecx, DWORD PTR [edx+eax]
  028e3	e9 f3 fd ff ff	 jmp	 $LN300@main
$LN255@main:

; 4528 : else ReallyTraversed=ReallyTraversed+Strnglen;

  028e8	8b 44 24 48	 mov	 eax, DWORD PTR _Strnglen$[esp+4512]
  028ec	99		 cdq
$LN1079@main:
  028ed	01 44 24 38	 add	 DWORD PTR _ReallyTraversed$[esp+4512], eax
  028f1	11 54 24 3c	 adc	 DWORD PTR _ReallyTraversed$[esp+4516], edx

; 4529 : clocks4 = clock();

  028f5	e8 00 00 00 00	 call	 _clock

; 4530 : if (Bozan == (1<<8)-1) { TotalRoughSearchTime = clocks4 - clocks3; TotalRoughSearchTime++;

  028fa	81 7c 24 18 ff
	00 00 00	 cmp	 DWORD PTR _Bozan$[esp+4512], 255 ; 000000ffH
  02902	a3 00 00 00 00	 mov	 DWORD PTR _clocks4, eax
  02907	75 59		 jne	 SHORT $LN251@main
  02909	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  0290f	89 44 24 14	 mov	 DWORD PTR tv8293[esp+4512], eax
  02913	db 44 24 14	 fild	 DWORD PTR tv8293[esp+4512]
  02917	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  0291d	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4531 :                          if ((long)(FoundInPTR-&Strng[0])>=0) printf( "Found ('%s') at %d position, Railgun_Quadruplet_6pp performance: %luKB/clock\n", DumboBox[i][0], FoundInPTR-&Strng[0], ((long)(FoundInPTR-&Strng[0])/((long)(TotalRoughSearchTime)))>>10);

  02923	e8 00 00 00 00	 call	 __ftol2_sse
  02928	8b c8		 mov	 ecx, eax
  0292a	85 f6		 test	 esi, esi
  0292c	78 16		 js	 SHORT $LN252@main
  0292e	8b c6		 mov	 eax, esi
  02930	99		 cdq
  02931	f7 f9		 idiv	 ecx
  02933	8b 54 24 20	 mov	 edx, DWORD PTR tv4508[esp+4512]
  02937	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  0293a	50		 push	 eax
  0293b	56		 push	 esi
  0293c	52		 push	 edx
  0293d	68 00 00 00 00	 push	 OFFSET $SG6495
  02942	eb 16		 jmp	 SHORT $LN1080@main
$LN252@main:

; 4532 : 			 else printf( "Found ('%s') at %d position, Railgun_Quadruplet_6pp performance: %luKB/clock\n", DumboBox[i][0], FoundInPTR-&Strng[0], (Strnglen/((long)(TotalRoughSearchTime)))>>10);

  02944	8b 44 24 48	 mov	 eax, DWORD PTR _Strnglen$[esp+4512]
  02948	99		 cdq
  02949	f7 f9		 idiv	 ecx
  0294b	8b 54 24 20	 mov	 edx, DWORD PTR tv4508[esp+4512]
  0294f	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  02952	50		 push	 eax
  02953	56		 push	 esi
  02954	52		 push	 edx
  02955	68 00 00 00 00	 push	 OFFSET $SG6498
$LN1080@main:
  0295a	e8 00 00 00 00	 call	 _printf
  0295f	83 c4 10	 add	 esp, 16			; 00000010H
$LN251@main:

; 4533 :                        }
; 4534 : Railgunhits=0;

  02962	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _Railgunhits, 0

; 4535 : clocks3 = clock();

  0296c	e8 00 00 00 00	 call	 _clock
  02971	a3 00 00 00 00	 mov	 DWORD PTR _clocks3, eax

; 4536 : 	FoundInPTR = Railgun_Quadruplet_6pp(&Strng[0], DumboBox[i][1], Strnglen, strlen(DumboBox[i][1]));

  02976	8b 44 24 24	 mov	 eax, DWORD PTR _i$[esp+4512]
  0297a	8b 9c c4 84 00
	00 00		 mov	 ebx, DWORD PTR _DumboBox$[esp+eax*8+4516]
  02981	8b f3		 mov	 esi, ebx
  02983	89 5c 24 20	 mov	 DWORD PTR tv4658[esp+4512], ebx
  02987	8d 4e 01	 lea	 ecx, DWORD PTR [esi+1]
  0298a	8d 9b 00 00 00
	00		 npad	 6
$LL925@main:
  02990	8a 06		 mov	 al, BYTE PTR [esi]
  02992	46		 inc	 esi
  02993	84 c0		 test	 al, al
  02995	75 f9		 jne	 SHORT $LL925@main
  02997	8b 44 24 48	 mov	 eax, DWORD PTR _Strnglen$[esp+4512]
  0299b	2b f1		 sub	 esi, ecx
  0299d	3b f0		 cmp	 esi, eax
  0299f	0f 87 56 02 00
	00		 ja	 $LN1081@main
  029a5	83 fe 04	 cmp	 esi, 4
  029a8	0f 83 a5 00 00
	00		 jae	 $LN372@main
  029ae	0f be 13	 movsx	 edx, BYTE PTR [ebx]
  029b1	0f be 7c 1e ff	 movsx	 edi, BYTE PTR [esi+ebx-1]
  029b6	8b 4c 24 28	 mov	 ecx, DWORD PTR _Strng$[esp+4512]
  029ba	c1 e2 08	 shl	 edx, 8
  029bd	03 ce		 add	 ecx, esi
  029bf	03 fa		 add	 edi, edx
  029c1	83 fe 03	 cmp	 esi, 3
  029c4	75 40		 jne	 SHORT $LN634@main
  029c6	8b 74 24 30	 mov	 esi, DWORD PTR tv6163[esp+4512]
  029ca	8d 9b 00 00 00
	00		 npad	 6
$LL370@main:
  029d0	0f be 41 fd	 movsx	 eax, BYTE PTR [ecx-3]
  029d4	0f be 51 ff	 movsx	 edx, BYTE PTR [ecx-1]
  029d8	c1 e0 08	 shl	 eax, 8
  029db	03 c2		 add	 eax, edx
  029dd	3b f8		 cmp	 edi, eax
  029df	75 08		 jne	 SHORT $LN367@main
  029e1	8a 43 01	 mov	 al, BYTE PTR [ebx+1]
  029e4	3a 41 fe	 cmp	 al, BYTE PTR [ecx-2]
  029e7	74 15		 je	 SHORT $LN773@main
$LN367@main:
  029e9	8b d7		 mov	 edx, edi
  029eb	c1 ea 08	 shr	 edx, 8
  029ee	3a 51 fe	 cmp	 dl, BYTE PTR [ecx-2]
  029f1	74 01		 je	 SHORT $LN366@main
  029f3	41		 inc	 ecx
$LN366@main:
  029f4	41		 inc	 ecx
  029f5	3b ce		 cmp	 ecx, esi
  029f7	76 d7		 jbe	 SHORT $LL370@main
  029f9	e9 fd 01 00 00	 jmp	 $LN1081@main
$LN773@main:
  029fe	83 c1 fd	 add	 ecx, -3			; fffffffdH
  02a01	e9 f7 01 00 00	 jmp	 $LN344@main
$LN634@main:
  02a06	8a 41 ff	 mov	 al, BYTE PTR [ecx-1]
  02a09	0f be 51 fe	 movsx	 edx, BYTE PTR [ecx-2]
  02a0d	0f be f0	 movsx	 esi, al
  02a10	c1 e2 08	 shl	 edx, 8
  02a13	03 d6		 add	 edx, esi
  02a15	3b fa		 cmp	 edi, edx
  02a17	74 32		 je	 SHORT $LN775@main
  02a19	8b d7		 mov	 edx, edi
  02a1b	c1 ea 08	 shr	 edx, 8

; 4542 : 			 else printf( "Found ('%s') at %d position, Railgun_Quadruplet_6pp performance: %luKB/clock\n", DumboBox[i][1], FoundInPTR-&Strng[0], (Strnglen/((long)(TotalRoughSearchTime)))>>10);

  02a1e	89 54 24 14	 mov	 DWORD PTR tv4692[esp+4512], edx
  02a22	eb 04		 jmp	 SHORT $LN363@main
$LL1004@main:
  02a24	8b 54 24 14	 mov	 edx, DWORD PTR tv4692[esp+4512]

; 4536 : 	FoundInPTR = Railgun_Quadruplet_6pp(&Strng[0], DumboBox[i][1], Strnglen, strlen(DumboBox[i][1]));

$LN363@main:
  02a28	3a d0		 cmp	 dl, al
  02a2a	74 01		 je	 SHORT $LN360@main
  02a2c	41		 inc	 ecx
$LN360@main:
  02a2d	41		 inc	 ecx
  02a2e	3b 4c 24 30	 cmp	 ecx, DWORD PTR tv6163[esp+4512]
  02a32	0f 87 c3 01 00
	00		 ja	 $LN1081@main
  02a38	8a 41 ff	 mov	 al, BYTE PTR [ecx-1]
  02a3b	0f be 51 fe	 movsx	 edx, BYTE PTR [ecx-2]
  02a3f	0f be f0	 movsx	 esi, al
  02a42	c1 e2 08	 shl	 edx, 8
  02a45	03 d6		 add	 edx, esi
  02a47	3b fa		 cmp	 edi, edx
  02a49	75 d9		 jne	 SHORT $LL1004@main
$LN775@main:
  02a4b	83 c1 fe	 add	 ecx, -2			; fffffffeH
  02a4e	e9 aa 01 00 00	 jmp	 $LN344@main
$LN372@main:
  02a53	3d c1 03 00 00	 cmp	 eax, 961		; 000003c1H
  02a58	0f 83 e9 00 00
	00		 jae	 $LN357@main
  02a5e	8b 4c 24 20	 mov	 ecx, DWORD PTR tv4658[esp+4512]
  02a62	8b 11		 mov	 edx, DWORD PTR [ecx]
  02a64	8b 44 24 28	 mov	 eax, DWORD PTR _Strng$[esp+4512]
  02a68	8d 1c 06	 lea	 ebx, DWORD PTR [esi+eax]
  02a6b	0f b6 c2	 movzx	 eax, dl
  02a6e	8b c8		 mov	 ecx, eax
  02a70	c1 e1 08	 shl	 ecx, 8
  02a73	89 4c 24 44	 mov	 DWORD PTR _Quadruplet2nd$7623[esp+4512], ecx
  02a77	8b c8		 mov	 ecx, eax
  02a79	c1 e1 10	 shl	 ecx, 16			; 00000010H
  02a7c	89 44 24 14	 mov	 DWORD PTR tv6209[esp+4512], eax
  02a80	c1 e0 18	 shl	 eax, 24			; 00000018H
  02a83	89 5c 24 34	 mov	 DWORD PTR $T7676[esp+4512], ebx
  02a87	89 54 24 50	 mov	 DWORD PTR _ulHashPattern$7618[esp+4512], edx
  02a8b	89 4c 24 40	 mov	 DWORD PTR _Quadruplet3rd$7624[esp+4512], ecx
  02a8f	89 44 24 5c	 mov	 DWORD PTR _Quadruplet4th$7625[esp+4512], eax
$LL356@main:
  02a93	8b c3		 mov	 eax, ebx
  02a95	2b c6		 sub	 eax, esi
  02a97	8b 08		 mov	 ecx, DWORD PTR [eax]
  02a99	33 ff		 xor	 edi, edi
  02a9b	89 7c 24 10	 mov	 DWORD PTR _AdvanceHopperGrass$7626[esp+4512], edi
  02a9f	3b d1		 cmp	 edx, ecx
  02aa1	75 53		 jne	 SHORT $LN354@main
  02aa3	8d 4e ff	 lea	 ecx, DWORD PTR [esi-1]
  02aa6	85 c9		 test	 ecx, ecx
  02aa8	74 35		 je	 SHORT $LN911@main
  02aaa	8b d6		 mov	 edx, esi
  02aac	8b fb		 mov	 edi, ebx
  02aae	2b d1		 sub	 edx, ecx
  02ab0	2b f9		 sub	 edi, ecx
  02ab2	03 54 24 20	 add	 edx, DWORD PTR tv4658[esp+4512]
$LL353@main:
  02ab6	8a 07		 mov	 al, BYTE PTR [edi]
  02ab8	38 02		 cmp	 BYTE PTR [edx], al
  02aba	75 30		 jne	 SHORT $LN352@main
  02abc	8b 5c 24 10	 mov	 ebx, DWORD PTR _AdvanceHopperGrass$7626[esp+4512]
  02ac0	8d 46 ff	 lea	 eax, DWORD PTR [esi-1]
  02ac3	03 d9		 add	 ebx, ecx
  02ac5	3b c3		 cmp	 eax, ebx
  02ac7	75 0d		 jne	 SHORT $LN351@main
  02ac9	0f be 07	 movsx	 eax, BYTE PTR [edi]
  02acc	39 44 24 14	 cmp	 DWORD PTR tv6209[esp+4512], eax
  02ad0	74 04		 je	 SHORT $LN351@main
  02ad2	ff 44 24 10	 inc	 DWORD PTR _AdvanceHopperGrass$7626[esp+4512]
$LN351@main:
  02ad6	8b 5c 24 34	 mov	 ebx, DWORD PTR $T7676[esp+4512]
  02ada	42		 inc	 edx
  02adb	47		 inc	 edi
  02adc	49		 dec	 ecx
  02add	75 d7		 jne	 SHORT $LL353@main
$LN911@main:
  02adf	2b de		 sub	 ebx, esi
  02ae1	8b cb		 mov	 ecx, ebx
  02ae3	8b 5c 24 20	 mov	 ebx, DWORD PTR tv4658[esp+4512]
  02ae7	e9 11 01 00 00	 jmp	 $LN344@main
$LN352@main:
  02aec	85 c9		 test	 ecx, ecx
  02aee	74 ef		 je	 SHORT $LN911@main
  02af0	8b 7c 24 10	 mov	 edi, DWORD PTR _AdvanceHopperGrass$7626[esp+4512]
  02af4	eb 36		 jmp	 SHORT $LN346@main
$LN354@main:
  02af6	8b d1		 mov	 edx, ecx
  02af8	81 e2 00 ff 00
	00		 and	 edx, 65280		; 0000ff00H
  02afe	39 54 24 44	 cmp	 DWORD PTR _Quadruplet2nd$7623[esp+4512], edx
  02b02	74 28		 je	 SHORT $LN346@main
  02b04	8b c1		 mov	 eax, ecx
  02b06	25 00 00 ff 00	 and	 eax, 16711680		; 00ff0000H
  02b0b	bf 01 00 00 00	 mov	 edi, 1
  02b10	39 44 24 40	 cmp	 DWORD PTR _Quadruplet3rd$7624[esp+4512], eax
  02b14	74 16		 je	 SHORT $LN346@main
  02b16	81 e1 00 00 00
	ff		 and	 ecx, -16777216		; ff000000H
  02b1c	bf 02 00 00 00	 mov	 edi, 2
  02b21	39 4c 24 5c	 cmp	 DWORD PTR _Quadruplet4th$7625[esp+4512], ecx
  02b25	74 05		 je	 SHORT $LN346@main
  02b27	bf 03 00 00 00	 mov	 edi, 3
$LN346@main:
  02b2c	8d 5c 3b 01	 lea	 ebx, DWORD PTR [ebx+edi+1]
  02b30	89 5c 24 34	 mov	 DWORD PTR $T7676[esp+4512], ebx
  02b34	3b 5c 24 30	 cmp	 ebx, DWORD PTR tv6163[esp+4512]
  02b38	0f 87 b9 00 00
	00		 ja	 $LN336@main
  02b3e	8b 54 24 50	 mov	 edx, DWORD PTR _ulHashPattern$7618[esp+4512]
  02b42	e9 4c ff ff ff	 jmp	 $LL356@main
$LN357@main:
  02b47	8b 0b		 mov	 ecx, DWORD PTR [ebx]
  02b49	89 4c 24 50	 mov	 DWORD PTR _ulHashPattern$7618[esp+4512], ecx
  02b4d	8b c6		 mov	 eax, esi
  02b4f	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  02b54	8d bc 24 90 01
	00 00		 lea	 edi, DWORD PTR _bm_bc$7630[esp+4512]
  02b5b	f3 ab		 rep stosd
  02b5d	8d 4e ff	 lea	 ecx, DWORD PTR [esi-1]
  02b60	33 c0		 xor	 eax, eax
  02b62	85 c9		 test	 ecx, ecx
  02b64	74 1b		 je	 SHORT $LN338@main
  02b66	8d 56 ff	 lea	 edx, DWORD PTR [esi-1]
  02b69	8d a4 24 00 00
	00 00		 npad	 7
$LL340@main:
  02b70	0f be 3c 18	 movsx	 edi, BYTE PTR [eax+ebx]
  02b74	89 94 bc 90 01
	00 00		 mov	 DWORD PTR _bm_bc$7630[esp+edi*4+4512], edx
  02b7b	40		 inc	 eax
  02b7c	4a		 dec	 edx
  02b7d	3b c1		 cmp	 eax, ecx
  02b7f	72 ef		 jb	 SHORT $LL340@main
$LN338@main:
  02b81	8b 7c 24 48	 mov	 edi, DWORD PTR _Strnglen$[esp+4512]
  02b85	0f be 44 1e ff	 movsx	 eax, BYTE PTR [esi+ebx-1]
  02b8a	33 d2		 xor	 edx, edx
  02b8c	2b fe		 sub	 edi, esi
  02b8e	89 7c 24 40	 mov	 DWORD PTR $T8330[esp+4512], edi
  02b92	89 44 24 14	 mov	 DWORD PTR tv4667[esp+4512], eax
  02b96	eb 08 8d a4 24
	00 00 00 00 90	 npad	 10
$LL974@main:
  02ba0	8b 44 24 28	 mov	 eax, DWORD PTR _Strng$[esp+4512]
  02ba4	8d 0c 06	 lea	 ecx, DWORD PTR [esi+eax]
  02ba7	0f b6 4c 11 ff	 movzx	 ecx, BYTE PTR [ecx+edx-1]
  02bac	89 4c 24 44	 mov	 DWORD PTR tv4763[esp+4512], ecx
  02bb0	3b 4c 24 14	 cmp	 ecx, DWORD PTR tv4667[esp+4512]
  02bb4	75 36		 jne	 SHORT $LN332@main
  02bb6	8b 5c 24 50	 mov	 ebx, DWORD PTR _ulHashPattern$7618[esp+4512]
  02bba	39 1c 10	 cmp	 DWORD PTR [eax+edx], ebx
  02bbd	75 2d		 jne	 SHORT $LN332@main
  02bbf	8d 46 fc	 lea	 eax, DWORD PTR [esi-4]
  02bc2	85 c0		 test	 eax, eax
  02bc4	74 4a		 je	 SHORT $LN779@main
  02bc6	8b 7c 24 20	 mov	 edi, DWORD PTR tv4658[esp+4512]
  02bca	8b 4c 24 28	 mov	 ecx, DWORD PTR _Strng$[esp+4512]
  02bce	83 c7 04	 add	 edi, 4
  02bd1	8d 4c 11 04	 lea	 ecx, DWORD PTR [ecx+edx+4]
$LL334@main:
  02bd5	8a 1f		 mov	 bl, BYTE PTR [edi]
  02bd7	3a 19		 cmp	 bl, BYTE PTR [ecx]
  02bd9	75 05		 jne	 SHORT $LN333@main
  02bdb	41		 inc	 ecx
  02bdc	47		 inc	 edi
  02bdd	48		 dec	 eax
  02bde	75 f5		 jne	 SHORT $LL334@main
$LN333@main:
  02be0	85 c0		 test	 eax, eax
  02be2	7e 2c		 jle	 SHORT $LN779@main
  02be4	8b 4c 24 44	 mov	 ecx, DWORD PTR tv4763[esp+4512]
  02be8	8b 7c 24 40	 mov	 edi, DWORD PTR $T8330[esp+4512]
$LN332@main:
  02bec	03 94 8c 90 01
	00 00		 add	 edx, DWORD PTR _bm_bc$7630[esp+ecx*4+4512]
  02bf3	3b d7		 cmp	 edx, edi
  02bf5	76 a9		 jbe	 SHORT $LL974@main
$LN336@main:
  02bf7	8b 5c 24 20	 mov	 ebx, DWORD PTR tv4658[esp+4512]
$LN1081@main:
  02bfb	33 c9		 xor	 ecx, ecx
$LN344@main:

; 4537 : if ((long)(FoundInPTR-&Strng[0])>=0) ReallyTraversed=ReallyTraversed+(long)(FoundInPTR-&Strng[0])+1;

  02bfd	8b f1		 mov	 esi, ecx
  02bff	2b 74 24 28	 sub	 esi, DWORD PTR _Strng$[esp+4512]
  02c03	78 17		 js	 SHORT $LN250@main
  02c05	8b c6		 mov	 eax, esi
  02c07	99		 cdq
  02c08	83 c0 01	 add	 eax, 1
  02c0b	83 d2 00	 adc	 edx, 0
  02c0e	eb 11		 jmp	 SHORT $LN1084@main
$LN779@main:

; 4536 : 	FoundInPTR = Railgun_Quadruplet_6pp(&Strng[0], DumboBox[i][1], Strnglen, strlen(DumboBox[i][1]));

  02c10	8b 4c 24 28	 mov	 ecx, DWORD PTR _Strng$[esp+4512]
  02c14	8b 5c 24 20	 mov	 ebx, DWORD PTR tv4658[esp+4512]
  02c18	03 ca		 add	 ecx, edx
  02c1a	eb e1		 jmp	 SHORT $LN344@main
$LN250@main:

; 4538 : else ReallyTraversed=ReallyTraversed+Strnglen;

  02c1c	8b 44 24 48	 mov	 eax, DWORD PTR _Strnglen$[esp+4512]
  02c20	99		 cdq
$LN1084@main:
  02c21	01 44 24 38	 add	 DWORD PTR _ReallyTraversed$[esp+4512], eax
  02c25	11 54 24 3c	 adc	 DWORD PTR _ReallyTraversed$[esp+4516], edx

; 4539 : clocks4 = clock();

  02c29	e8 00 00 00 00	 call	 _clock

; 4540 : if (Bozan == (1<<8)-1) { TotalRoughSearchTime = clocks4 - clocks3; TotalRoughSearchTime++;

  02c2e	81 7c 24 18 ff
	00 00 00	 cmp	 DWORD PTR _Bozan$[esp+4512], 255 ; 000000ffH
  02c36	a3 00 00 00 00	 mov	 DWORD PTR _clocks4, eax
  02c3b	75 51		 jne	 SHORT $LN257@main
  02c3d	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  02c43	89 44 24 14	 mov	 DWORD PTR tv8231[esp+4512], eax
  02c47	db 44 24 14	 fild	 DWORD PTR tv8231[esp+4512]
  02c4b	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  02c51	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4541 :                          if ((long)(FoundInPTR-&Strng[0])>=0) printf( "Found ('%s') at %d position, Railgun_Quadruplet_6pp performance: %luKB/clock\n", DumboBox[i][1], FoundInPTR-&Strng[0], ((long)(FoundInPTR-&Strng[0])/((long)(TotalRoughSearchTime)))>>10);

  02c57	e8 00 00 00 00	 call	 __ftol2_sse
  02c5c	8b c8		 mov	 ecx, eax
  02c5e	85 f6		 test	 esi, esi
  02c60	78 12		 js	 SHORT $LN247@main
  02c62	8b c6		 mov	 eax, esi
  02c64	99		 cdq
  02c65	f7 f9		 idiv	 ecx
  02c67	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  02c6a	50		 push	 eax
  02c6b	56		 push	 esi
  02c6c	53		 push	 ebx
  02c6d	68 00 00 00 00	 push	 OFFSET $SG6508
  02c72	eb 12		 jmp	 SHORT $LN1085@main
$LN247@main:

; 4542 : 			 else printf( "Found ('%s') at %d position, Railgun_Quadruplet_6pp performance: %luKB/clock\n", DumboBox[i][1], FoundInPTR-&Strng[0], (Strnglen/((long)(TotalRoughSearchTime)))>>10);

  02c74	8b 44 24 48	 mov	 eax, DWORD PTR _Strnglen$[esp+4512]
  02c78	99		 cdq
  02c79	f7 f9		 idiv	 ecx
  02c7b	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  02c7e	50		 push	 eax
  02c7f	56		 push	 esi
  02c80	53		 push	 ebx
  02c81	68 00 00 00 00	 push	 OFFSET $SG6511
$LN1085@main:
  02c86	e8 00 00 00 00	 call	 _printf
  02c8b	83 c4 10	 add	 esp, 16			; 00000010H
$LN257@main:

; 4519 : {
; 4520 : //Search area is between Strng[0] .. Strng[n-1]
; 4521 : 
; 4522 : for (i = 0; i<8; i++)

  02c8e	8b 44 24 24	 mov	 eax, DWORD PTR _i$[esp+4512]
  02c92	40		 inc	 eax
  02c93	89 44 24 24	 mov	 DWORD PTR _i$[esp+4512], eax
  02c97	83 f8 08	 cmp	 eax, 8
  02c9a	0f 8c b0 f9 ff
	ff		 jl	 $LL258@main

; 4518 :     for (Bozan=0; Bozan < (1<<8); Bozan++) // 16 times, at end >>4

  02ca0	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  02ca4	40		 inc	 eax
  02ca5	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  02ca9	3d 00 01 00 00	 cmp	 eax, 256		; 00000100H
  02cae	0f 8c 93 f9 ff
	ff		 jl	 $LL261@main

; 4543 : 
; 4544 :                        }
; 4545 :    }
; 4546 : }
; 4547 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  02cb4	e8 00 00 00 00	 call	 _clock
  02cb9	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  02cbe	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  02cc4	89 44 24 14	 mov	 DWORD PTR tv8210[esp+4512], eax
  02cc8	db 44 24 14	 fild	 DWORD PTR tv8210[esp+4512]
  02ccc	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  02cd2	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4548 : //printf( "Railgun_6pp_hits/Railgun_6pp_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);
; 4549 : printf( "Railgun_Quadruplet_6pp 8x2 i.e. average performance: %luKB/clock\n", ((unsigned long long)ReallyTraversed/((long)(TotalRoughSearchTime)))>>10);

  02cd8	e8 00 00 00 00	 call	 __ftol2_sse
  02cdd	8b 7c 24 3c	 mov	 edi, DWORD PTR _ReallyTraversed$[esp+4516]
  02ce1	8b 74 24 38	 mov	 esi, DWORD PTR _ReallyTraversed$[esp+4512]
  02ce5	99		 cdq
  02ce6	52		 push	 edx
  02ce7	50		 push	 eax
  02ce8	57		 push	 edi
  02ce9	56		 push	 esi
  02cea	e8 00 00 00 00	 call	 __aulldiv
  02cef	0f ac d0 0a	 shrd	 eax, edx, 10
  02cf3	c1 ea 0a	 shr	 edx, 10			; 0000000aH
  02cf6	52		 push	 edx
  02cf7	50		 push	 eax
  02cf8	68 00 00 00 00	 push	 OFFSET $SG6514
  02cfd	e8 00 00 00 00	 call	 _printf

; 4550 : printf( "ReallyTraversed: %s bytes\n", _ui64toaKAZEcomma(ReallyTraversed, llTOaDigits, 10));

  02d02	6a 0a		 push	 10			; 0000000aH
  02d04	8d 94 24 a4 09
	00 00		 lea	 edx, DWORD PTR _llTOaDigits$[esp+4528]
  02d0b	52		 push	 edx
  02d0c	57		 push	 edi
  02d0d	56		 push	 esi
  02d0e	e8 00 00 00 00	 call	 __ui64toaKAZEcomma
  02d13	50		 push	 eax
  02d14	68 00 00 00 00	 push	 OFFSET $SG6515
  02d19	e8 00 00 00 00	 call	 _printf

; 4551 : // As one line: ]
; 4552 : 
; 4553 : 
; 4554 : ReallyTraversed=0;
; 4555 : // As one line: [
; 4556 : printf( "\nDoing Search for 8x2 Patterns into String(%dbytes) as-one-line ... Not-Counting-Hits-Just-Returns-First-One\n", Strnglen);

  02d1e	8b 44 24 6c	 mov	 eax, DWORD PTR _Strnglen$[esp+4548]
  02d22	50		 push	 eax
  02d23	33 f6		 xor	 esi, esi
  02d25	68 00 00 00 00	 push	 OFFSET $SG6516
  02d2a	89 74 24 64	 mov	 DWORD PTR _ReallyTraversed$[esp+4556], esi
  02d2e	89 74 24 68	 mov	 DWORD PTR _ReallyTraversed$[esp+4560], esi
  02d32	e8 00 00 00 00	 call	 _printf
  02d37	83 c4 2c	 add	 esp, 44			; 0000002cH

; 4557 : clocks1 = clock();

  02d3a	e8 00 00 00 00	 call	 _clock
  02d3f	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 4558 :     for (Bozan=0; Bozan < (1<<8); Bozan++) // 16 times, at end >>4

  02d44	89 74 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], esi
  02d48	eb 06 8d 9b 00
	00 00 00	 npad	 8
$LL245@main:

; 4559 : {
; 4560 : //Search area is between Strng[0] .. Strng[n-1]
; 4561 : 
; 4562 : for (i = 0; i<8; i++)

  02d50	8b 5c 24 48	 mov	 ebx, DWORD PTR _Strnglen$[esp+4512]
  02d54	c7 44 24 24 00
	00 00 00	 mov	 DWORD PTR _i$[esp+4512], 0
  02d5c	8b 74 24 24	 mov	 esi, DWORD PTR _i$[esp+4512]
$LN242@main:

; 4563 :    {
; 4564 : Railgunhits=0;

  02d60	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _Railgunhits, 0

; 4565 : clocks3 = clock();

  02d6a	e8 00 00 00 00	 call	 _clock

; 4566 : 	FoundInPTR = Railgun_Quadruplet_7(&Strng[0], DumboBox[i][0], Strnglen, strlen(DumboBox[i][0]));

  02d6f	8b bc f4 80 00
	00 00		 mov	 edi, DWORD PTR _DumboBox$[esp+esi*8+4512]
  02d76	a3 00 00 00 00	 mov	 DWORD PTR _clocks3, eax
  02d7b	8b c7		 mov	 eax, edi
  02d7d	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
$LL926@main:
  02d80	8a 08		 mov	 cl, BYTE PTR [eax]
  02d82	40		 inc	 eax
  02d83	84 c9		 test	 cl, cl
  02d85	75 f9		 jne	 SHORT $LL926@main
  02d87	8b 4c 24 28	 mov	 ecx, DWORD PTR _Strng$[esp+4512]
  02d8b	2b c2		 sub	 eax, edx
  02d8d	50		 push	 eax
  02d8e	53		 push	 ebx
  02d8f	57		 push	 edi
  02d90	51		 push	 ecx
  02d91	e8 00 00 00 00	 call	 _Railgun_Quadruplet_7
  02d96	8b f0		 mov	 esi, eax
  02d98	83 c4 10	 add	 esp, 16			; 00000010H

; 4567 : if ((long)(FoundInPTR-&Strng[0])>=0) ReallyTraversed=ReallyTraversed+(long)(FoundInPTR-&Strng[0])+1;

  02d9b	2b 74 24 28	 sub	 esi, DWORD PTR _Strng$[esp+4512]
  02d9f	78 0b		 js	 SHORT $LN239@main
  02da1	8b c6		 mov	 eax, esi
  02da3	99		 cdq
  02da4	83 c0 01	 add	 eax, 1
  02da7	83 d2 00	 adc	 edx, 0
  02daa	eb 03		 jmp	 SHORT $LN1086@main
$LN239@main:

; 4568 : else ReallyTraversed=ReallyTraversed+Strnglen;

  02dac	8b c3		 mov	 eax, ebx
  02dae	99		 cdq
$LN1086@main:
  02daf	01 44 24 38	 add	 DWORD PTR _ReallyTraversed$[esp+4512], eax
  02db3	11 54 24 3c	 adc	 DWORD PTR _ReallyTraversed$[esp+4516], edx

; 4569 : clocks4 = clock();

  02db7	e8 00 00 00 00	 call	 _clock

; 4570 : if (Bozan == (1<<8)-1) { TotalRoughSearchTime = clocks4 - clocks3; TotalRoughSearchTime++;

  02dbc	81 7c 24 18 ff
	00 00 00	 cmp	 DWORD PTR _Bozan$[esp+4512], 255 ; 000000ffH
  02dc4	a3 00 00 00 00	 mov	 DWORD PTR _clocks4, eax
  02dc9	75 4f		 jne	 SHORT $LN235@main
  02dcb	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  02dd1	89 44 24 14	 mov	 DWORD PTR tv8135[esp+4512], eax
  02dd5	db 44 24 14	 fild	 DWORD PTR tv8135[esp+4512]
  02dd9	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  02ddf	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4571 :                          if ((long)(FoundInPTR-&Strng[0])>=0) printf( "Found ('%s') at %d position, Railgun_Quadruplet_7 performance: %luKB/clock\n", DumboBox[i][0], FoundInPTR-&Strng[0], ((long)(FoundInPTR-&Strng[0])/((long)(TotalRoughSearchTime)))>>10);

  02de5	e8 00 00 00 00	 call	 __ftol2_sse
  02dea	8b c8		 mov	 ecx, eax
  02dec	85 f6		 test	 esi, esi
  02dee	78 12		 js	 SHORT $LN236@main
  02df0	8b c6		 mov	 eax, esi
  02df2	99		 cdq
  02df3	f7 f9		 idiv	 ecx
  02df5	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  02df8	50		 push	 eax
  02df9	56		 push	 esi
  02dfa	57		 push	 edi
  02dfb	68 00 00 00 00	 push	 OFFSET $SG6532
  02e00	eb 10		 jmp	 SHORT $LN1087@main
$LN236@main:

; 4572 : 			 else printf( "Found ('%s') at %d position, Railgun_Quadruplet_7 performance: %luKB/clock\n", DumboBox[i][0], FoundInPTR-&Strng[0], (Strnglen/((long)(TotalRoughSearchTime)))>>10);

  02e02	8b c3		 mov	 eax, ebx
  02e04	99		 cdq
  02e05	f7 f9		 idiv	 ecx
  02e07	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  02e0a	50		 push	 eax
  02e0b	56		 push	 esi
  02e0c	57		 push	 edi
  02e0d	68 00 00 00 00	 push	 OFFSET $SG6535
$LN1087@main:
  02e12	e8 00 00 00 00	 call	 _printf
  02e17	83 c4 10	 add	 esp, 16			; 00000010H
$LN235@main:

; 4573 :                        }
; 4574 : Railgunhits=0;

  02e1a	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _Railgunhits, 0

; 4575 : clocks3 = clock();

  02e24	e8 00 00 00 00	 call	 _clock

; 4576 : 	FoundInPTR = Railgun_Quadruplet_7(&Strng[0], DumboBox[i][1], Strnglen, strlen(DumboBox[i][1]));

  02e29	8b 54 24 24	 mov	 edx, DWORD PTR _i$[esp+4512]
  02e2d	8b bc d4 84 00
	00 00		 mov	 edi, DWORD PTR _DumboBox$[esp+edx*8+4516]
  02e34	a3 00 00 00 00	 mov	 DWORD PTR _clocks3, eax
  02e39	8b c7		 mov	 eax, edi
  02e3b	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
  02e3e	8b ff		 npad	 2
$LL927@main:
  02e40	8a 08		 mov	 cl, BYTE PTR [eax]
  02e42	40		 inc	 eax
  02e43	84 c9		 test	 cl, cl
  02e45	75 f9		 jne	 SHORT $LL927@main
  02e47	2b c2		 sub	 eax, edx
  02e49	50		 push	 eax
  02e4a	8b 44 24 2c	 mov	 eax, DWORD PTR _Strng$[esp+4516]
  02e4e	53		 push	 ebx
  02e4f	57		 push	 edi
  02e50	50		 push	 eax
  02e51	e8 00 00 00 00	 call	 _Railgun_Quadruplet_7
  02e56	8b f0		 mov	 esi, eax
  02e58	83 c4 10	 add	 esp, 16			; 00000010H

; 4577 : if ((long)(FoundInPTR-&Strng[0])>=0) ReallyTraversed=ReallyTraversed+(long)(FoundInPTR-&Strng[0])+1;

  02e5b	2b 74 24 28	 sub	 esi, DWORD PTR _Strng$[esp+4512]
  02e5f	78 0b		 js	 SHORT $LN234@main
  02e61	8b c6		 mov	 eax, esi
  02e63	99		 cdq
  02e64	83 c0 01	 add	 eax, 1
  02e67	83 d2 00	 adc	 edx, 0
  02e6a	eb 03		 jmp	 SHORT $LN1088@main
$LN234@main:

; 4578 : else ReallyTraversed=ReallyTraversed+Strnglen;

  02e6c	8b c3		 mov	 eax, ebx
  02e6e	99		 cdq
$LN1088@main:
  02e6f	01 44 24 38	 add	 DWORD PTR _ReallyTraversed$[esp+4512], eax
  02e73	11 54 24 3c	 adc	 DWORD PTR _ReallyTraversed$[esp+4516], edx

; 4579 : clocks4 = clock();

  02e77	e8 00 00 00 00	 call	 _clock

; 4580 : if (Bozan == (1<<8)-1) { TotalRoughSearchTime = clocks4 - clocks3; TotalRoughSearchTime++;

  02e7c	81 7c 24 18 ff
	00 00 00	 cmp	 DWORD PTR _Bozan$[esp+4512], 255 ; 000000ffH
  02e84	a3 00 00 00 00	 mov	 DWORD PTR _clocks4, eax
  02e89	75 4f		 jne	 SHORT $LN241@main
  02e8b	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  02e91	89 44 24 14	 mov	 DWORD PTR tv8082[esp+4512], eax
  02e95	db 44 24 14	 fild	 DWORD PTR tv8082[esp+4512]
  02e99	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  02e9f	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4581 :                          if ((long)(FoundInPTR-&Strng[0])>=0) printf( "Found ('%s') at %d position, Railgun_Quadruplet_7 performance: %luKB/clock\n", DumboBox[i][1], FoundInPTR-&Strng[0], ((long)(FoundInPTR-&Strng[0])/((long)(TotalRoughSearchTime)))>>10);

  02ea5	e8 00 00 00 00	 call	 __ftol2_sse
  02eaa	8b c8		 mov	 ecx, eax
  02eac	85 f6		 test	 esi, esi
  02eae	78 12		 js	 SHORT $LN231@main
  02eb0	8b c6		 mov	 eax, esi
  02eb2	99		 cdq
  02eb3	f7 f9		 idiv	 ecx
  02eb5	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  02eb8	50		 push	 eax
  02eb9	56		 push	 esi
  02eba	57		 push	 edi
  02ebb	68 00 00 00 00	 push	 OFFSET $SG6545
  02ec0	eb 10		 jmp	 SHORT $LN1089@main
$LN231@main:

; 4582 : 			 else printf( "Found ('%s') at %d position, Railgun_Quadruplet_7 performance: %luKB/clock\n", DumboBox[i][1], FoundInPTR-&Strng[0], (Strnglen/((long)(TotalRoughSearchTime)))>>10);

  02ec2	8b c3		 mov	 eax, ebx
  02ec4	99		 cdq
  02ec5	f7 f9		 idiv	 ecx
  02ec7	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  02eca	50		 push	 eax
  02ecb	56		 push	 esi
  02ecc	57		 push	 edi
  02ecd	68 00 00 00 00	 push	 OFFSET $SG6548
$LN1089@main:
  02ed2	e8 00 00 00 00	 call	 _printf
  02ed7	83 c4 10	 add	 esp, 16			; 00000010H
$LN241@main:

; 4559 : {
; 4560 : //Search area is between Strng[0] .. Strng[n-1]
; 4561 : 
; 4562 : for (i = 0; i<8; i++)

  02eda	8b 74 24 24	 mov	 esi, DWORD PTR _i$[esp+4512]
  02ede	46		 inc	 esi
  02edf	89 74 24 24	 mov	 DWORD PTR _i$[esp+4512], esi
  02ee3	83 fe 08	 cmp	 esi, 8
  02ee6	0f 8c 74 fe ff
	ff		 jl	 $LN242@main

; 4558 :     for (Bozan=0; Bozan < (1<<8); Bozan++) // 16 times, at end >>4

  02eec	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  02ef0	40		 inc	 eax
  02ef1	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  02ef5	3d 00 01 00 00	 cmp	 eax, 256		; 00000100H
  02efa	0f 8c 50 fe ff
	ff		 jl	 $LL245@main

; 4583 :                        }
; 4584 :    }
; 4585 : }
; 4586 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  02f00	e8 00 00 00 00	 call	 _clock
  02f05	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  02f0a	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  02f10	89 44 24 14	 mov	 DWORD PTR tv8061[esp+4512], eax
  02f14	db 44 24 14	 fild	 DWORD PTR tv8061[esp+4512]
  02f18	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  02f1e	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4587 : //printf( "Railgun_6pp_hits/Railgun_6pp_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);
; 4588 : printf( "Railgun_Quadruplet_7 8x2 i.e. average performance: %luKB/clock\n", ((unsigned long long)ReallyTraversed/((long)(TotalRoughSearchTime)))>>10);

  02f24	e8 00 00 00 00	 call	 __ftol2_sse
  02f29	8b 7c 24 3c	 mov	 edi, DWORD PTR _ReallyTraversed$[esp+4516]
  02f2d	8b 74 24 38	 mov	 esi, DWORD PTR _ReallyTraversed$[esp+4512]
  02f31	99		 cdq
  02f32	52		 push	 edx
  02f33	50		 push	 eax
  02f34	57		 push	 edi
  02f35	56		 push	 esi
  02f36	e8 00 00 00 00	 call	 __aulldiv
  02f3b	0f ac d0 0a	 shrd	 eax, edx, 10
  02f3f	c1 ea 0a	 shr	 edx, 10			; 0000000aH
  02f42	52		 push	 edx
  02f43	50		 push	 eax
  02f44	68 00 00 00 00	 push	 OFFSET $SG6551
  02f49	e8 00 00 00 00	 call	 _printf

; 4589 : printf( "ReallyTraversed: %s bytes\n", _ui64toaKAZEcomma(ReallyTraversed, llTOaDigits, 10));

  02f4e	6a 0a		 push	 10			; 0000000aH
  02f50	8d 94 24 a4 09
	00 00		 lea	 edx, DWORD PTR _llTOaDigits$[esp+4528]
  02f57	52		 push	 edx
  02f58	57		 push	 edi
  02f59	56		 push	 esi
  02f5a	e8 00 00 00 00	 call	 __ui64toaKAZEcomma
  02f5f	50		 push	 eax
  02f60	68 00 00 00 00	 push	 OFFSET $SG6552
  02f65	e8 00 00 00 00	 call	 _printf

; 4590 : // As one line: ]
; 4591 : 
; 4592 : // ====================================================================================================================
; 4593 : 
; 4594 : printf( "\nNote: Executing the next two tests 256 times i.e. the search is for 256x52 patterns, all utilizing BMH!\n");

  02f6a	68 00 00 00 00	 push	 OFFSET $SG6553
  02f6f	e8 00 00 00 00	 call	 _printf

; 4595 : 
; 4596 : ReallyTraversed=0;
; 4597 : // As one line: [
; 4598 : printf( "\nDoing Search for 52 Patterns into String(%dbytes) as-one-line ... Not-Counting-Hits-Just-Returns-First-One\n", Strnglen);

  02f74	8b c3		 mov	 eax, ebx
  02f76	50		 push	 eax
  02f77	33 f6		 xor	 esi, esi
  02f79	68 00 00 00 00	 push	 OFFSET $SG6554
  02f7e	89 74 24 68	 mov	 DWORD PTR _ReallyTraversed$[esp+4560], esi
  02f82	89 74 24 6c	 mov	 DWORD PTR _ReallyTraversed$[esp+4564], esi
  02f86	e8 00 00 00 00	 call	 _printf
  02f8b	83 c4 30	 add	 esp, 48			; 00000030H

; 4599 : clocks1 = clock();

  02f8e	e8 00 00 00 00	 call	 _clock
  02f93	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 4600 :     for (Bozan=0; Bozan < (1<<8); Bozan++) // 16 times, at end >>4

  02f98	89 74 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], esi
  02f9c	8d 64 24 00	 npad	 4
$LL229@main:

; 4601 : {
; 4602 : //Search area is between Strng[0] .. Strng[n-1]
; 4603 : 
; 4604 : for (i = 0; i<52; i++)

  02fa0	c7 44 24 24 00
	00 00 00	 mov	 DWORD PTR _i$[esp+4512], 0
  02fa8	eb 06 8d 9b 00
	00 00 00	 npad	 8
$LL226@main:

; 4605 :    {
; 4606 : Railgunhits=0;

  02fb0	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _Railgunhits, 0

; 4607 : clocks3 = clock();

  02fba	e8 00 00 00 00	 call	 _clock

; 4608 : 	FoundInPTR = Railgun_Quadruplet_6pp(&Strng[0], Dumbino[i], Strnglen, strlen(Dumbino[i]));

  02fbf	8b 4c 24 24	 mov	 ecx, DWORD PTR _i$[esp+4512]
  02fc3	8b 9c 8c c0 00
	00 00		 mov	 ebx, DWORD PTR _Dumbino$[esp+ecx*4+4512]
  02fca	8b f3		 mov	 esi, ebx
  02fcc	a3 00 00 00 00	 mov	 DWORD PTR _clocks3, eax
  02fd1	89 5c 24 20	 mov	 DWORD PTR tv4799[esp+4512], ebx
  02fd5	8d 4e 01	 lea	 ecx, DWORD PTR [esi+1]
$LL928@main:
  02fd8	8a 06		 mov	 al, BYTE PTR [esi]
  02fda	46		 inc	 esi
  02fdb	84 c0		 test	 al, al
  02fdd	75 f9		 jne	 SHORT $LL928@main
  02fdf	8b 44 24 48	 mov	 eax, DWORD PTR _Strnglen$[esp+4512]
  02fe3	2b f1		 sub	 esi, ecx
  02fe5	3b f0		 cmp	 esi, eax
  02fe7	0f 87 4e 02 00
	00		 ja	 $LN1090@main
  02fed	83 fe 04	 cmp	 esi, 4
  02ff0	0f 83 a0 00 00
	00		 jae	 $LN416@main
  02ff6	0f be 03	 movsx	 eax, BYTE PTR [ebx]
  02ff9	0f be 7c 1e ff	 movsx	 edi, BYTE PTR [esi+ebx-1]
  02ffe	8b 54 24 28	 mov	 edx, DWORD PTR _Strng$[esp+4512]
  03002	c1 e0 08	 shl	 eax, 8
  03005	03 f8		 add	 edi, eax
  03007	8d 0c 16	 lea	 ecx, DWORD PTR [esi+edx]
  0300a	83 fe 03	 cmp	 esi, 3
  0300d	75 3a		 jne	 SHORT $LN646@main
  0300f	8b 74 24 30	 mov	 esi, DWORD PTR tv6163[esp+4512]
$LL414@main:
  03013	0f be 51 fd	 movsx	 edx, BYTE PTR [ecx-3]
  03017	0f be 41 ff	 movsx	 eax, BYTE PTR [ecx-1]
  0301b	c1 e2 08	 shl	 edx, 8
  0301e	03 d0		 add	 edx, eax
  03020	3b fa		 cmp	 edi, edx
  03022	75 08		 jne	 SHORT $LN411@main
  03024	8a 53 01	 mov	 dl, BYTE PTR [ebx+1]
  03027	3a 51 fe	 cmp	 dl, BYTE PTR [ecx-2]
  0302a	74 15		 je	 SHORT $LN780@main
$LN411@main:
  0302c	8b c7		 mov	 eax, edi
  0302e	c1 e8 08	 shr	 eax, 8
  03031	3a 41 fe	 cmp	 al, BYTE PTR [ecx-2]
  03034	74 01		 je	 SHORT $LN410@main
  03036	41		 inc	 ecx
$LN410@main:
  03037	41		 inc	 ecx
  03038	3b ce		 cmp	 ecx, esi
  0303a	76 d7		 jbe	 SHORT $LL414@main
  0303c	e9 fa 01 00 00	 jmp	 $LN1090@main
$LN780@main:
  03041	83 c1 fd	 add	 ecx, -3			; fffffffdH
  03044	e9 f4 01 00 00	 jmp	 $LN388@main
$LN646@main:
  03049	8a 41 ff	 mov	 al, BYTE PTR [ecx-1]
  0304c	0f be 51 fe	 movsx	 edx, BYTE PTR [ecx-2]
  03050	0f be f0	 movsx	 esi, al
  03053	c1 e2 08	 shl	 edx, 8
  03056	03 d6		 add	 edx, esi
  03058	3b fa		 cmp	 edi, edx
  0305a	74 32		 je	 SHORT $LN782@main
  0305c	8b d7		 mov	 edx, edi
  0305e	c1 ea 08	 shr	 edx, 8

; 4614 : 			 else printf( "Found ('%s') at %d position, Railgun_Quadruplet_6pp performance: %luKB/clock\n", Dumbino[i], FoundInPTR-&Strng[0], (Strnglen/((long)(TotalRoughSearchTime)))>>10);

  03061	89 54 24 14	 mov	 DWORD PTR tv4833[esp+4512], edx
  03065	eb 04		 jmp	 SHORT $LN407@main
$LL1001@main:
  03067	8b 54 24 14	 mov	 edx, DWORD PTR tv4833[esp+4512]

; 4608 : 	FoundInPTR = Railgun_Quadruplet_6pp(&Strng[0], Dumbino[i], Strnglen, strlen(Dumbino[i]));

$LN407@main:
  0306b	3a d0		 cmp	 dl, al
  0306d	74 01		 je	 SHORT $LN404@main
  0306f	41		 inc	 ecx
$LN404@main:
  03070	41		 inc	 ecx
  03071	3b 4c 24 30	 cmp	 ecx, DWORD PTR tv6163[esp+4512]
  03075	0f 87 c0 01 00
	00		 ja	 $LN1090@main
  0307b	8a 41 ff	 mov	 al, BYTE PTR [ecx-1]
  0307e	0f be 51 fe	 movsx	 edx, BYTE PTR [ecx-2]
  03082	0f be f0	 movsx	 esi, al
  03085	c1 e2 08	 shl	 edx, 8
  03088	03 d6		 add	 edx, esi
  0308a	3b fa		 cmp	 edi, edx
  0308c	75 d9		 jne	 SHORT $LL1001@main
$LN782@main:
  0308e	83 c1 fe	 add	 ecx, -2			; fffffffeH
  03091	e9 a7 01 00 00	 jmp	 $LN388@main
$LN416@main:
  03096	3d c1 03 00 00	 cmp	 eax, 961		; 000003c1H
  0309b	0f 83 f0 00 00
	00		 jae	 $LN401@main
  030a1	8b 4c 24 20	 mov	 ecx, DWORD PTR tv4799[esp+4512]
  030a5	8b 11		 mov	 edx, DWORD PTR [ecx]
  030a7	8b 44 24 28	 mov	 eax, DWORD PTR _Strng$[esp+4512]
  030ab	8d 1c 06	 lea	 ebx, DWORD PTR [esi+eax]
  030ae	0f b6 c2	 movzx	 eax, dl
  030b1	8b c8		 mov	 ecx, eax
  030b3	c1 e1 08	 shl	 ecx, 8
  030b6	89 4c 24 44	 mov	 DWORD PTR _Quadruplet2nd$7688[esp+4512], ecx
  030ba	8b c8		 mov	 ecx, eax
  030bc	c1 e1 10	 shl	 ecx, 16			; 00000010H
  030bf	89 44 24 14	 mov	 DWORD PTR tv6246[esp+4512], eax
  030c3	c1 e0 18	 shl	 eax, 24			; 00000018H
  030c6	89 5c 24 34	 mov	 DWORD PTR $T7741[esp+4512], ebx
  030ca	89 54 24 50	 mov	 DWORD PTR _ulHashPattern$7683[esp+4512], edx
  030ce	89 4c 24 40	 mov	 DWORD PTR _Quadruplet3rd$7689[esp+4512], ecx
  030d2	89 44 24 5c	 mov	 DWORD PTR _Quadruplet4th$7690[esp+4512], eax
$LL400@main:
  030d6	8b c3		 mov	 eax, ebx
  030d8	2b c6		 sub	 eax, esi
  030da	8b 08		 mov	 ecx, DWORD PTR [eax]
  030dc	33 ff		 xor	 edi, edi
  030de	89 7c 24 10	 mov	 DWORD PTR _AdvanceHopperGrass$7691[esp+4512], edi
  030e2	3b d1		 cmp	 edx, ecx
  030e4	75 5a		 jne	 SHORT $LN398@main
  030e6	8d 4e ff	 lea	 ecx, DWORD PTR [esi-1]
  030e9	85 c9		 test	 ecx, ecx
  030eb	74 3c		 je	 SHORT $LN912@main
  030ed	8b d6		 mov	 edx, esi
  030ef	8b fb		 mov	 edi, ebx
  030f1	2b d1		 sub	 edx, ecx
  030f3	2b f9		 sub	 edi, ecx
  030f5	03 54 24 20	 add	 edx, DWORD PTR tv4799[esp+4512]
  030f9	8d a4 24 00 00
	00 00		 npad	 7
$LL397@main:
  03100	8a 07		 mov	 al, BYTE PTR [edi]
  03102	38 02		 cmp	 BYTE PTR [edx], al
  03104	75 30		 jne	 SHORT $LN396@main
  03106	8b 5c 24 10	 mov	 ebx, DWORD PTR _AdvanceHopperGrass$7691[esp+4512]
  0310a	8d 46 ff	 lea	 eax, DWORD PTR [esi-1]
  0310d	03 d9		 add	 ebx, ecx
  0310f	3b c3		 cmp	 eax, ebx
  03111	75 0d		 jne	 SHORT $LN395@main
  03113	0f be 07	 movsx	 eax, BYTE PTR [edi]
  03116	39 44 24 14	 cmp	 DWORD PTR tv6246[esp+4512], eax
  0311a	74 04		 je	 SHORT $LN395@main
  0311c	ff 44 24 10	 inc	 DWORD PTR _AdvanceHopperGrass$7691[esp+4512]
$LN395@main:
  03120	8b 5c 24 34	 mov	 ebx, DWORD PTR $T7741[esp+4512]
  03124	42		 inc	 edx
  03125	47		 inc	 edi
  03126	49		 dec	 ecx
  03127	75 d7		 jne	 SHORT $LL397@main
$LN912@main:
  03129	2b de		 sub	 ebx, esi
  0312b	8b cb		 mov	 ecx, ebx
  0312d	8b 5c 24 20	 mov	 ebx, DWORD PTR tv4799[esp+4512]
  03131	e9 07 01 00 00	 jmp	 $LN388@main
$LN396@main:
  03136	85 c9		 test	 ecx, ecx
  03138	74 ef		 je	 SHORT $LN912@main
  0313a	8b 7c 24 10	 mov	 edi, DWORD PTR _AdvanceHopperGrass$7691[esp+4512]
  0313e	eb 36		 jmp	 SHORT $LN390@main
$LN398@main:
  03140	8b d1		 mov	 edx, ecx
  03142	81 e2 00 ff 00
	00		 and	 edx, 65280		; 0000ff00H
  03148	39 54 24 44	 cmp	 DWORD PTR _Quadruplet2nd$7688[esp+4512], edx
  0314c	74 28		 je	 SHORT $LN390@main
  0314e	8b c1		 mov	 eax, ecx
  03150	25 00 00 ff 00	 and	 eax, 16711680		; 00ff0000H
  03155	bf 01 00 00 00	 mov	 edi, 1
  0315a	39 44 24 40	 cmp	 DWORD PTR _Quadruplet3rd$7689[esp+4512], eax
  0315e	74 16		 je	 SHORT $LN390@main
  03160	81 e1 00 00 00
	ff		 and	 ecx, -16777216		; ff000000H
  03166	bf 02 00 00 00	 mov	 edi, 2
  0316b	39 4c 24 5c	 cmp	 DWORD PTR _Quadruplet4th$7690[esp+4512], ecx
  0316f	74 05		 je	 SHORT $LN390@main
  03171	bf 03 00 00 00	 mov	 edi, 3
$LN390@main:
  03176	8d 5c 3b 01	 lea	 ebx, DWORD PTR [ebx+edi+1]
  0317a	89 5c 24 34	 mov	 DWORD PTR $T7741[esp+4512], ebx
  0317e	3b 5c 24 30	 cmp	 ebx, DWORD PTR tv6163[esp+4512]
  03182	0f 87 af 00 00
	00		 ja	 $LN380@main
  03188	8b 54 24 50	 mov	 edx, DWORD PTR _ulHashPattern$7683[esp+4512]
  0318c	e9 45 ff ff ff	 jmp	 $LL400@main
$LN401@main:
  03191	8b 0b		 mov	 ecx, DWORD PTR [ebx]
  03193	89 4c 24 50	 mov	 DWORD PTR _ulHashPattern$7683[esp+4512], ecx
  03197	8b c6		 mov	 eax, esi
  03199	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  0319e	8d bc 24 90 01
	00 00		 lea	 edi, DWORD PTR _bm_bc$7695[esp+4512]
  031a5	f3 ab		 rep stosd
  031a7	8d 4e ff	 lea	 ecx, DWORD PTR [esi-1]
  031aa	33 c0		 xor	 eax, eax
  031ac	85 c9		 test	 ecx, ecx
  031ae	74 14		 je	 SHORT $LN382@main
  031b0	8d 56 ff	 lea	 edx, DWORD PTR [esi-1]
$LL384@main:
  031b3	0f be 3c 18	 movsx	 edi, BYTE PTR [eax+ebx]
  031b7	89 94 bc 90 01
	00 00		 mov	 DWORD PTR _bm_bc$7695[esp+edi*4+4512], edx
  031be	40		 inc	 eax
  031bf	4a		 dec	 edx
  031c0	3b c1		 cmp	 eax, ecx
  031c2	72 ef		 jb	 SHORT $LL384@main
$LN382@main:
  031c4	8b 7c 24 48	 mov	 edi, DWORD PTR _Strnglen$[esp+4512]
  031c8	0f be 44 1e ff	 movsx	 eax, BYTE PTR [esi+ebx-1]
  031cd	33 d2		 xor	 edx, edx
  031cf	2b fe		 sub	 edi, esi
  031d1	89 7c 24 44	 mov	 DWORD PTR $T8332[esp+4512], edi
  031d5	89 44 24 14	 mov	 DWORD PTR tv4808[esp+4512], eax
  031d9	8d a4 24 00 00
	00 00		 npad	 7
$LL975@main:
  031e0	8b 44 24 28	 mov	 eax, DWORD PTR _Strng$[esp+4512]
  031e4	8d 0c 16	 lea	 ecx, DWORD PTR [esi+edx]
  031e7	0f b6 4c 01 ff	 movzx	 ecx, BYTE PTR [ecx+eax-1]
  031ec	89 4c 24 40	 mov	 DWORD PTR tv4904[esp+4512], ecx
  031f0	3b 4c 24 14	 cmp	 ecx, DWORD PTR tv4808[esp+4512]
  031f4	75 36		 jne	 SHORT $LN376@main
  031f6	8b 5c 24 50	 mov	 ebx, DWORD PTR _ulHashPattern$7683[esp+4512]
  031fa	39 1c 02	 cmp	 DWORD PTR [edx+eax], ebx
  031fd	75 2d		 jne	 SHORT $LN376@main
  031ff	8d 46 fc	 lea	 eax, DWORD PTR [esi-4]
  03202	85 c0		 test	 eax, eax
  03204	74 4a		 je	 SHORT $LN786@main
  03206	8b 7c 24 20	 mov	 edi, DWORD PTR tv4799[esp+4512]
  0320a	8b 4c 24 28	 mov	 ecx, DWORD PTR _Strng$[esp+4512]
  0320e	83 c7 04	 add	 edi, 4
  03211	8d 4c 0a 04	 lea	 ecx, DWORD PTR [edx+ecx+4]
$LL378@main:
  03215	8a 1f		 mov	 bl, BYTE PTR [edi]
  03217	3a 19		 cmp	 bl, BYTE PTR [ecx]
  03219	75 05		 jne	 SHORT $LN377@main
  0321b	41		 inc	 ecx
  0321c	47		 inc	 edi
  0321d	48		 dec	 eax
  0321e	75 f5		 jne	 SHORT $LL378@main
$LN377@main:
  03220	85 c0		 test	 eax, eax
  03222	7e 2c		 jle	 SHORT $LN786@main
  03224	8b 7c 24 44	 mov	 edi, DWORD PTR $T8332[esp+4512]
  03228	8b 4c 24 40	 mov	 ecx, DWORD PTR tv4904[esp+4512]
$LN376@main:
  0322c	03 94 8c 90 01
	00 00		 add	 edx, DWORD PTR _bm_bc$7695[esp+ecx*4+4512]
  03233	3b d7		 cmp	 edx, edi
  03235	76 a9		 jbe	 SHORT $LL975@main
$LN380@main:
  03237	8b 5c 24 20	 mov	 ebx, DWORD PTR tv4799[esp+4512]
$LN1090@main:
  0323b	33 c9		 xor	 ecx, ecx
$LN388@main:

; 4609 : if ((long)(FoundInPTR-&Strng[0])>=0) ReallyTraversed=ReallyTraversed+(long)(FoundInPTR-&Strng[0])+1;

  0323d	8b f1		 mov	 esi, ecx
  0323f	2b 74 24 28	 sub	 esi, DWORD PTR _Strng$[esp+4512]
  03243	78 18		 js	 SHORT $LN223@main
  03245	8b c6		 mov	 eax, esi
  03247	99		 cdq
  03248	83 c0 01	 add	 eax, 1
  0324b	83 d2 00	 adc	 edx, 0
  0324e	eb 12		 jmp	 SHORT $LN1093@main
$LN786@main:

; 4608 : 	FoundInPTR = Railgun_Quadruplet_6pp(&Strng[0], Dumbino[i], Strnglen, strlen(Dumbino[i]));

  03250	8b 44 24 28	 mov	 eax, DWORD PTR _Strng$[esp+4512]
  03254	8b 5c 24 20	 mov	 ebx, DWORD PTR tv4799[esp+4512]
  03258	8d 0c 02	 lea	 ecx, DWORD PTR [edx+eax]
  0325b	eb e0		 jmp	 SHORT $LN388@main
$LN223@main:

; 4610 : else ReallyTraversed=ReallyTraversed+Strnglen;

  0325d	8b 44 24 48	 mov	 eax, DWORD PTR _Strnglen$[esp+4512]
  03261	99		 cdq
$LN1093@main:
  03262	01 44 24 38	 add	 DWORD PTR _ReallyTraversed$[esp+4512], eax
  03266	11 54 24 3c	 adc	 DWORD PTR _ReallyTraversed$[esp+4516], edx

; 4611 : clocks4 = clock();

  0326a	e8 00 00 00 00	 call	 _clock

; 4612 : if (Bozan == (1<<8)-1) { TotalRoughSearchTime = clocks4 - clocks3; TotalRoughSearchTime++;

  0326f	8b 7c 24 18	 mov	 edi, DWORD PTR _Bozan$[esp+4512]
  03273	a3 00 00 00 00	 mov	 DWORD PTR _clocks4, eax
  03278	81 ff ff 00 00
	00		 cmp	 edi, 255		; 000000ffH
  0327e	75 51		 jne	 SHORT $LN225@main
  03280	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  03286	89 44 24 14	 mov	 DWORD PTR tv7976[esp+4512], eax
  0328a	db 44 24 14	 fild	 DWORD PTR tv7976[esp+4512]
  0328e	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  03294	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4613 :                          if ((long)(FoundInPTR-&Strng[0])>=0) printf( "Found ('%s') at %d position, Railgun_Quadruplet_6pp performance: %luKB/clock\n", Dumbino[i], FoundInPTR-&Strng[0], ((long)(FoundInPTR-&Strng[0])/((long)(TotalRoughSearchTime)))>>10);

  0329a	e8 00 00 00 00	 call	 __ftol2_sse
  0329f	8b c8		 mov	 ecx, eax
  032a1	85 f6		 test	 esi, esi
  032a3	78 12		 js	 SHORT $LN220@main
  032a5	8b c6		 mov	 eax, esi
  032a7	99		 cdq
  032a8	f7 f9		 idiv	 ecx
  032aa	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  032ad	50		 push	 eax
  032ae	56		 push	 esi
  032af	53		 push	 ebx
  032b0	68 00 00 00 00	 push	 OFFSET $SG6570
  032b5	eb 12		 jmp	 SHORT $LN1094@main
$LN220@main:

; 4614 : 			 else printf( "Found ('%s') at %d position, Railgun_Quadruplet_6pp performance: %luKB/clock\n", Dumbino[i], FoundInPTR-&Strng[0], (Strnglen/((long)(TotalRoughSearchTime)))>>10);

  032b7	8b 44 24 48	 mov	 eax, DWORD PTR _Strnglen$[esp+4512]
  032bb	99		 cdq
  032bc	f7 f9		 idiv	 ecx
  032be	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  032c1	50		 push	 eax
  032c2	56		 push	 esi
  032c3	53		 push	 ebx
  032c4	68 00 00 00 00	 push	 OFFSET $SG6573
$LN1094@main:
  032c9	e8 00 00 00 00	 call	 _printf
  032ce	83 c4 10	 add	 esp, 16			; 00000010H
$LN225@main:

; 4601 : {
; 4602 : //Search area is between Strng[0] .. Strng[n-1]
; 4603 : 
; 4604 : for (i = 0; i<52; i++)

  032d1	8b 44 24 24	 mov	 eax, DWORD PTR _i$[esp+4512]
  032d5	40		 inc	 eax
  032d6	89 44 24 24	 mov	 DWORD PTR _i$[esp+4512], eax
  032da	83 f8 34	 cmp	 eax, 52			; 00000034H
  032dd	0f 8c cd fc ff
	ff		 jl	 $LL226@main

; 4600 :     for (Bozan=0; Bozan < (1<<8); Bozan++) // 16 times, at end >>4

  032e3	47		 inc	 edi
  032e4	89 7c 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], edi
  032e8	81 ff 00 01 00
	00		 cmp	 edi, 256		; 00000100H
  032ee	0f 8c ac fc ff
	ff		 jl	 $LL229@main

; 4615 :                        }
; 4616 :    }
; 4617 : }
; 4618 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  032f4	e8 00 00 00 00	 call	 _clock
  032f9	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  032fe	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  03304	89 44 24 14	 mov	 DWORD PTR tv7956[esp+4512], eax
  03308	db 44 24 14	 fild	 DWORD PTR tv7956[esp+4512]
  0330c	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  03312	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4619 : //printf( "Railgun_6pp_hits/Railgun_6pp_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);
; 4620 : printf( "Railgun_Quadruplet_6pp 52 i.e. average performance: %luKB/clock\n", ((unsigned long long)ReallyTraversed/((long)(TotalRoughSearchTime)))>>10);

  03318	e8 00 00 00 00	 call	 __ftol2_sse
  0331d	8b 7c 24 3c	 mov	 edi, DWORD PTR _ReallyTraversed$[esp+4516]
  03321	8b 74 24 38	 mov	 esi, DWORD PTR _ReallyTraversed$[esp+4512]
  03325	99		 cdq
  03326	52		 push	 edx
  03327	50		 push	 eax
  03328	57		 push	 edi
  03329	56		 push	 esi
  0332a	e8 00 00 00 00	 call	 __aulldiv
  0332f	0f ac d0 0a	 shrd	 eax, edx, 10
  03333	c1 ea 0a	 shr	 edx, 10			; 0000000aH
  03336	52		 push	 edx
  03337	50		 push	 eax
  03338	68 00 00 00 00	 push	 OFFSET $SG6576
  0333d	e8 00 00 00 00	 call	 _printf
  03342	83 c4 0c	 add	 esp, 12			; 0000000cH

; 4621 : printf( "TotalRoughSearchTime: %s clocks\n", _ui64toaKAZEcomma(TotalRoughSearchTime, llTOaDigits, 10));

  03345	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  0334b	8d 94 24 94 09
	00 00		 lea	 edx, DWORD PTR _llTOaDigits$[esp+4512]
  03352	6a 0a		 push	 10			; 0000000aH
  03354	52		 push	 edx
  03355	e8 00 00 00 00	 call	 __ftol2
  0335a	52		 push	 edx
  0335b	50		 push	 eax
  0335c	e8 00 00 00 00	 call	 __ui64toaKAZEcomma
  03361	50		 push	 eax
  03362	68 00 00 00 00	 push	 OFFSET $SG6577
  03367	e8 00 00 00 00	 call	 _printf

; 4622 : printf( "ReallyTraversed: %s bytes\n", _ui64toaKAZEcomma(ReallyTraversed, llTOaDigits, 10));

  0336c	6a 0a		 push	 10			; 0000000aH
  0336e	8d 84 24 b0 09
	00 00		 lea	 eax, DWORD PTR _llTOaDigits$[esp+4540]
  03375	50		 push	 eax
  03376	57		 push	 edi
  03377	56		 push	 esi
  03378	e8 00 00 00 00	 call	 __ui64toaKAZEcomma
  0337d	50		 push	 eax
  0337e	68 00 00 00 00	 push	 OFFSET $SG6578
  03383	e8 00 00 00 00	 call	 _printf

; 4623 : // As one line: ]
; 4624 : 
; 4625 : 
; 4626 : ReallyTraversed=0;
; 4627 : // As one line: [
; 4628 : printf( "\nDoing Search for 52 Patterns into String(%dbytes) as-one-line ... Not-Counting-Hits-Just-Returns-First-One\n", Strnglen);

  03388	8b 4c 24 78	 mov	 ecx, DWORD PTR _Strnglen$[esp+4560]
  0338c	51		 push	 ecx
  0338d	33 f6		 xor	 esi, esi
  0338f	68 00 00 00 00	 push	 OFFSET $SG6579
  03394	89 74 24 70	 mov	 DWORD PTR _ReallyTraversed$[esp+4568], esi
  03398	89 74 24 74	 mov	 DWORD PTR _ReallyTraversed$[esp+4572], esi
  0339c	e8 00 00 00 00	 call	 _printf
  033a1	83 c4 38	 add	 esp, 56			; 00000038H

; 4629 : clocks1 = clock();

  033a4	e8 00 00 00 00	 call	 _clock
  033a9	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 4630 :     for (Bozan=0; Bozan < (1<<8); Bozan++) // 16 times, at end >>4

  033ae	89 74 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], esi
  033b2	eb 0c 8d a4 24
	00 00 00 00 eb
	03 8d 49 00	 npad	 14
$LL218@main:

; 4631 : {
; 4632 : //Search area is between Strng[0] .. Strng[n-1]
; 4633 : 
; 4634 : for (i = 0; i<52; i++)

  033c0	8b 5c 24 48	 mov	 ebx, DWORD PTR _Strnglen$[esp+4512]
  033c4	c7 44 24 24 00
	00 00 00	 mov	 DWORD PTR _i$[esp+4512], 0
  033cc	8b 74 24 24	 mov	 esi, DWORD PTR _i$[esp+4512]
$LN215@main:

; 4635 :    {
; 4636 : Railgunhits=0;

  033d0	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _Railgunhits, 0

; 4637 : clocks3 = clock();

  033da	e8 00 00 00 00	 call	 _clock

; 4638 : 	FoundInPTR = Railgun_Quadruplet_7(&Strng[0], Dumbino[i], Strnglen, strlen(Dumbino[i]));

  033df	8b bc b4 c0 00
	00 00		 mov	 edi, DWORD PTR _Dumbino$[esp+esi*4+4512]
  033e6	a3 00 00 00 00	 mov	 DWORD PTR _clocks3, eax
  033eb	8b c7		 mov	 eax, edi
  033ed	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
$LL929@main:
  033f0	8a 08		 mov	 cl, BYTE PTR [eax]
  033f2	40		 inc	 eax
  033f3	84 c9		 test	 cl, cl
  033f5	75 f9		 jne	 SHORT $LL929@main
  033f7	2b c2		 sub	 eax, edx
  033f9	8b 54 24 28	 mov	 edx, DWORD PTR _Strng$[esp+4512]
  033fd	50		 push	 eax
  033fe	53		 push	 ebx
  033ff	57		 push	 edi
  03400	52		 push	 edx
  03401	e8 00 00 00 00	 call	 _Railgun_Quadruplet_7
  03406	8b f0		 mov	 esi, eax
  03408	83 c4 10	 add	 esp, 16			; 00000010H

; 4639 : if ((long)(FoundInPTR-&Strng[0])>=0) ReallyTraversed=ReallyTraversed+(long)(FoundInPTR-&Strng[0])+1;

  0340b	2b 74 24 28	 sub	 esi, DWORD PTR _Strng$[esp+4512]
  0340f	78 0b		 js	 SHORT $LN212@main
  03411	8b c6		 mov	 eax, esi
  03413	99		 cdq
  03414	83 c0 01	 add	 eax, 1
  03417	83 d2 00	 adc	 edx, 0
  0341a	eb 03		 jmp	 SHORT $LN1095@main
$LN212@main:

; 4640 : else ReallyTraversed=ReallyTraversed+Strnglen;

  0341c	8b c3		 mov	 eax, ebx
  0341e	99		 cdq
$LN1095@main:
  0341f	01 44 24 38	 add	 DWORD PTR _ReallyTraversed$[esp+4512], eax
  03423	11 54 24 3c	 adc	 DWORD PTR _ReallyTraversed$[esp+4516], edx

; 4641 : clocks4 = clock();

  03427	e8 00 00 00 00	 call	 _clock

; 4642 : if (Bozan == (1<<8)-1) { TotalRoughSearchTime = clocks4 - clocks3; TotalRoughSearchTime++;

  0342c	81 7c 24 18 ff
	00 00 00	 cmp	 DWORD PTR _Bozan$[esp+4512], 255 ; 000000ffH
  03434	a3 00 00 00 00	 mov	 DWORD PTR _clocks4, eax
  03439	75 4f		 jne	 SHORT $LN214@main
  0343b	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  03441	89 44 24 14	 mov	 DWORD PTR tv7867[esp+4512], eax
  03445	db 44 24 14	 fild	 DWORD PTR tv7867[esp+4512]
  03449	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  0344f	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4643 :                          if ((long)(FoundInPTR-&Strng[0])>=0) printf( "Found ('%s') at %d position, Railgun_Quadruplet_7 performance: %luKB/clock\n", Dumbino[i], FoundInPTR-&Strng[0], ((long)(FoundInPTR-&Strng[0])/((long)(TotalRoughSearchTime)))>>10);

  03455	e8 00 00 00 00	 call	 __ftol2_sse
  0345a	8b c8		 mov	 ecx, eax
  0345c	85 f6		 test	 esi, esi
  0345e	78 12		 js	 SHORT $LN209@main
  03460	8b c6		 mov	 eax, esi
  03462	99		 cdq
  03463	f7 f9		 idiv	 ecx
  03465	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  03468	50		 push	 eax
  03469	56		 push	 esi
  0346a	57		 push	 edi
  0346b	68 00 00 00 00	 push	 OFFSET $SG6595
  03470	eb 10		 jmp	 SHORT $LN1096@main
$LN209@main:

; 4644 : 			 else printf( "Found ('%s') at %d position, Railgun_Quadruplet_7 performance: %luKB/clock\n", Dumbino[i], FoundInPTR-&Strng[0], (Strnglen/((long)(TotalRoughSearchTime)))>>10);

  03472	8b c3		 mov	 eax, ebx
  03474	99		 cdq
  03475	f7 f9		 idiv	 ecx
  03477	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  0347a	50		 push	 eax
  0347b	56		 push	 esi
  0347c	57		 push	 edi
  0347d	68 00 00 00 00	 push	 OFFSET $SG6598
$LN1096@main:
  03482	e8 00 00 00 00	 call	 _printf
  03487	83 c4 10	 add	 esp, 16			; 00000010H
$LN214@main:

; 4631 : {
; 4632 : //Search area is between Strng[0] .. Strng[n-1]
; 4633 : 
; 4634 : for (i = 0; i<52; i++)

  0348a	8b 74 24 24	 mov	 esi, DWORD PTR _i$[esp+4512]
  0348e	46		 inc	 esi
  0348f	89 74 24 24	 mov	 DWORD PTR _i$[esp+4512], esi
  03493	83 fe 34	 cmp	 esi, 52			; 00000034H
  03496	0f 8c 34 ff ff
	ff		 jl	 $LN215@main

; 4630 :     for (Bozan=0; Bozan < (1<<8); Bozan++) // 16 times, at end >>4

  0349c	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  034a0	40		 inc	 eax
  034a1	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  034a5	3d 00 01 00 00	 cmp	 eax, 256		; 00000100H
  034aa	0f 8c 10 ff ff
	ff		 jl	 $LL218@main

; 4645 :                        }
; 4646 :    }
; 4647 : }
; 4648 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  034b0	e8 00 00 00 00	 call	 _clock
  034b5	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  034ba	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  034c0	89 44 24 14	 mov	 DWORD PTR tv7847[esp+4512], eax
  034c4	db 44 24 14	 fild	 DWORD PTR tv7847[esp+4512]
  034c8	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  034ce	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4649 : //printf( "Railgun_6pp_hits/Railgun_6pp_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);
; 4650 : printf( "Railgun_Quadruplet_7 52 i.e. average performance: %luKB/clock\n", ((unsigned long long)ReallyTraversed/((long)(TotalRoughSearchTime)))>>10);

  034d4	e8 00 00 00 00	 call	 __ftol2_sse
  034d9	8b 7c 24 3c	 mov	 edi, DWORD PTR _ReallyTraversed$[esp+4516]
  034dd	8b 74 24 38	 mov	 esi, DWORD PTR _ReallyTraversed$[esp+4512]
  034e1	99		 cdq
  034e2	52		 push	 edx
  034e3	50		 push	 eax
  034e4	57		 push	 edi
  034e5	56		 push	 esi
  034e6	e8 00 00 00 00	 call	 __aulldiv
  034eb	0f ac d0 0a	 shrd	 eax, edx, 10
  034ef	c1 ea 0a	 shr	 edx, 10			; 0000000aH
  034f2	52		 push	 edx
  034f3	50		 push	 eax
  034f4	68 00 00 00 00	 push	 OFFSET $SG6601
  034f9	e8 00 00 00 00	 call	 _printf
  034fe	83 c4 0c	 add	 esp, 12			; 0000000cH

; 4651 : printf( "TotalRoughSearchTime: %s clocks\n", _ui64toaKAZEcomma(TotalRoughSearchTime, llTOaDigits, 10));

  03501	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  03507	8d 94 24 94 09
	00 00		 lea	 edx, DWORD PTR _llTOaDigits$[esp+4512]
  0350e	6a 0a		 push	 10			; 0000000aH
  03510	52		 push	 edx
  03511	e8 00 00 00 00	 call	 __ftol2
  03516	52		 push	 edx
  03517	50		 push	 eax
  03518	e8 00 00 00 00	 call	 __ui64toaKAZEcomma
  0351d	50		 push	 eax
  0351e	68 00 00 00 00	 push	 OFFSET $SG6602
  03523	e8 00 00 00 00	 call	 _printf

; 4652 : printf( "ReallyTraversed: %s bytes\n", _ui64toaKAZEcomma(ReallyTraversed, llTOaDigits, 10));

  03528	6a 0a		 push	 10			; 0000000aH
  0352a	8d 84 24 b0 09
	00 00		 lea	 eax, DWORD PTR _llTOaDigits$[esp+4540]
  03531	50		 push	 eax
  03532	57		 push	 edi
  03533	56		 push	 esi
  03534	e8 00 00 00 00	 call	 __ui64toaKAZEcomma
  03539	50		 push	 eax
  0353a	68 00 00 00 00	 push	 OFFSET $SG6603
  0353f	e8 00 00 00 00	 call	 _printf

; 4653 : // As one line: ]
; 4654 : 
; 4655 : 
; 4656 : // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
; 4657 : // NEW TEST APPROACH HERE - the old BMH loop of Railgun_Quadruplet_6pp is 67 bytes long whereas the new Railgun_Quadruplet_7mm has 61 i.e. under 64. ]
; 4658 : 
; 4659 : 
; 4660 : 
; 4661 : 
; 4662 : 
; 4663 : 
; 4664 : 
; 4665 : 
; 4666 : 
; 4667 : 
; 4668 : // As one line: [
; 4669 : printf( "\nDoing Search for 8x2 Patterns into String(%dbytes) as-one-line ...\n", Strnglen);

  03544	8b fb		 mov	 edi, ebx
  03546	57		 push	 edi
  03547	68 00 00 00 00	 push	 OFFSET $SG6604
  0354c	e8 00 00 00 00	 call	 _printf
  03551	83 c4 38	 add	 esp, 56			; 00000038H

; 4670 : clocks1 = clock();

  03554	e8 00 00 00 00	 call	 _clock

; 4671 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  03559	8b 5c 24 28	 mov	 ebx, DWORD PTR _Strng$[esp+4512]
  0355d	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax
  03562	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
  0356a	8d 9b 00 00 00
	00		 npad	 6
$LL207@main:

; 4672 : {
; 4673 : //Search area is between Strng[0] .. Strng[n-1]
; 4674 : 
; 4675 : for (i = 0; i<8; i++)

  03570	c7 44 24 24 00
	00 00 00	 mov	 DWORD PTR _i$[esp+4512], 0
  03578	eb 06 8d 9b 00
	00 00 00	 npad	 8
$LL204@main:

; 4676 :    {
; 4677 : Railgunhits=0;

  03580	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _Railgunhits, 0

; 4678 : clocks3 = clock();

  0358a	e8 00 00 00 00	 call	 _clock

; 4679 : 	dummy = HORSPOOL_hits(&Strng[0], DumboBox[i][0], Strnglen, strlen(DumboBox[i][0]));

  0358f	8b 4c 24 24	 mov	 ecx, DWORD PTR _i$[esp+4512]
  03593	8b b4 cc 80 00
	00 00		 mov	 esi, DWORD PTR _DumboBox$[esp+ecx*8+4512]
  0359a	a3 00 00 00 00	 mov	 DWORD PTR _clocks3, eax
  0359f	8b c6		 mov	 eax, esi
  035a1	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
$LL930@main:
  035a4	8a 08		 mov	 cl, BYTE PTR [eax]
  035a6	40		 inc	 eax
  035a7	84 c9		 test	 cl, cl
  035a9	75 f9		 jne	 SHORT $LL930@main
  035ab	2b c2		 sub	 eax, edx
  035ad	50		 push	 eax
  035ae	57		 push	 edi
  035af	56		 push	 esi
  035b0	53		 push	 ebx
  035b1	e8 00 00 00 00	 call	 _HORSPOOL_hits
  035b6	83 c4 10	 add	 esp, 16			; 00000010H

; 4680 : clocks4 = clock();

  035b9	e8 00 00 00 00	 call	 _clock

; 4681 : if (Bozan == (1<<4)-1) { TotalRoughSearchTime = clocks4 - clocks3; TotalRoughSearchTime++;

  035be	83 7c 24 18 0f	 cmp	 DWORD PTR _Bozan$[esp+4512], 15 ; 0000000fH
  035c3	a3 00 00 00 00	 mov	 DWORD PTR _clocks4, eax
  035c8	75 3f		 jne	 SHORT $LN201@main
  035ca	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  035d0	89 44 24 14	 mov	 DWORD PTR tv7777[esp+4512], eax
  035d4	db 44 24 14	 fild	 DWORD PTR tv7777[esp+4512]
  035d8	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  035de	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4682 :                          printf( "Found ('%s') %d time(s), BM_HORSPOOL performance: %luKB/clock\n", DumboBox[i][0], Railgunhits, (Strnglen/((long)(TotalRoughSearchTime)))>>10);

  035e4	e8 00 00 00 00	 call	 __ftol2_sse
  035e9	8b c8		 mov	 ecx, eax
  035eb	8b c7		 mov	 eax, edi
  035ed	99		 cdq
  035ee	f7 f9		 idiv	 ecx
  035f0	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _Railgunhits
  035f6	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  035f9	50		 push	 eax
  035fa	52		 push	 edx
  035fb	56		 push	 esi
  035fc	68 00 00 00 00	 push	 OFFSET $SG6613
  03601	e8 00 00 00 00	 call	 _printf
  03606	83 c4 10	 add	 esp, 16			; 00000010H
$LN201@main:

; 4683 :                        }
; 4684 : Railgunhits=0;

  03609	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _Railgunhits, 0

; 4685 : clocks3 = clock();

  03613	e8 00 00 00 00	 call	 _clock
  03618	a3 00 00 00 00	 mov	 DWORD PTR _clocks3, eax

; 4686 : 	dummy = HORSPOOL_hits(&Strng[0], DumboBox[i][1], Strnglen, strlen(DumboBox[i][1]));

  0361d	8b 44 24 24	 mov	 eax, DWORD PTR _i$[esp+4512]
  03621	8b b4 c4 84 00
	00 00		 mov	 esi, DWORD PTR _DumboBox$[esp+eax*8+4516]
  03628	8b c6		 mov	 eax, esi
  0362a	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
  0362d	8d 49 00	 npad	 3
$LL931@main:
  03630	8a 08		 mov	 cl, BYTE PTR [eax]
  03632	40		 inc	 eax
  03633	84 c9		 test	 cl, cl
  03635	75 f9		 jne	 SHORT $LL931@main
  03637	2b c2		 sub	 eax, edx
  03639	50		 push	 eax
  0363a	57		 push	 edi
  0363b	56		 push	 esi
  0363c	53		 push	 ebx
  0363d	e8 00 00 00 00	 call	 _HORSPOOL_hits
  03642	83 c4 10	 add	 esp, 16			; 00000010H

; 4687 : clocks4 = clock();

  03645	e8 00 00 00 00	 call	 _clock

; 4688 : if (Bozan == (1<<4)-1) { TotalRoughSearchTime = clocks4 - clocks3; TotalRoughSearchTime++;

  0364a	83 7c 24 18 0f	 cmp	 DWORD PTR _Bozan$[esp+4512], 15 ; 0000000fH
  0364f	a3 00 00 00 00	 mov	 DWORD PTR _clocks4, eax
  03654	75 3f		 jne	 SHORT $LN203@main
  03656	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  0365c	89 44 24 14	 mov	 DWORD PTR tv7753[esp+4512], eax
  03660	db 44 24 14	 fild	 DWORD PTR tv7753[esp+4512]
  03664	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  0366a	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4689 :                          printf( "Found ('%s') %d time(s), BM_HORSPOOL performance: %luKB/clock\n", DumboBox[i][1], Railgunhits, (Strnglen/((long)(TotalRoughSearchTime)))>>10);

  03670	e8 00 00 00 00	 call	 __ftol2_sse
  03675	8b c8		 mov	 ecx, eax
  03677	8b c7		 mov	 eax, edi
  03679	99		 cdq
  0367a	f7 f9		 idiv	 ecx
  0367c	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _Railgunhits
  03682	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  03685	50		 push	 eax
  03686	52		 push	 edx
  03687	56		 push	 esi
  03688	68 00 00 00 00	 push	 OFFSET $SG6616
  0368d	e8 00 00 00 00	 call	 _printf
  03692	83 c4 10	 add	 esp, 16			; 00000010H
$LN203@main:

; 4672 : {
; 4673 : //Search area is between Strng[0] .. Strng[n-1]
; 4674 : 
; 4675 : for (i = 0; i<8; i++)

  03695	8b 44 24 24	 mov	 eax, DWORD PTR _i$[esp+4512]
  03699	40		 inc	 eax
  0369a	89 44 24 24	 mov	 DWORD PTR _i$[esp+4512], eax
  0369e	83 f8 08	 cmp	 eax, 8
  036a1	0f 8c d9 fe ff
	ff		 jl	 $LL204@main

; 4671 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  036a7	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  036ab	40		 inc	 eax
  036ac	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  036b0	83 f8 10	 cmp	 eax, 16			; 00000010H
  036b3	0f 8c b7 fe ff
	ff		 jl	 $LL207@main

; 4690 :                        }
; 4691 :    }
; 4692 : }
; 4693 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  036b9	e8 00 00 00 00	 call	 _clock
  036be	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  036c3	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  036c9	89 44 24 14	 mov	 DWORD PTR tv7741[esp+4512], eax
  036cd	db 44 24 14	 fild	 DWORD PTR tv7741[esp+4512]

; 4694 : //printf( "BM_HORSPOOL_hits/BM_HORSPOOL_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);
; 4695 : printf( "BM_HORSPOOL 8x2 i.e. average performance: %luKB/clock\n", ((unsigned long long)8*2*Strnglen/((long)(TotalRoughSearchTime)>>4))>>10);

  036d1	8b c7		 mov	 eax, edi
  036d3	99		 cdq
  036d4	8b f0		 mov	 esi, eax
  036d6	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  036dc	0f a4 f2 04	 shld	 edx, esi, 4
  036e0	c1 e6 04	 shl	 esi, 4
  036e3	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime
  036e9	89 54 24 3c	 mov	 DWORD PTR tv4934[esp+4516], edx
  036ed	89 74 24 38	 mov	 DWORD PTR tv4934[esp+4512], esi
  036f1	e8 00 00 00 00	 call	 __ftol2_sse
  036f6	c1 f8 04	 sar	 eax, 4
  036f9	99		 cdq
  036fa	52		 push	 edx
  036fb	50		 push	 eax
  036fc	8b 44 24 44	 mov	 eax, DWORD PTR tv4934[esp+4524]
  03700	50		 push	 eax
  03701	56		 push	 esi
  03702	e8 00 00 00 00	 call	 __aulldiv
  03707	0f ac d0 0a	 shrd	 eax, edx, 10
  0370b	c1 ea 0a	 shr	 edx, 10			; 0000000aH
  0370e	52		 push	 edx
  0370f	50		 push	 eax
  03710	68 00 00 00 00	 push	 OFFSET $SG6619
  03715	e8 00 00 00 00	 call	 _printf

; 4696 : // As one line: ]
; 4697 : 
; 4698 : 
; 4699 : /*
; 4700 : // As one line: [
; 4701 : printf( "\nDoing Search for 8x2 Patterns into String(%dbytes) as-one-line ...\n", Strnglen);
; 4702 : clocks1 = clock();
; 4703 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4
; 4704 : {
; 4705 : //Search area is between Strng[0] .. Strng[n-1]
; 4706 : 
; 4707 : for (i = 0; i<8; i++)
; 4708 :    {
; 4709 : Railgunhits=0;
; 4710 : clocks3 = clock();
; 4711 : 	FoundInPTR = TW(&Strng[0], Strnglen, DumboBox[i][0], strlen(DumboBox[i][0]));
; 4712 : clocks4 = clock();
; 4713 : if (Bozan == (1<<4)-1) { TotalRoughSearchTime = clocks4 - clocks3; TotalRoughSearchTime++;
; 4714 :                          printf( "Found ('%s') %d time(s), TW performance: %luKB/clock\n", DumboBox[i][0], Railgunhits, (Strnglen/((long)(TotalRoughSearchTime)))>>10);
; 4715 :                        }
; 4716 : Railgunhits=0;
; 4717 : clocks3 = clock();
; 4718 : 	FoundInPTR = TW(&Strng[0], Strnglen, DumboBox[i][1], strlen(DumboBox[i][1]));
; 4719 : clocks4 = clock();
; 4720 : if (Bozan == (1<<4)-1) { TotalRoughSearchTime = clocks4 - clocks3; TotalRoughSearchTime++;
; 4721 :                          printf( "Found ('%s') %d time(s), TW performance: %luKB/clock\n", DumboBox[i][1], Railgunhits, (Strnglen/((long)(TotalRoughSearchTime)))>>10);
; 4722 :                        }
; 4723 :    }
; 4724 : }
; 4725 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;
; 4726 : //printf( "Two-way_hits/Two-way_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);
; 4727 : printf( "TW 8x2 i.e. average performance: %luKB/clock\n", ((unsigned long long)8*2*Strnglen/((long)(TotalRoughSearchTime)>>4))>>10);
; 4728 : // As one line: ]
; 4729 : */
; 4730 : 
; 4731 : 
; 4732 : 
; 4733 : 
; 4734 : // As one line: [
; 4735 : printf( "\nDoing Search for 8x2 Patterns into String(%dbytes) as-one-line ...\n", Strnglen);

  0371a	57		 push	 edi
  0371b	68 00 00 00 00	 push	 OFFSET $SG6620
  03720	e8 00 00 00 00	 call	 _printf
  03725	83 c4 14	 add	 esp, 20			; 00000014H

; 4736 : clocks1 = clock();

  03728	e8 00 00 00 00	 call	 _clock
  0372d	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 4737 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  03732	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
  0373a	8d 9b 00 00 00
	00		 npad	 6
$LL199@main:

; 4738 : {
; 4739 : //Search area is between Strng[0] .. Strng[n-1]
; 4740 : 
; 4741 : for (i = 0; i<8; i++)

  03740	c7 44 24 24 00
	00 00 00	 mov	 DWORD PTR _i$[esp+4512], 0
  03748	eb 06 8d 9b 00
	00 00 00	 npad	 8
$LL196@main:

; 4742 :    {
; 4743 : Railgunhits=0;

  03750	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _Railgunhits, 0

; 4744 : clocks3 = clock();

  0375a	e8 00 00 00 00	 call	 _clock

; 4745 : 	FoundInPTR = Railgun_Quadruplet_6pp_count_hits(&Strng[0], DumboBox[i][0], Strnglen, strlen(DumboBox[i][0]));

  0375f	8b 4c 24 24	 mov	 ecx, DWORD PTR _i$[esp+4512]
  03763	8b b4 cc 80 00
	00 00		 mov	 esi, DWORD PTR _DumboBox$[esp+ecx*8+4512]
  0376a	a3 00 00 00 00	 mov	 DWORD PTR _clocks3, eax
  0376f	8b c6		 mov	 eax, esi
  03771	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
$LL932@main:
  03774	8a 08		 mov	 cl, BYTE PTR [eax]
  03776	40		 inc	 eax
  03777	84 c9		 test	 cl, cl
  03779	75 f9		 jne	 SHORT $LL932@main
  0377b	2b c2		 sub	 eax, edx
  0377d	50		 push	 eax
  0377e	57		 push	 edi
  0377f	56		 push	 esi
  03780	53		 push	 ebx
  03781	e8 00 00 00 00	 call	 _Railgun_Quadruplet_6pp_count_hits
  03786	83 c4 10	 add	 esp, 16			; 00000010H

; 4746 : clocks4 = clock();

  03789	e8 00 00 00 00	 call	 _clock

; 4747 : if (Bozan == (1<<4)-1) { TotalRoughSearchTime = clocks4 - clocks3; TotalRoughSearchTime++;

  0378e	83 7c 24 18 0f	 cmp	 DWORD PTR _Bozan$[esp+4512], 15 ; 0000000fH
  03793	a3 00 00 00 00	 mov	 DWORD PTR _clocks4, eax
  03798	75 3f		 jne	 SHORT $LN193@main
  0379a	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  037a0	89 44 24 14	 mov	 DWORD PTR tv7678[esp+4512], eax
  037a4	db 44 24 14	 fild	 DWORD PTR tv7678[esp+4512]
  037a8	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  037ae	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4748 :                          printf( "Found ('%s') %d time(s), Railgun_6pp performance: %luKB/clock\n", DumboBox[i][0], Railgunhits, (Strnglen/((long)(TotalRoughSearchTime)))>>10);

  037b4	e8 00 00 00 00	 call	 __ftol2_sse
  037b9	8b c8		 mov	 ecx, eax
  037bb	8b c7		 mov	 eax, edi
  037bd	99		 cdq
  037be	f7 f9		 idiv	 ecx
  037c0	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _Railgunhits
  037c6	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  037c9	50		 push	 eax
  037ca	52		 push	 edx
  037cb	56		 push	 esi
  037cc	68 00 00 00 00	 push	 OFFSET $SG6629
  037d1	e8 00 00 00 00	 call	 _printf
  037d6	83 c4 10	 add	 esp, 16			; 00000010H
$LN193@main:

; 4749 :                        }
; 4750 : Railgunhits=0;

  037d9	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _Railgunhits, 0

; 4751 : clocks3 = clock();

  037e3	e8 00 00 00 00	 call	 _clock
  037e8	a3 00 00 00 00	 mov	 DWORD PTR _clocks3, eax

; 4752 : 	FoundInPTR = Railgun_Quadruplet_6pp_count_hits(&Strng[0], DumboBox[i][1], Strnglen, strlen(DumboBox[i][1]));

  037ed	8b 44 24 24	 mov	 eax, DWORD PTR _i$[esp+4512]
  037f1	8b b4 c4 84 00
	00 00		 mov	 esi, DWORD PTR _DumboBox$[esp+eax*8+4516]
  037f8	8b c6		 mov	 eax, esi
  037fa	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
  037fd	8d 49 00	 npad	 3
$LL933@main:
  03800	8a 08		 mov	 cl, BYTE PTR [eax]
  03802	40		 inc	 eax
  03803	84 c9		 test	 cl, cl
  03805	75 f9		 jne	 SHORT $LL933@main
  03807	2b c2		 sub	 eax, edx
  03809	50		 push	 eax
  0380a	57		 push	 edi
  0380b	56		 push	 esi
  0380c	53		 push	 ebx
  0380d	e8 00 00 00 00	 call	 _Railgun_Quadruplet_6pp_count_hits
  03812	83 c4 10	 add	 esp, 16			; 00000010H

; 4753 : clocks4 = clock();

  03815	e8 00 00 00 00	 call	 _clock

; 4754 : if (Bozan == (1<<4)-1) { TotalRoughSearchTime = clocks4 - clocks3; TotalRoughSearchTime++;

  0381a	83 7c 24 18 0f	 cmp	 DWORD PTR _Bozan$[esp+4512], 15 ; 0000000fH
  0381f	a3 00 00 00 00	 mov	 DWORD PTR _clocks4, eax
  03824	75 3f		 jne	 SHORT $LN195@main
  03826	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  0382c	89 44 24 14	 mov	 DWORD PTR tv7652[esp+4512], eax
  03830	db 44 24 14	 fild	 DWORD PTR tv7652[esp+4512]
  03834	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  0383a	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4755 :                          printf( "Found ('%s') %d time(s), Railgun_6pp performance: %luKB/clock\n", DumboBox[i][1], Railgunhits, (Strnglen/((long)(TotalRoughSearchTime)))>>10);

  03840	e8 00 00 00 00	 call	 __ftol2_sse
  03845	8b c8		 mov	 ecx, eax
  03847	8b c7		 mov	 eax, edi
  03849	99		 cdq
  0384a	f7 f9		 idiv	 ecx
  0384c	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _Railgunhits
  03852	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  03855	50		 push	 eax
  03856	52		 push	 edx
  03857	56		 push	 esi
  03858	68 00 00 00 00	 push	 OFFSET $SG6632
  0385d	e8 00 00 00 00	 call	 _printf
  03862	83 c4 10	 add	 esp, 16			; 00000010H
$LN195@main:

; 4738 : {
; 4739 : //Search area is between Strng[0] .. Strng[n-1]
; 4740 : 
; 4741 : for (i = 0; i<8; i++)

  03865	8b 44 24 24	 mov	 eax, DWORD PTR _i$[esp+4512]
  03869	40		 inc	 eax
  0386a	89 44 24 24	 mov	 DWORD PTR _i$[esp+4512], eax
  0386e	83 f8 08	 cmp	 eax, 8
  03871	0f 8c d9 fe ff
	ff		 jl	 $LL196@main

; 4737 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  03877	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  0387b	40		 inc	 eax
  0387c	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  03880	83 f8 10	 cmp	 eax, 16			; 00000010H
  03883	0f 8c b7 fe ff
	ff		 jl	 $LL199@main

; 4756 :                        }
; 4757 :    }
; 4758 : }
; 4759 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  03889	e8 00 00 00 00	 call	 _clock
  0388e	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  03893	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  03899	89 44 24 14	 mov	 DWORD PTR tv7639[esp+4512], eax
  0389d	db 44 24 14	 fild	 DWORD PTR tv7639[esp+4512]
  038a1	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  038a7	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4760 : //printf( "Railgun_6pp_hits/Railgun_6pp_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);
; 4761 : printf( "Railgun_6pp 8x2 i.e. average performance: %luKB/clock\n", ((unsigned long long)8*2*Strnglen/((long)(TotalRoughSearchTime)>>4))>>10);

  038ad	e8 00 00 00 00	 call	 __ftol2_sse
  038b2	8b 4c 24 38	 mov	 ecx, DWORD PTR tv4934[esp+4512]
  038b6	c1 f8 04	 sar	 eax, 4
  038b9	99		 cdq
  038ba	52		 push	 edx
  038bb	50		 push	 eax
  038bc	8b 44 24 44	 mov	 eax, DWORD PTR tv4934[esp+4524]
  038c0	50		 push	 eax
  038c1	51		 push	 ecx
  038c2	e8 00 00 00 00	 call	 __aulldiv
  038c7	0f ac d0 0a	 shrd	 eax, edx, 10
  038cb	c1 ea 0a	 shr	 edx, 10			; 0000000aH
  038ce	52		 push	 edx
  038cf	50		 push	 eax
  038d0	68 00 00 00 00	 push	 OFFSET $SG6635
  038d5	e8 00 00 00 00	 call	 _printf

; 4762 : // As one line: ]
; 4763 : 
; 4764 : 
; 4765 : 
; 4766 : // As one line: [
; 4767 : printf( "\nDoing Search for 8x2 Patterns into String(%dbytes) as-one-line ...\n", Strnglen);

  038da	57		 push	 edi
  038db	68 00 00 00 00	 push	 OFFSET $SG6636
  038e0	e8 00 00 00 00	 call	 _printf
  038e5	83 c4 14	 add	 esp, 20			; 00000014H

; 4768 : clocks1 = clock();

  038e8	e8 00 00 00 00	 call	 _clock
  038ed	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 4769 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  038f2	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
  038fa	8d 9b 00 00 00
	00		 npad	 6
$LL191@main:

; 4770 : {
; 4771 : //Search area is between Strng[0] .. Strng[n-1]
; 4772 : 
; 4773 : for (i = 0; i<8; i++)

  03900	c7 44 24 24 00
	00 00 00	 mov	 DWORD PTR _i$[esp+4512], 0
  03908	eb 06 8d 9b 00
	00 00 00	 npad	 8
$LL188@main:

; 4774 :    {
; 4775 : Railgunhits=0;

  03910	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _Railgunhits, 0

; 4776 : clocks3 = clock();

  0391a	e8 00 00 00 00	 call	 _clock

; 4777 : 	FoundInPTR = Railgun_Quadruplet_7_count_hits(&Strng[0], DumboBox[i][0], Strnglen, strlen(DumboBox[i][0]));

  0391f	8b 54 24 24	 mov	 edx, DWORD PTR _i$[esp+4512]
  03923	8b b4 d4 80 00
	00 00		 mov	 esi, DWORD PTR _DumboBox$[esp+edx*8+4512]
  0392a	a3 00 00 00 00	 mov	 DWORD PTR _clocks3, eax
  0392f	8b c6		 mov	 eax, esi
  03931	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
$LL934@main:
  03934	8a 08		 mov	 cl, BYTE PTR [eax]
  03936	40		 inc	 eax
  03937	84 c9		 test	 cl, cl
  03939	75 f9		 jne	 SHORT $LL934@main
  0393b	2b c2		 sub	 eax, edx
  0393d	50		 push	 eax
  0393e	57		 push	 edi
  0393f	56		 push	 esi
  03940	53		 push	 ebx
  03941	e8 00 00 00 00	 call	 _Railgun_Quadruplet_7_count_hits
  03946	83 c4 10	 add	 esp, 16			; 00000010H

; 4778 : clocks4 = clock();

  03949	e8 00 00 00 00	 call	 _clock

; 4779 : if (Bozan == (1<<4)-1) { TotalRoughSearchTime = clocks4 - clocks3; TotalRoughSearchTime++;

  0394e	83 7c 24 18 0f	 cmp	 DWORD PTR _Bozan$[esp+4512], 15 ; 0000000fH
  03953	a3 00 00 00 00	 mov	 DWORD PTR _clocks4, eax
  03958	75 3f		 jne	 SHORT $LN185@main
  0395a	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  03960	89 44 24 14	 mov	 DWORD PTR tv7590[esp+4512], eax
  03964	db 44 24 14	 fild	 DWORD PTR tv7590[esp+4512]
  03968	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  0396e	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4780 :                          printf( "Found ('%s') %d time(s), Railgun_Quadruplet_7 performance: %luKB/clock\n", DumboBox[i][0], Railgunhits, (Strnglen/((long)(TotalRoughSearchTime)))>>10);

  03974	e8 00 00 00 00	 call	 __ftol2_sse
  03979	8b c8		 mov	 ecx, eax
  0397b	8b c7		 mov	 eax, edi
  0397d	99		 cdq
  0397e	f7 f9		 idiv	 ecx
  03980	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _Railgunhits
  03986	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  03989	50		 push	 eax
  0398a	52		 push	 edx
  0398b	56		 push	 esi
  0398c	68 00 00 00 00	 push	 OFFSET $SG6645
  03991	e8 00 00 00 00	 call	 _printf
  03996	83 c4 10	 add	 esp, 16			; 00000010H
$LN185@main:

; 4781 :                        }
; 4782 : Railgunhits=0;

  03999	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _Railgunhits, 0

; 4783 : clocks3 = clock();

  039a3	e8 00 00 00 00	 call	 _clock
  039a8	a3 00 00 00 00	 mov	 DWORD PTR _clocks3, eax

; 4784 : 	FoundInPTR = Railgun_Quadruplet_7_count_hits(&Strng[0], DumboBox[i][1], Strnglen, strlen(DumboBox[i][1]));

  039ad	8b 44 24 24	 mov	 eax, DWORD PTR _i$[esp+4512]
  039b1	8b b4 c4 84 00
	00 00		 mov	 esi, DWORD PTR _DumboBox$[esp+eax*8+4516]
  039b8	8b c6		 mov	 eax, esi
  039ba	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
  039bd	8d 49 00	 npad	 3
$LL935@main:
  039c0	8a 08		 mov	 cl, BYTE PTR [eax]
  039c2	40		 inc	 eax
  039c3	84 c9		 test	 cl, cl
  039c5	75 f9		 jne	 SHORT $LL935@main
  039c7	2b c2		 sub	 eax, edx
  039c9	50		 push	 eax
  039ca	57		 push	 edi
  039cb	56		 push	 esi
  039cc	53		 push	 ebx
  039cd	e8 00 00 00 00	 call	 _Railgun_Quadruplet_7_count_hits
  039d2	83 c4 10	 add	 esp, 16			; 00000010H

; 4785 : clocks4 = clock();

  039d5	e8 00 00 00 00	 call	 _clock

; 4786 : if (Bozan == (1<<4)-1) { TotalRoughSearchTime = clocks4 - clocks3; TotalRoughSearchTime++;

  039da	83 7c 24 18 0f	 cmp	 DWORD PTR _Bozan$[esp+4512], 15 ; 0000000fH
  039df	a3 00 00 00 00	 mov	 DWORD PTR _clocks4, eax
  039e4	75 3f		 jne	 SHORT $LN187@main
  039e6	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks3
  039ec	89 44 24 14	 mov	 DWORD PTR tv7566[esp+4512], eax
  039f0	db 44 24 14	 fild	 DWORD PTR tv7566[esp+4512]
  039f4	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  039fa	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4787 :                          printf( "Found ('%s') %d time(s), Railgun_Quadruplet_7 performance: %luKB/clock\n", DumboBox[i][1], Railgunhits, (Strnglen/((long)(TotalRoughSearchTime)))>>10);

  03a00	e8 00 00 00 00	 call	 __ftol2_sse
  03a05	8b c8		 mov	 ecx, eax
  03a07	8b c7		 mov	 eax, edi
  03a09	99		 cdq
  03a0a	f7 f9		 idiv	 ecx
  03a0c	8b 15 00 00 00
	00		 mov	 edx, DWORD PTR _Railgunhits
  03a12	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  03a15	50		 push	 eax
  03a16	52		 push	 edx
  03a17	56		 push	 esi
  03a18	68 00 00 00 00	 push	 OFFSET $SG6648
  03a1d	e8 00 00 00 00	 call	 _printf
  03a22	83 c4 10	 add	 esp, 16			; 00000010H
$LN187@main:

; 4770 : {
; 4771 : //Search area is between Strng[0] .. Strng[n-1]
; 4772 : 
; 4773 : for (i = 0; i<8; i++)

  03a25	8b 44 24 24	 mov	 eax, DWORD PTR _i$[esp+4512]
  03a29	40		 inc	 eax
  03a2a	89 44 24 24	 mov	 DWORD PTR _i$[esp+4512], eax
  03a2e	83 f8 08	 cmp	 eax, 8
  03a31	0f 8c d9 fe ff
	ff		 jl	 $LL188@main

; 4769 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  03a37	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  03a3b	40		 inc	 eax
  03a3c	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  03a40	83 f8 10	 cmp	 eax, 16			; 00000010H
  03a43	0f 8c b7 fe ff
	ff		 jl	 $LL191@main

; 4788 :                        }
; 4789 :    }
; 4790 : }
; 4791 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  03a49	e8 00 00 00 00	 call	 _clock
  03a4e	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  03a53	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  03a59	89 44 24 14	 mov	 DWORD PTR tv7554[esp+4512], eax
  03a5d	db 44 24 14	 fild	 DWORD PTR tv7554[esp+4512]
  03a61	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  03a67	dd 15 00 00 00
	00		 fst	 QWORD PTR _TotalRoughSearchTime

; 4792 : //printf( "Railgun_6pp_hits/Railgun_6pp_clocks: %lu/%lu\n", Railgunhits>>4, (long)(TotalRoughSearchTime)>>4);
; 4793 : printf( "Railgun_Quadruplet_7 8x2 i.e. average performance: %luKB/clock\n", ((unsigned long long)8*2*Strnglen/((long)(TotalRoughSearchTime)>>4))>>10);

  03a6d	e8 00 00 00 00	 call	 __ftol2_sse
  03a72	8b 4c 24 38	 mov	 ecx, DWORD PTR tv4934[esp+4512]
  03a76	c1 f8 04	 sar	 eax, 4
  03a79	99		 cdq
  03a7a	52		 push	 edx
  03a7b	50		 push	 eax
  03a7c	8b 44 24 44	 mov	 eax, DWORD PTR tv4934[esp+4524]
  03a80	50		 push	 eax
  03a81	51		 push	 ecx
  03a82	e8 00 00 00 00	 call	 __aulldiv
  03a87	0f ac d0 0a	 shrd	 eax, edx, 10
  03a8b	c1 ea 0a	 shr	 edx, 10			; 0000000aH
  03a8e	52		 push	 edx
  03a8f	50		 push	 eax
  03a90	68 00 00 00 00	 push	 OFFSET $SG6651
  03a95	e8 00 00 00 00	 call	 _printf
  03a9a	83 c4 0c	 add	 esp, 12			; 0000000cH

; 4794 : // As one line: ]
; 4795 : 
; 4796 : 
; 4797 : 
; 4798 : 
; 4799 : 
; 4800 : 
; 4801 : if (argc==1) {

  03a9d	83 7d 08 01	 cmp	 DWORD PTR _argc$[ebp], 1
  03aa1	0f 85 04 1a 00
	00		 jne	 $LN59@main

; 4802 : 
; 4803 : printf( "\nDoing Search for Pattern(%dbytes) into String(%dbytes) line-by-line ...\n", Patternlen, Strnglen);

  03aa7	8b 54 24 2c	 mov	 edx, DWORD PTR _Patternlen$[esp+4512]
  03aab	57		 push	 edi
  03aac	52		 push	 edx
  03aad	68 00 00 00 00	 push	 OFFSET $SG6653
  03ab2	e8 00 00 00 00	 call	 _printf
  03ab7	83 c4 0c	 add	 esp, 12			; 0000000cH

; 4804 : 
; 4805 : // 7[
; 4806 : clocks1 = clock();

  03aba	e8 00 00 00 00	 call	 _clock
  03abf	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 4807 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  03ac4	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
  03acc	8d 47 ff	 lea	 eax, DWORD PTR [edi-1]

; 4817 : 	LinesEncountered++;

  03acf	8b cb		 mov	 ecx, ebx
$LN182@main:

; 4808 : {
; 4809 : //Search area is between Strng[0] .. Strng[n-1]
; 4810 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real
; 4811 : ThunderwithL=0;ThunderwithR=0;

  03ad1	33 db		 xor	 ebx, ebx
  03ad3	33 d2		 xor	 edx, edx
  03ad5	89 5c 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], ebx
  03ad9	89 54 24 30	 mov	 DWORD PTR _ThunderwithL$[esp+4512], edx
  03add	89 5c 24 20	 mov	 DWORD PTR _ThunderwithR$[esp+4512], ebx
$LL179@main:

; 4812 : 	for (;;)
; 4813 : 	{
; 4814 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  03ae1	80 3c 0b 0a	 cmp	 BYTE PTR [ebx+ecx], 10	; 0000000aH
  03ae5	74 0f		 je	 SHORT $LN176@main
$LL177@main:
  03ae7	3b d8		 cmp	 ebx, eax
  03ae9	7d 07		 jge	 SHORT $LN1054@main
  03aeb	43		 inc	 ebx
  03aec	80 3c 0b 0a	 cmp	 BYTE PTR [ebx+ecx], 10	; 0000000aH
  03af0	75 f5		 jne	 SHORT $LL177@main
$LN1054@main:
  03af2	89 5c 24 20	 mov	 DWORD PTR _ThunderwithR$[esp+4512], ebx
$LN176@main:

; 4815 : 	FoundInPTR = strstr_Microsoft(&Strng[ThunderwithL], &Pattern[0]);

  03af6	80 bc 24 b0 09
	00 00 00	 cmp	 BYTE PTR _Pattern$[esp+4512], 0
  03afe	8d 34 0a	 lea	 esi, DWORD PTR [edx+ecx]
  03b01	0f 84 9e 01 00
	00		 je	 $LN1097@main
  03b07	8a 0e		 mov	 cl, BYTE PTR [esi]
  03b09	84 c9		 test	 cl, cl
  03b0b	74 5c		 je	 SHORT $LN1016@main
  03b0d	8b d6		 mov	 edx, esi
  03b0f	8d 84 24 b0 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4512]
  03b16	2b d0		 sub	 edx, eax
  03b18	eb 06 8d 9b 00
	00 00 00	 npad	 8
$LL424@main:
  03b20	8d 84 24 b0 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4512]
  03b27	84 c9		 test	 cl, cl
  03b29	74 28		 je	 SHORT $LN421@main
  03b2b	eb 07		 jmp	 SHORT $LN422@main
  03b2d	8d 49 00	 npad	 3
$LL1013@main:
  03b30	8b 5c 24 20	 mov	 ebx, DWORD PTR _ThunderwithR$[esp+4512]
$LN422@main:
  03b34	8a 08		 mov	 cl, BYTE PTR [eax]
  03b36	84 c9		 test	 cl, cl
  03b38	0f 84 5f 01 00
	00		 je	 $LN787@main
  03b3e	0f be 1c 02	 movsx	 ebx, BYTE PTR [edx+eax]
  03b42	0f be c9	 movsx	 ecx, cl
  03b45	2b d9		 sub	 ebx, ecx
  03b47	75 06		 jne	 SHORT $LN1015@main
  03b49	40		 inc	 eax
  03b4a	38 1c 02	 cmp	 BYTE PTR [edx+eax], bl
  03b4d	75 e1		 jne	 SHORT $LL1013@main
$LN1015@main:
  03b4f	8b 5c 24 20	 mov	 ebx, DWORD PTR _ThunderwithR$[esp+4512]
$LN421@main:
  03b53	80 38 00	 cmp	 BYTE PTR [eax], 0
  03b56	0f 84 41 01 00
	00		 je	 $LN787@main
  03b5c	8a 4e 01	 mov	 cl, BYTE PTR [esi+1]
  03b5f	46		 inc	 esi
  03b60	42		 inc	 edx
  03b61	84 c9		 test	 cl, cl
  03b63	75 bb		 jne	 SHORT $LL424@main

; 5222 : 	if (ThunderwithR >= Strnglen-1) break;

  03b65	8b 54 24 30	 mov	 edx, DWORD PTR _ThunderwithL$[esp+4512]
$LN1016@main:

; 4816 : 	if ( FoundInPTR != NULL) {strstrMicrosofthits++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  03b69	8b 4c 24 28	 mov	 ecx, DWORD PTR _Strng$[esp+4512]
$LN175@main:
  03b6d	8b c3		 mov	 eax, ebx
  03b6f	2b c2		 sub	 eax, edx
$LN1098@main:
  03b71	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax

; 4817 : 	LinesEncountered++;

  03b75	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]

; 4818 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;

  03b79	43		 inc	 ebx

; 4819 : 	if (ThunderwithR >= Strnglen-1) break;

  03b7a	8d 47 ff	 lea	 eax, DWORD PTR [edi-1]
  03b7d	8b d3		 mov	 edx, ebx
  03b7f	89 5c 24 20	 mov	 DWORD PTR _ThunderwithR$[esp+4512], ebx
  03b83	89 54 24 30	 mov	 DWORD PTR _ThunderwithL$[esp+4512], edx
  03b87	89 44 24 24	 mov	 DWORD PTR tv4941[esp+4512], eax
  03b8b	3b d8		 cmp	 ebx, eax
  03b8d	0f 8c 4e ff ff
	ff		 jl	 $LL179@main

; 4820 : 	}
; 4821 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  03b93	8b 54 24 18	 mov	 edx, DWORD PTR _Bozan$[esp+4512]
  03b97	83 fa 0f	 cmp	 edx, 15			; 0000000fH
  03b9a	74 08		 je	 SHORT $LN181@main
  03b9c	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN181@main:

; 4807 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  03ba4	42		 inc	 edx
  03ba5	89 54 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], edx
  03ba9	83 fa 10	 cmp	 edx, 16			; 00000010H
  03bac	0f 8c 1f ff ff
	ff		 jl	 $LN182@main

; 4822 : }
; 4823 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  03bb2	e8 00 00 00 00	 call	 _clock

; 4824 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  03bb7	8b 4c 24 1c	 mov	 ecx, DWORD PTR _LinesEncountered$[esp+4512]
  03bbb	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  03bc0	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  03bc6	51		 push	 ecx
  03bc7	89 44 24 18	 mov	 DWORD PTR tv7512[esp+4516], eax
  03bcb	db 44 24 18	 fild	 DWORD PTR tv7512[esp+4516]
  03bcf	68 00 00 00 00	 push	 OFFSET $SG6668
  03bd4	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  03bda	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  03be0	e8 00 00 00 00	 call	 _printf

; 4825 : printf( "strstr_Microsoft_hits/strstr_Microsoft_clocks: %lu/%lu\n", strstrMicrosofthits>>4, (long)(TotalRoughSearchTime)>>4);

  03be5	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  03beb	e8 00 00 00 00	 call	 __ftol2_sse
  03bf0	c1 f8 04	 sar	 eax, 4
  03bf3	50		 push	 eax
  03bf4	8b 44 24 78	 mov	 eax, DWORD PTR _strstrMicrosofthits$[esp+4524]
  03bf8	c1 f8 04	 sar	 eax, 4
  03bfb	50		 push	 eax
  03bfc	68 00 00 00 00	 push	 OFFSET $SG6670
  03c01	e8 00 00 00 00	 call	 _printf

; 4826 : printf( "strstr_Microsoft performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  03c06	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  03c0c	e8 00 00 00 00	 call	 __ftol2_sse
  03c11	8b 74 24 24	 mov	 esi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  03c15	8b c8		 mov	 ecx, eax
  03c17	8b c6		 mov	 eax, esi
  03c19	99		 cdq
  03c1a	c1 f9 04	 sar	 ecx, 4
  03c1d	f7 f9		 idiv	 ecx
  03c1f	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  03c22	50		 push	 eax
  03c23	68 00 00 00 00	 push	 OFFSET $SG6672
  03c28	e8 00 00 00 00	 call	 _printf

; 4827 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  03c2d	56		 push	 esi
  03c2e	68 00 00 00 00	 push	 OFFSET $SG6673
  03c33	e8 00 00 00 00	 call	 _printf
  03c38	83 c4 24	 add	 esp, 36			; 00000024H

; 4828 : // 7]
; 4829 : 
; 4830 : // 8[
; 4831 : clocks1 = clock();

  03c3b	e8 00 00 00 00	 call	 _clock

; 4832 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  03c40	8b 5c 24 28	 mov	 ebx, DWORD PTR _Strng$[esp+4512]
  03c44	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax
  03c49	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
$LL171@main:

; 4833 : {
; 4834 : //Search area is between Strng[0] .. Strng[n-1]
; 4835 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real

  03c51	33 f6		 xor	 esi, esi
  03c53	89 74 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], esi

; 4836 : ThunderwithL=0;ThunderwithR=0;

  03c57	33 ff		 xor	 edi, edi
  03c59	8d a4 24 00 00
	00 00		 npad	 7
$LL168@main:

; 4837 : 	for (;;)
; 4838 : 	{
; 4839 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  03c60	80 3c 1e 0a	 cmp	 BYTE PTR [esi+ebx], 10	; 0000000aH
  03c64	74 15		 je	 SHORT $LN165@main
  03c66	8b 44 24 24	 mov	 eax, DWORD PTR tv4941[esp+4512]
  03c6a	8d 9b 00 00 00
	00		 npad	 6
$LL166@main:
  03c70	3b f0		 cmp	 esi, eax
  03c72	7d 07		 jge	 SHORT $LN165@main
  03c74	46		 inc	 esi
  03c75	80 3c 1e 0a	 cmp	 BYTE PTR [esi+ebx], 10	; 0000000aH
  03c79	75 f5		 jne	 SHORT $LL166@main
$LN165@main:

; 4840 : 	FoundInPTR = strstr_GNU_C_Library(&Strng[ThunderwithL], &Pattern[0]);

  03c7b	8d 94 24 b0 09
	00 00		 lea	 edx, DWORD PTR _Pattern$[esp+4512]
  03c82	8d 04 1f	 lea	 eax, DWORD PTR [edi+ebx]
  03c85	52		 push	 edx
  03c86	50		 push	 eax
  03c87	e8 00 00 00 00	 call	 _strstr_GNU_C_Library
  03c8c	83 c4 08	 add	 esp, 8

; 4841 : 	if ( FoundInPTR != 0) {strstrGNUCLibraryhits++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  03c8f	85 c0		 test	 eax, eax
  03c91	74 29		 je	 SHORT $LN164@main
  03c93	ff 44 24 64	 inc	 DWORD PTR _strstrGNUCLibraryhits$[esp+4512]
  03c97	2b c7		 sub	 eax, edi
  03c99	2b c3		 sub	 eax, ebx
  03c9b	eb 23		 jmp	 SHORT $LN1099@main
$LN787@main:

; 4815 : 	FoundInPTR = strstr_Microsoft(&Strng[ThunderwithL], &Pattern[0]);

  03c9d	8b 54 24 30	 mov	 edx, DWORD PTR _ThunderwithL$[esp+4512]
  03ca1	8b 4c 24 28	 mov	 ecx, DWORD PTR _Strng$[esp+4512]
$LN1097@main:
  03ca5	8b c6		 mov	 eax, esi

; 4816 : 	if ( FoundInPTR != NULL) {strstrMicrosofthits++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  03ca7	85 c0		 test	 eax, eax
  03ca9	0f 84 be fe ff
	ff		 je	 $LN175@main
  03caf	ff 44 24 6c	 inc	 DWORD PTR _strstrMicrosofthits$[esp+4512]
  03cb3	2b c2		 sub	 eax, edx
  03cb5	2b c1		 sub	 eax, ecx
  03cb7	e9 b5 fe ff ff	 jmp	 $LN1098@main
$LN164@main:

; 4841 : 	if ( FoundInPTR != 0) {strstrGNUCLibraryhits++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  03cbc	8b c6		 mov	 eax, esi
  03cbe	2b c7		 sub	 eax, edi
$LN1099@main:
  03cc0	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax

; 4842 : 	LinesEncountered++;

  03cc4	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]

; 4843 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;

  03cc8	46		 inc	 esi
  03cc9	8b fe		 mov	 edi, esi

; 4844 : 	if (ThunderwithR >= Strnglen-1) break;

  03ccb	3b 74 24 24	 cmp	 esi, DWORD PTR tv4941[esp+4512]
  03ccf	7c 8f		 jl	 SHORT $LL168@main

; 4845 : 	}
; 4846 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  03cd1	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  03cd5	83 f8 0f	 cmp	 eax, 15			; 0000000fH
  03cd8	74 08		 je	 SHORT $LN170@main
  03cda	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN170@main:

; 4832 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  03ce2	40		 inc	 eax
  03ce3	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  03ce7	83 f8 10	 cmp	 eax, 16			; 00000010H
  03cea	0f 8c 61 ff ff
	ff		 jl	 $LL171@main

; 4847 : }
; 4848 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  03cf0	e8 00 00 00 00	 call	 _clock

; 4849 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  03cf5	8b 4c 24 1c	 mov	 ecx, DWORD PTR _LinesEncountered$[esp+4512]
  03cf9	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  03cfe	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  03d04	51		 push	 ecx
  03d05	89 44 24 18	 mov	 DWORD PTR tv7491[esp+4516], eax
  03d09	db 44 24 18	 fild	 DWORD PTR tv7491[esp+4516]
  03d0d	68 00 00 00 00	 push	 OFFSET $SG6687
  03d12	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  03d18	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  03d1e	e8 00 00 00 00	 call	 _printf

; 4850 : printf( "strstr_GNU_C_Library_hits/strstr_GNU_C_Library_clocks: %lu/%lu\n", strstrGNUCLibraryhits>>4, (long)(TotalRoughSearchTime)>>4);

  03d23	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  03d29	e8 00 00 00 00	 call	 __ftol2_sse
  03d2e	c1 f8 04	 sar	 eax, 4
  03d31	50		 push	 eax
  03d32	8b 44 24 70	 mov	 eax, DWORD PTR _strstrGNUCLibraryhits$[esp+4524]
  03d36	c1 f8 04	 sar	 eax, 4
  03d39	50		 push	 eax
  03d3a	68 00 00 00 00	 push	 OFFSET $SG6689
  03d3f	e8 00 00 00 00	 call	 _printf

; 4851 : printf( "strstr_GNU_C_Library performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  03d44	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  03d4a	e8 00 00 00 00	 call	 __ftol2_sse
  03d4f	8b 74 24 24	 mov	 esi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  03d53	8b c8		 mov	 ecx, eax
  03d55	8b c6		 mov	 eax, esi
  03d57	99		 cdq
  03d58	c1 f9 04	 sar	 ecx, 4
  03d5b	f7 f9		 idiv	 ecx
  03d5d	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  03d60	50		 push	 eax
  03d61	68 00 00 00 00	 push	 OFFSET $SG6691
  03d66	e8 00 00 00 00	 call	 _printf

; 4852 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  03d6b	56		 push	 esi
  03d6c	68 00 00 00 00	 push	 OFFSET $SG6692
  03d71	e8 00 00 00 00	 call	 _printf
  03d76	83 c4 24	 add	 esp, 36			; 00000024H

; 4853 : // 8]
; 4854 : 
; 4855 : // 9[
; 4856 : clocks1 = clock();

  03d79	e8 00 00 00 00	 call	 _clock
  03d7e	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 4857 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  03d83	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
  03d8b	eb 03 8d 49 00	 npad	 5
$LL160@main:

; 4858 : {
; 4859 : //Search area is between Strng[0] .. Strng[n-1]
; 4860 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real

  03d90	33 f6		 xor	 esi, esi
  03d92	89 74 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], esi

; 4861 : ThunderwithL=0;ThunderwithR=0;

  03d96	33 ff		 xor	 edi, edi
$LL157@main:

; 4862 : 	for (;;)
; 4863 : 	{
; 4864 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  03d98	80 3c 1e 0a	 cmp	 BYTE PTR [esi+ebx], 10	; 0000000aH
  03d9c	74 0f		 je	 SHORT $LN154@main
  03d9e	8b 44 24 24	 mov	 eax, DWORD PTR tv4941[esp+4512]
$LL155@main:
  03da2	3b f0		 cmp	 esi, eax
  03da4	7d 07		 jge	 SHORT $LN154@main
  03da6	46		 inc	 esi
  03da7	80 3c 1e 0a	 cmp	 BYTE PTR [esi+ebx], 10	; 0000000aH
  03dab	75 f5		 jne	 SHORT $LL155@main
$LN154@main:

; 4865 : 	FoundInPTR = Railgun(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  03dad	8b 54 24 2c	 mov	 edx, DWORD PTR _Patternlen$[esp+4512]
  03db1	52		 push	 edx
  03db2	8b c6		 mov	 eax, esi
  03db4	2b c7		 sub	 eax, edi
  03db6	50		 push	 eax
  03db7	8d 84 24 b8 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4520]
  03dbe	8d 0c 1f	 lea	 ecx, DWORD PTR [edi+ebx]
  03dc1	50		 push	 eax
  03dc2	51		 push	 ecx
  03dc3	e8 00 00 00 00	 call	 _Railgun
  03dc8	83 c4 10	 add	 esp, 16			; 00000010H

; 4866 : 	if ( FoundInPTR != NULL) {Karp_Rabin_Kaze_4_OCTETShits++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  03dcb	85 c0		 test	 eax, eax
  03dcd	74 0e		 je	 SHORT $LN153@main
  03dcf	ff 44 24 4c	 inc	 DWORD PTR _Karp_Rabin_Kaze_4_OCTETShits$[esp+4512]
  03dd3	2b c7		 sub	 eax, edi
  03dd5	2b c3		 sub	 eax, ebx
  03dd7	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax
  03ddb	eb 08		 jmp	 SHORT $LN152@main
$LN153@main:
  03ddd	8b ce		 mov	 ecx, esi
  03ddf	2b cf		 sub	 ecx, edi
  03de1	01 4c 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], ecx
$LN152@main:

; 4867 : 	LinesEncountered++;

  03de5	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]

; 4868 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;

  03de9	46		 inc	 esi
  03dea	8b fe		 mov	 edi, esi

; 4869 : 	if (ThunderwithR >= Strnglen-1) break;

  03dec	3b 74 24 24	 cmp	 esi, DWORD PTR tv4941[esp+4512]
  03df0	7c a6		 jl	 SHORT $LL157@main

; 4870 : 	}
; 4871 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  03df2	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  03df6	83 f8 0f	 cmp	 eax, 15			; 0000000fH
  03df9	74 08		 je	 SHORT $LN159@main
  03dfb	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN159@main:

; 4857 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  03e03	40		 inc	 eax
  03e04	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  03e08	83 f8 10	 cmp	 eax, 16			; 00000010H
  03e0b	7c 83		 jl	 SHORT $LL160@main

; 4872 : }
; 4873 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  03e0d	e8 00 00 00 00	 call	 _clock

; 4874 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  03e12	8b 54 24 1c	 mov	 edx, DWORD PTR _LinesEncountered$[esp+4512]
  03e16	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  03e1b	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  03e21	52		 push	 edx
  03e22	89 44 24 18	 mov	 DWORD PTR tv7469[esp+4516], eax
  03e26	db 44 24 18	 fild	 DWORD PTR tv7469[esp+4516]
  03e2a	68 00 00 00 00	 push	 OFFSET $SG6707
  03e2f	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  03e35	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  03e3b	e8 00 00 00 00	 call	 _printf

; 4875 : printf( "Railgun_hits/Railgun_clocks: %lu/%lu\n", Karp_Rabin_Kaze_4_OCTETShits>>4, (long)(TotalRoughSearchTime)>>4);

  03e40	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  03e46	e8 00 00 00 00	 call	 __ftol2_sse
  03e4b	c1 f8 04	 sar	 eax, 4
  03e4e	50		 push	 eax
  03e4f	8b 44 24 58	 mov	 eax, DWORD PTR _Karp_Rabin_Kaze_4_OCTETShits$[esp+4524]
  03e53	c1 f8 04	 sar	 eax, 4
  03e56	50		 push	 eax
  03e57	68 00 00 00 00	 push	 OFFSET $SG6709
  03e5c	e8 00 00 00 00	 call	 _printf

; 4876 : printf( "Railgun performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  03e61	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  03e67	e8 00 00 00 00	 call	 __ftol2_sse
  03e6c	8b 74 24 24	 mov	 esi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  03e70	8b c8		 mov	 ecx, eax
  03e72	8b c6		 mov	 eax, esi
  03e74	99		 cdq
  03e75	c1 f9 04	 sar	 ecx, 4
  03e78	f7 f9		 idiv	 ecx
  03e7a	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  03e7d	50		 push	 eax
  03e7e	68 00 00 00 00	 push	 OFFSET $SG6711
  03e83	e8 00 00 00 00	 call	 _printf

; 4877 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  03e88	56		 push	 esi
  03e89	68 00 00 00 00	 push	 OFFSET $SG6712
  03e8e	e8 00 00 00 00	 call	 _printf
  03e93	83 c4 24	 add	 esp, 36			; 00000024H

; 4878 : // 9]
; 4879 : 
; 4880 : // +[
; 4881 : clocks1 = clock();

  03e96	e8 00 00 00 00	 call	 _clock

; 4882 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  03e9b	8b 74 24 24	 mov	 esi, DWORD PTR tv4941[esp+4512]
  03e9f	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax
  03ea4	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
  03eac	8d 64 24 00	 npad	 4
$LL149@main:

; 4883 : {
; 4884 : //Search area is between Strng[0] .. Strng[n-1]
; 4885 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real

  03eb0	33 c0		 xor	 eax, eax
  03eb2	89 44 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax

; 4886 : ThunderwithL=0;ThunderwithR=0;

  03eb6	89 44 24 30	 mov	 DWORD PTR _ThunderwithL$[esp+4512], eax
  03eba	89 44 24 20	 mov	 DWORD PTR _ThunderwithR$[esp+4512], eax
  03ebe	8b ff		 npad	 2
$LL146@main:

; 4887 : 	for (;;)
; 4888 : 	{
; 4889 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  03ec0	8b 44 24 20	 mov	 eax, DWORD PTR _ThunderwithR$[esp+4512]
  03ec4	8b 4c 24 28	 mov	 ecx, DWORD PTR _Strng$[esp+4512]
  03ec8	80 3c 08 0a	 cmp	 BYTE PTR [eax+ecx], 10	; 0000000aH
  03ecc	74 11		 je	 SHORT $LN143@main
  03ece	8b ff		 npad	 2
$LL144@main:
  03ed0	3b c6		 cmp	 eax, esi
  03ed2	7d 07		 jge	 SHORT $LN1055@main
  03ed4	40		 inc	 eax
  03ed5	80 3c 08 0a	 cmp	 BYTE PTR [eax+ecx], 10	; 0000000aH
  03ed9	75 f5		 jne	 SHORT $LL144@main
$LN1055@main:
  03edb	89 44 24 20	 mov	 DWORD PTR _ThunderwithR$[esp+4512], eax
$LN143@main:

; 4890 : 	FoundInPTR = Railgun_Quadruplet(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  03edf	8b 5c 24 30	 mov	 ebx, DWORD PTR _ThunderwithL$[esp+4512]
  03ee3	8b 54 24 20	 mov	 edx, DWORD PTR _ThunderwithR$[esp+4512]
  03ee7	2b d3		 sub	 edx, ebx
  03ee9	03 d9		 add	 ebx, ecx
  03eeb	8b 4c 24 2c	 mov	 ecx, DWORD PTR _Patternlen$[esp+4512]
  03eef	8d 3c 1a	 lea	 edi, DWORD PTR [edx+ebx]
  03ef2	89 7c 24 50	 mov	 DWORD PTR _pbTargetMax$7760[esp+4512], edi
  03ef6	3b ca		 cmp	 ecx, edx
  03ef8	77 5b		 ja	 SHORT $LN142@main
  03efa	83 f9 04	 cmp	 ecx, 4
  03efd	0f 83 70 03 00
	00		 jae	 $LN468@main
  03f03	0f be 94 24 b0
	09 00 00	 movsx	 edx, BYTE PTR _Pattern$[esp+4512]
  03f0b	0f be b4 0c af
	09 00 00	 movsx	 esi, BYTE PTR _Pattern$[esp+ecx+4511]
  03f13	c1 e2 08	 shl	 edx, 8
  03f16	03 f2		 add	 esi, edx
  03f18	8d 04 0b	 lea	 eax, DWORD PTR [ebx+ecx]
  03f1b	83 f9 03	 cmp	 ecx, 3
  03f1e	0f 85 08 03 00
	00		 jne	 $LN676@main
$LL466@main:
  03f24	0f be 48 fd	 movsx	 ecx, BYTE PTR [eax-3]
  03f28	0f be 50 ff	 movsx	 edx, BYTE PTR [eax-1]
  03f2c	c1 e1 08	 shl	 ecx, 8
  03f2f	03 ca		 add	 ecx, edx
  03f31	3b f1		 cmp	 esi, ecx
  03f33	75 10		 jne	 SHORT $LN463@main
  03f35	8a 8c 24 b1 09
	00 00		 mov	 cl, BYTE PTR _Pattern$[esp+4513]
  03f3c	3a 48 fe	 cmp	 cl, BYTE PTR [eax-2]
  03f3f	0f 84 df 02 00
	00		 je	 $LN791@main
$LN463@main:
  03f45	8b d6		 mov	 edx, esi
  03f47	c1 ea 08	 shr	 edx, 8
  03f4a	3a 50 fe	 cmp	 dl, BYTE PTR [eax-2]
  03f4d	74 01		 je	 SHORT $LN462@main
  03f4f	40		 inc	 eax
$LN462@main:
  03f50	40		 inc	 eax
  03f51	3b c7		 cmp	 eax, edi
  03f53	76 cf		 jbe	 SHORT $LL466@main
$LN142@main:

; 4891 : 	if ( FoundInPTR != NULL) {Karp_Rabin_Kaze_4_OCTETShits_DOUBLET++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  03f55	8b 44 24 20	 mov	 eax, DWORD PTR _ThunderwithR$[esp+4512]
  03f59	8b c8		 mov	 ecx, eax
  03f5b	2b 4c 24 30	 sub	 ecx, DWORD PTR _ThunderwithL$[esp+4512]
  03f5f	01 4c 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], ecx
$LN141@main:

; 4892 : 	LinesEncountered++;
; 4893 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;
; 4894 : 	if (ThunderwithR >= Strnglen-1) break;

  03f63	8b 74 24 48	 mov	 esi, DWORD PTR _Strnglen$[esp+4512]
  03f67	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]
  03f6b	40		 inc	 eax
  03f6c	4e		 dec	 esi
  03f6d	89 44 24 20	 mov	 DWORD PTR _ThunderwithR$[esp+4512], eax
  03f71	89 44 24 30	 mov	 DWORD PTR _ThunderwithL$[esp+4512], eax
  03f75	3b c6		 cmp	 eax, esi
  03f77	0f 8c 43 ff ff
	ff		 jl	 $LL146@main

; 4895 : 	}
; 4896 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  03f7d	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  03f81	83 f8 0f	 cmp	 eax, 15			; 0000000fH
  03f84	74 08		 je	 SHORT $LN148@main
  03f86	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN148@main:

; 4882 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  03f8e	40		 inc	 eax
  03f8f	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  03f93	83 f8 10	 cmp	 eax, 16			; 00000010H
  03f96	0f 8c 14 ff ff
	ff		 jl	 $LL149@main

; 4897 : }
; 4898 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  03f9c	e8 00 00 00 00	 call	 _clock

; 4899 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  03fa1	8b 54 24 1c	 mov	 edx, DWORD PTR _LinesEncountered$[esp+4512]
  03fa5	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  03faa	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  03fb0	52		 push	 edx
  03fb1	89 44 24 18	 mov	 DWORD PTR tv7437[esp+4516], eax
  03fb5	db 44 24 18	 fild	 DWORD PTR tv7437[esp+4516]
  03fb9	68 00 00 00 00	 push	 OFFSET $SG6727
  03fbe	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  03fc4	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  03fca	e8 00 00 00 00	 call	 _printf

; 4900 : printf( "Railgun_Quadruplet_hits/Railgun_Quadruplet_clocks: %lu/%lu\n", Karp_Rabin_Kaze_4_OCTETShits_DOUBLET>>4, (long)(TotalRoughSearchTime)>>4);

  03fcf	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  03fd5	e8 00 00 00 00	 call	 __ftol2_sse
  03fda	c1 f8 04	 sar	 eax, 4
  03fdd	50		 push	 eax
  03fde	8b 44 24 60	 mov	 eax, DWORD PTR _Karp_Rabin_Kaze_4_OCTETShits_DOUBLET$[esp+4524]
  03fe2	c1 f8 04	 sar	 eax, 4
  03fe5	50		 push	 eax
  03fe6	68 00 00 00 00	 push	 OFFSET $SG6729
  03feb	e8 00 00 00 00	 call	 _printf

; 4901 : printf( "Railgun_Quadruplet performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  03ff0	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  03ff6	e8 00 00 00 00	 call	 __ftol2_sse
  03ffb	8b 7c 24 24	 mov	 edi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  03fff	8b c8		 mov	 ecx, eax
  04001	8b c7		 mov	 eax, edi
  04003	99		 cdq
  04004	c1 f9 04	 sar	 ecx, 4
  04007	f7 f9		 idiv	 ecx
  04009	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  0400c	50		 push	 eax
  0400d	68 00 00 00 00	 push	 OFFSET $SG6731
  04012	e8 00 00 00 00	 call	 _printf

; 4902 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  04017	57		 push	 edi
  04018	68 00 00 00 00	 push	 OFFSET $SG6732
  0401d	e8 00 00 00 00	 call	 _printf
  04022	83 c4 24	 add	 esp, 36			; 00000024H

; 4903 : // +]
; 4904 : 
; 4905 : 
; 4906 : // Z[
; 4907 : clocks1 = clock();

  04025	e8 00 00 00 00	 call	 _clock
  0402a	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 4908 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  0402f	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
$LL138@main:

; 4909 : {
; 4910 : //Search area is between Strng[0] .. Strng[n-1]
; 4911 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real
; 4912 : ThunderwithL=0;ThunderwithR=0;

  04037	8b 4c 24 28	 mov	 ecx, DWORD PTR _Strng$[esp+4512]
  0403b	33 c0		 xor	 eax, eax
  0403d	33 d2		 xor	 edx, edx
  0403f	89 44 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax
  04043	89 44 24 30	 mov	 DWORD PTR _ThunderwithL$[esp+4512], eax
  04047	89 54 24 20	 mov	 DWORD PTR _ThunderwithR$[esp+4512], edx
  0404b	eb 03 8d 49 00	 npad	 5
$LL135@main:

; 4913 : 	for (;;)
; 4914 : 	{
; 4915 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  04050	80 3c 0a 0a	 cmp	 BYTE PTR [edx+ecx], 10	; 0000000aH
  04054	74 0f		 je	 SHORT $LN132@main
$LL133@main:
  04056	3b d6		 cmp	 edx, esi
  04058	7d 07		 jge	 SHORT $LN1056@main
  0405a	42		 inc	 edx
  0405b	80 3c 0a 0a	 cmp	 BYTE PTR [edx+ecx], 10	; 0000000aH
  0405f	75 f5		 jne	 SHORT $LL133@main
$LN1056@main:
  04061	89 54 24 20	 mov	 DWORD PTR _ThunderwithR$[esp+4512], edx
$LN132@main:

; 4916 : 	FoundInPTR = Railgun_Quadruplet_6pp(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  04065	8b 5c 24 2c	 mov	 ebx, DWORD PTR _Patternlen$[esp+4512]
  04069	2b d0		 sub	 edx, eax
  0406b	03 c1		 add	 eax, ecx
  0406d	8d 3c 02	 lea	 edi, DWORD PTR [edx+eax]
  04070	89 44 24 34	 mov	 DWORD PTR tv4485[esp+4512], eax
  04074	89 7c 24 50	 mov	 DWORD PTR _pbTargetMax$7824[esp+4512], edi
  04078	3b da		 cmp	 ebx, edx
  0407a	77 5a		 ja	 SHORT $LN131@main
  0407c	83 fb 04	 cmp	 ebx, 4
  0407f	0f 83 1f 04 00
	00		 jae	 $LN512@main
  04085	0f be 94 24 b0
	09 00 00	 movsx	 edx, BYTE PTR _Pattern$[esp+4512]
  0408d	0f be b4 1c af
	09 00 00	 movsx	 esi, BYTE PTR _Pattern$[esp+ebx+4511]
  04095	c1 e2 08	 shl	 edx, 8
  04098	03 c3		 add	 eax, ebx
  0409a	03 f2		 add	 esi, edx
  0409c	83 fb 03	 cmp	 ebx, 3
  0409f	0f 85 b8 03 00
	00		 jne	 $LN687@main
$LL510@main:
  040a5	0f be 48 fd	 movsx	 ecx, BYTE PTR [eax-3]
  040a9	0f be 50 ff	 movsx	 edx, BYTE PTR [eax-1]
  040ad	c1 e1 08	 shl	 ecx, 8
  040b0	03 ca		 add	 ecx, edx
  040b2	3b f1		 cmp	 esi, ecx
  040b4	75 10		 jne	 SHORT $LN507@main
  040b6	8a 8c 24 b1 09
	00 00		 mov	 cl, BYTE PTR _Pattern$[esp+4513]
  040bd	3a 48 fe	 cmp	 cl, BYTE PTR [eax-2]
  040c0	0f 84 8f 03 00
	00		 je	 $LN799@main
$LN507@main:
  040c6	8b d6		 mov	 edx, esi
  040c8	c1 ea 08	 shr	 edx, 8
  040cb	3a 50 fe	 cmp	 dl, BYTE PTR [eax-2]
  040ce	74 01		 je	 SHORT $LN506@main
  040d0	40		 inc	 eax
$LN506@main:
  040d1	40		 inc	 eax
  040d2	3b c7		 cmp	 eax, edi
  040d4	76 cf		 jbe	 SHORT $LL510@main
$LN131@main:

; 4917 : 	if ( FoundInPTR != NULL) {Railgun_Quadruplet_6pp_GO++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  040d6	8b 54 24 20	 mov	 edx, DWORD PTR _ThunderwithR$[esp+4512]
  040da	8b ca		 mov	 ecx, edx
  040dc	2b 4c 24 30	 sub	 ecx, DWORD PTR _ThunderwithL$[esp+4512]
  040e0	01 4c 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], ecx
  040e4	8b 4c 24 28	 mov	 ecx, DWORD PTR _Strng$[esp+4512]
$LN130@main:

; 4918 : 	LinesEncountered++;
; 4919 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;
; 4920 : 	if (ThunderwithR >= Strnglen-1) break;

  040e8	8b 74 24 48	 mov	 esi, DWORD PTR _Strnglen$[esp+4512]
  040ec	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]
  040f0	42		 inc	 edx
  040f1	4e		 dec	 esi
  040f2	8b c2		 mov	 eax, edx
  040f4	89 54 24 20	 mov	 DWORD PTR _ThunderwithR$[esp+4512], edx
  040f8	89 44 24 30	 mov	 DWORD PTR _ThunderwithL$[esp+4512], eax
  040fc	89 74 24 24	 mov	 DWORD PTR tv4941[esp+4512], esi
  04100	3b d6		 cmp	 edx, esi
  04102	0f 8c 48 ff ff
	ff		 jl	 $LL135@main

; 4921 : 	}
; 4922 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  04108	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  0410c	83 f8 0f	 cmp	 eax, 15			; 0000000fH
  0410f	74 08		 je	 SHORT $LN137@main
  04111	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN137@main:

; 4908 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  04119	40		 inc	 eax
  0411a	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  0411e	83 f8 10	 cmp	 eax, 16			; 00000010H
  04121	0f 8c 10 ff ff
	ff		 jl	 $LL138@main

; 4923 : }
; 4924 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  04127	e8 00 00 00 00	 call	 _clock

; 4925 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  0412c	8b 54 24 1c	 mov	 edx, DWORD PTR _LinesEncountered$[esp+4512]
  04130	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  04135	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  0413b	52		 push	 edx
  0413c	89 44 24 18	 mov	 DWORD PTR tv7405[esp+4516], eax
  04140	db 44 24 18	 fild	 DWORD PTR tv7405[esp+4516]
  04144	68 00 00 00 00	 push	 OFFSET $SG6747
  04149	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  0414f	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  04155	e8 00 00 00 00	 call	 _printf

; 4926 : printf( "Railgun_Quadruplet_6pp_hits/Railgun_Quadruplet_6pp_clocks: %lu/%lu\n", Railgun_Quadruplet_6pp_GO>>4, (long)(TotalRoughSearchTime)>>4);

  0415a	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04160	e8 00 00 00 00	 call	 __ftol2_sse
  04165	c1 f8 04	 sar	 eax, 4
  04168	50		 push	 eax
  04169	8b 84 24 80 00
	00 00		 mov	 eax, DWORD PTR _Railgun_Quadruplet_6pp_GO$[esp+4524]
  04170	c1 f8 04	 sar	 eax, 4
  04173	50		 push	 eax
  04174	68 00 00 00 00	 push	 OFFSET $SG6749
  04179	e8 00 00 00 00	 call	 _printf

; 4927 : printf( "Railgun_Quadruplet_6pp performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  0417e	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04184	e8 00 00 00 00	 call	 __ftol2_sse
  04189	8b 74 24 24	 mov	 esi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  0418d	8b c8		 mov	 ecx, eax
  0418f	8b c6		 mov	 eax, esi
  04191	99		 cdq
  04192	c1 f9 04	 sar	 ecx, 4
  04195	f7 f9		 idiv	 ecx
  04197	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  0419a	50		 push	 eax
  0419b	68 00 00 00 00	 push	 OFFSET $SG6751
  041a0	e8 00 00 00 00	 call	 _printf

; 4928 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  041a5	56		 push	 esi
  041a6	68 00 00 00 00	 push	 OFFSET $SG6752
  041ab	e8 00 00 00 00	 call	 _printf
  041b0	83 c4 24	 add	 esp, 36			; 00000024H

; 4929 : // Z]
; 4930 : 
; 4931 : 
; 4932 : 
; 4933 : 
; 4934 : 
; 4935 : 
; 4936 : 
; 4937 : 
; 4938 : // 6[
; 4939 : clocks1 = clock();

  041b3	e8 00 00 00 00	 call	 _clock

; 4940 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  041b8	8b 5c 24 28	 mov	 ebx, DWORD PTR _Strng$[esp+4512]
  041bc	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax
  041c1	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
  041c9	8d a4 24 00 00
	00 00		 npad	 7
$LL127@main:

; 4941 : {
; 4942 : //Search area is between Strng[0] .. Strng[n-1]
; 4943 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real

  041d0	33 f6		 xor	 esi, esi
  041d2	89 74 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], esi

; 4944 : ThunderwithL=0;ThunderwithR=0;

  041d6	33 ff		 xor	 edi, edi
$LL124@main:

; 4945 : 	for (;;)
; 4946 : 	{
; 4947 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  041d8	80 3c 1e 0a	 cmp	 BYTE PTR [esi+ebx], 10	; 0000000aH
  041dc	74 0f		 je	 SHORT $LN121@main
  041de	8b 44 24 24	 mov	 eax, DWORD PTR tv4941[esp+4512]
$LL122@main:
  041e2	3b f0		 cmp	 esi, eax
  041e4	7d 07		 jge	 SHORT $LN121@main
  041e6	46		 inc	 esi
  041e7	80 3c 1e 0a	 cmp	 BYTE PTR [esi+ebx], 10	; 0000000aH
  041eb	75 f5		 jne	 SHORT $LL122@main
$LN121@main:

; 4948 : 	FoundInPTR = KarpRabinKaze_BOOSTED(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  041ed	8b 54 24 2c	 mov	 edx, DWORD PTR _Patternlen$[esp+4512]
  041f1	52		 push	 edx
  041f2	8b c6		 mov	 eax, esi
  041f4	2b c7		 sub	 eax, edi
  041f6	50		 push	 eax
  041f7	8d 84 24 b8 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4520]
  041fe	8d 0c 1f	 lea	 ecx, DWORD PTR [edi+ebx]
  04201	50		 push	 eax
  04202	51		 push	 ecx
  04203	e8 00 00 00 00	 call	 _KarpRabinKaze_BOOSTED
  04208	83 c4 10	 add	 esp, 16			; 00000010H

; 4949 : 	if ( FoundInPTR != NULL) {KarpRabinKaze_BOOSTEDhits++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  0420b	85 c0		 test	 eax, eax
  0420d	0f 84 7d 04 00
	00		 je	 $LN120@main
  04213	ff 44 24 70	 inc	 DWORD PTR _KarpRabinKaze_BOOSTEDhits$[esp+4512]
  04217	2b c7		 sub	 eax, edi
  04219	2b c3		 sub	 eax, ebx
  0421b	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax
  0421f	e9 74 04 00 00	 jmp	 $LN119@main
$LN791@main:

; 4890 : 	FoundInPTR = Railgun_Quadruplet(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  04224	83 c0 fd	 add	 eax, -3			; fffffffdH
  04227	e9 08 02 00 00	 jmp	 $LN440@main
$LN676@main:
  0422c	8a 48 ff	 mov	 cl, BYTE PTR [eax-1]
  0422f	0f be 50 fe	 movsx	 edx, BYTE PTR [eax-2]
  04233	0f be d9	 movsx	 ebx, cl
  04236	c1 e2 08	 shl	 edx, 8
  04239	03 d3		 add	 edx, ebx
  0423b	3b f2		 cmp	 esi, edx
  0423d	74 2c		 je	 SHORT $LN793@main
  0423f	8b d6		 mov	 edx, esi
  04241	c1 ea 08	 shr	 edx, 8
  04244	eb 04		 jmp	 SHORT $LN459@main
$LL1027@main:
  04246	8b 7c 24 50	 mov	 edi, DWORD PTR _pbTargetMax$7760[esp+4512]
$LN459@main:
  0424a	3a d1		 cmp	 dl, cl
  0424c	74 01		 je	 SHORT $LN456@main
  0424e	40		 inc	 eax
$LN456@main:
  0424f	40		 inc	 eax
  04250	3b c7		 cmp	 eax, edi
  04252	0f 87 fd fc ff
	ff		 ja	 $LN142@main
  04258	8a 48 ff	 mov	 cl, BYTE PTR [eax-1]
  0425b	0f be 78 fe	 movsx	 edi, BYTE PTR [eax-2]
  0425f	0f be d9	 movsx	 ebx, cl
  04262	c1 e7 08	 shl	 edi, 8
  04265	03 fb		 add	 edi, ebx
  04267	3b f7		 cmp	 esi, edi
  04269	75 db		 jne	 SHORT $LL1027@main
$LN793@main:
  0426b	83 c0 fe	 add	 eax, -2			; fffffffeH
  0426e	e9 c1 01 00 00	 jmp	 $LN440@main
$LN468@main:
  04273	81 fa c1 03 00
	00		 cmp	 edx, 961		; 000003c1H
  04279	0f 83 ea 00 00
	00		 jae	 $LN453@main
  0427f	0f b6 84 24 b0
	09 00 00	 movzx	 eax, BYTE PTR _Pattern$[esp+4512]
  04287	8b f8		 mov	 edi, eax
  04289	8b f0		 mov	 esi, eax
  0428b	c1 e7 08	 shl	 edi, 8
  0428e	c1 e6 10	 shl	 esi, 16			; 00000010H
  04291	89 44 24 4c	 mov	 DWORD PTR tv6297[esp+4512], eax
  04295	8d 14 0b	 lea	 edx, DWORD PTR [ebx+ecx]
  04298	c1 e0 18	 shl	 eax, 24			; 00000018H
  0429b	89 54 24 34	 mov	 DWORD PTR $T7819[esp+4512], edx
  0429f	89 7c 24 40	 mov	 DWORD PTR _Quadruplet2nd$7766[esp+4512], edi
  042a3	89 74 24 14	 mov	 DWORD PTR _Quadruplet3rd$7767[esp+4512], esi
  042a7	89 44 24 44	 mov	 DWORD PTR _Quadruplet4th$7768[esp+4512], eax
  042ab	eb 03 8d 49 00	 npad	 5
$LL452@main:
  042b0	8b c2		 mov	 eax, edx
  042b2	2b c1		 sub	 eax, ecx
  042b4	8b 00		 mov	 eax, DWORD PTR [eax]
  042b6	33 f6		 xor	 esi, esi
  042b8	39 84 24 b0 09
	00 00		 cmp	 DWORD PTR _Pattern$[esp+4512], eax
  042bf	75 59		 jne	 SHORT $LN450@main
  042c1	8d 41 ff	 lea	 eax, DWORD PTR [ecx-1]
  042c4	85 c0		 test	 eax, eax
  042c6	74 3d		 je	 SHORT $LN913@main
  042c8	8b 7c 24 2c	 mov	 edi, DWORD PTR _Patternlen$[esp+4512]
  042cc	8b ca		 mov	 ecx, edx
  042ce	2b c8		 sub	 ecx, eax
  042d0	2b f8		 sub	 edi, eax
  042d2	8d bc 3c b0 09
	00 00		 lea	 edi, DWORD PTR _Pattern$[esp+edi+4512]
  042d9	8d a4 24 00 00
	00 00		 npad	 7
$LL449@main:
  042e0	8a 19		 mov	 bl, BYTE PTR [ecx]
  042e2	38 1f		 cmp	 BYTE PTR [edi], bl
  042e4	75 2a		 jne	 SHORT $LN448@main
  042e6	8b 54 24 2c	 mov	 edx, DWORD PTR _Patternlen$[esp+4512]
  042ea	8d 1c 30	 lea	 ebx, DWORD PTR [eax+esi]
  042ed	4a		 dec	 edx
  042ee	3b d3		 cmp	 edx, ebx
  042f0	75 0a		 jne	 SHORT $LN447@main
  042f2	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  042f5	39 54 24 4c	 cmp	 DWORD PTR tv6297[esp+4512], edx
  042f9	74 01		 je	 SHORT $LN447@main
  042fb	46		 inc	 esi
$LN447@main:
  042fc	8b 54 24 34	 mov	 edx, DWORD PTR $T7819[esp+4512]
  04300	47		 inc	 edi
  04301	41		 inc	 ecx
  04302	48		 dec	 eax
  04303	75 db		 jne	 SHORT $LL449@main
$LN913@main:
  04305	2b 54 24 2c	 sub	 edx, DWORD PTR _Patternlen$[esp+4512]
  04309	8b c2		 mov	 eax, edx
  0430b	e9 24 01 00 00	 jmp	 $LN440@main
$LN448@main:
  04310	85 c0		 test	 eax, eax
  04312	74 f1		 je	 SHORT $LN913@main
  04314	8b 4c 24 2c	 mov	 ecx, DWORD PTR _Patternlen$[esp+4512]
  04318	eb 34		 jmp	 SHORT $LN442@main
$LN450@main:
  0431a	8b d8		 mov	 ebx, eax
  0431c	81 e3 00 ff 00
	00		 and	 ebx, 65280		; 0000ff00H
  04322	3b fb		 cmp	 edi, ebx
  04324	74 28		 je	 SHORT $LN442@main
  04326	8b f8		 mov	 edi, eax
  04328	81 e7 00 00 ff
	00		 and	 edi, 16711680		; 00ff0000H
  0432e	be 01 00 00 00	 mov	 esi, 1
  04333	39 7c 24 14	 cmp	 DWORD PTR _Quadruplet3rd$7767[esp+4512], edi
  04337	74 15		 je	 SHORT $LN442@main
  04339	25 00 00 00 ff	 and	 eax, -16777216		; ff000000H
  0433e	be 02 00 00 00	 mov	 esi, 2
  04343	39 44 24 44	 cmp	 DWORD PTR _Quadruplet4th$7768[esp+4512], eax
  04347	74 05		 je	 SHORT $LN442@main
  04349	be 03 00 00 00	 mov	 esi, 3
$LN442@main:
  0434e	8d 54 32 01	 lea	 edx, DWORD PTR [edx+esi+1]
  04352	89 54 24 34	 mov	 DWORD PTR $T7819[esp+4512], edx
  04356	3b 54 24 50	 cmp	 edx, DWORD PTR _pbTargetMax$7760[esp+4512]
  0435a	0f 87 f5 fb ff
	ff		 ja	 $LN142@main
  04360	8b 7c 24 40	 mov	 edi, DWORD PTR _Quadruplet2nd$7766[esp+4512]
  04364	e9 47 ff ff ff	 jmp	 $LL452@main
$LN453@main:
  04369	8b 44 24 2c	 mov	 eax, DWORD PTR _Patternlen$[esp+4512]
  0436d	8d 48 fe	 lea	 ecx, DWORD PTR [eax-2]
  04370	89 4c 24 14	 mov	 DWORD PTR _countSTATIC$7764[esp+4512], ecx
  04374	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  04379	8d bc 24 90 01
	00 00		 lea	 edi, DWORD PTR _bm_bc$7773[esp+4512]
  04380	f3 ab		 rep stosd
  04382	8d 70 ff	 lea	 esi, DWORD PTR [eax-1]
  04385	33 c9		 xor	 ecx, ecx
  04387	85 f6		 test	 esi, esi
  04389	74 1d		 je	 SHORT $LN434@main
  0438b	8d 78 ff	 lea	 edi, DWORD PTR [eax-1]
  0438e	8b ff		 npad	 2
$LL436@main:
  04390	0f be b4 0c b0
	09 00 00	 movsx	 esi, BYTE PTR _Pattern$[esp+ecx+4512]
  04398	89 bc b4 90 01
	00 00		 mov	 DWORD PTR _bm_bc$7773[esp+esi*4+4512], edi
  0439f	41		 inc	 ecx
  043a0	8d 70 ff	 lea	 esi, DWORD PTR [eax-1]
  043a3	4f		 dec	 edi
  043a4	3b ce		 cmp	 ecx, esi
  043a6	72 e8		 jb	 SHORT $LL436@main
$LN434@main:
  043a8	33 f6		 xor	 esi, esi
  043aa	2b d0		 sub	 edx, eax
  043ac	89 54 24 34	 mov	 DWORD PTR $T8334[esp+4512], edx
  043b0	0f be 94 04 af
	09 00 00	 movsx	 edx, BYTE PTR _Pattern$[esp+eax+4511]
  043b8	89 54 24 4c	 mov	 DWORD PTR tv4989[esp+4512], edx
  043bc	8d 64 24 00	 npad	 4
$LL433@main:
  043c0	8d 0c 33	 lea	 ecx, DWORD PTR [ebx+esi]
  043c3	0f b6 44 01 ff	 movzx	 eax, BYTE PTR [ecx+eax-1]
  043c8	89 44 24 5c	 mov	 DWORD PTR tv5078[esp+4512], eax
  043cc	3b 44 24 4c	 cmp	 eax, DWORD PTR tv4989[esp+4512]
  043d0	75 48		 jne	 SHORT $LN428@main
  043d2	8a 94 24 b0 09
	00 00		 mov	 dl, BYTE PTR _Pattern$[esp+4512]
  043d9	38 11		 cmp	 BYTE PTR [ecx], dl
  043db	75 3d		 jne	 SHORT $LN428@main
  043dd	8b 4c 24 14	 mov	 ecx, DWORD PTR _countSTATIC$7764[esp+4512]
  043e1	85 c9		 test	 ecx, ecx
  043e3	74 4c		 je	 SHORT $LN797@main
  043e5	8d 84 24 b1 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4513]
  043ec	8b d6		 mov	 edx, esi
  043ee	8b f8		 mov	 edi, eax
  043f0	2b d7		 sub	 edx, edi
  043f2	89 54 24 40	 mov	 DWORD PTR tv7809[esp+4512], edx
$LL430@main:
  043f6	03 d0		 add	 edx, eax
  043f8	89 44 24 44	 mov	 DWORD PTR tv6979[esp+4512], eax
  043fc	8a 00		 mov	 al, BYTE PTR [eax]
  043fe	3a 44 1a 01	 cmp	 al, BYTE PTR [edx+ebx+1]
  04402	8b 44 24 44	 mov	 eax, DWORD PTR tv6979[esp+4512]
  04406	75 0a		 jne	 SHORT $LN429@main
  04408	40		 inc	 eax
  04409	49		 dec	 ecx
  0440a	74 25		 je	 SHORT $LN797@main
  0440c	8b 54 24 40	 mov	 edx, DWORD PTR tv7809[esp+4512]
  04410	eb e4		 jmp	 SHORT $LL430@main
$LN429@main:
  04412	85 c9		 test	 ecx, ecx
  04414	74 1b		 je	 SHORT $LN797@main
  04416	8b 44 24 5c	 mov	 eax, DWORD PTR tv5078[esp+4512]
$LN428@main:
  0441a	03 b4 84 90 01
	00 00		 add	 esi, DWORD PTR _bm_bc$7773[esp+eax*4+4512]
  04421	3b 74 24 34	 cmp	 esi, DWORD PTR $T8334[esp+4512]
  04425	0f 87 2a fb ff
	ff		 ja	 $LN142@main
  0442b	8b 44 24 2c	 mov	 eax, DWORD PTR _Patternlen$[esp+4512]
  0442f	eb 8f		 jmp	 SHORT $LL433@main
$LN797@main:
  04431	8d 04 33	 lea	 eax, DWORD PTR [ebx+esi]
$LN440@main:

; 4891 : 	if ( FoundInPTR != NULL) {Karp_Rabin_Kaze_4_OCTETShits_DOUBLET++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  04434	85 c0		 test	 eax, eax
  04436	0f 84 19 fb ff
	ff		 je	 $LN142@main
  0443c	2b 44 24 30	 sub	 eax, DWORD PTR _ThunderwithL$[esp+4512]
  04440	ff 44 24 54	 inc	 DWORD PTR _Karp_Rabin_Kaze_4_OCTETShits_DOUBLET$[esp+4512]
  04444	2b 44 24 28	 sub	 eax, DWORD PTR _Strng$[esp+4512]
  04448	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax
  0444c	8b 44 24 20	 mov	 eax, DWORD PTR _ThunderwithR$[esp+4512]
  04450	e9 0e fb ff ff	 jmp	 $LN141@main
$LN799@main:

; 4916 : 	FoundInPTR = Railgun_Quadruplet_6pp(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  04455	83 c0 fd	 add	 eax, -3			; fffffffdH
  04458	e9 10 02 00 00	 jmp	 $LN484@main
$LN687@main:
  0445d	8a 48 ff	 mov	 cl, BYTE PTR [eax-1]
  04460	0f be 50 fe	 movsx	 edx, BYTE PTR [eax-2]
  04464	0f be d9	 movsx	 ebx, cl
  04467	c1 e2 08	 shl	 edx, 8
  0446a	03 d3		 add	 edx, ebx
  0446c	3b f2		 cmp	 esi, edx
  0446e	74 2c		 je	 SHORT $LN801@main
  04470	8b d6		 mov	 edx, esi
  04472	c1 ea 08	 shr	 edx, 8
  04475	eb 04		 jmp	 SHORT $LN503@main
$LL1025@main:
  04477	8b 7c 24 50	 mov	 edi, DWORD PTR _pbTargetMax$7824[esp+4512]
$LN503@main:
  0447b	3a d1		 cmp	 dl, cl
  0447d	74 01		 je	 SHORT $LN500@main
  0447f	40		 inc	 eax
$LN500@main:
  04480	40		 inc	 eax
  04481	3b c7		 cmp	 eax, edi
  04483	0f 87 4d fc ff
	ff		 ja	 $LN131@main
  04489	8a 48 ff	 mov	 cl, BYTE PTR [eax-1]
  0448c	0f be 78 fe	 movsx	 edi, BYTE PTR [eax-2]
  04490	0f be d9	 movsx	 ebx, cl
  04493	c1 e7 08	 shl	 edi, 8
  04496	03 fb		 add	 edi, ebx
  04498	3b f7		 cmp	 esi, edi
  0449a	75 db		 jne	 SHORT $LL1025@main
$LN801@main:
  0449c	83 c0 fe	 add	 eax, -2			; fffffffeH
  0449f	e9 c9 01 00 00	 jmp	 $LN484@main
$LN512@main:
  044a4	81 fa c1 03 00
	00		 cmp	 edx, 961		; 000003c1H
  044aa	0f 83 f1 00 00
	00		 jae	 $LN497@main
  044b0	8d 14 18	 lea	 edx, DWORD PTR [eax+ebx]
  044b3	0f b6 84 24 b0
	09 00 00	 movzx	 eax, BYTE PTR _Pattern$[esp+4512]
  044bb	8b c8		 mov	 ecx, eax
  044bd	c1 e1 08	 shl	 ecx, 8
  044c0	89 4c 24 40	 mov	 DWORD PTR _Quadruplet2nd$7830[esp+4512], ecx
  044c4	8b c8		 mov	 ecx, eax
  044c6	c1 e1 10	 shl	 ecx, 16			; 00000010H
  044c9	8b f8		 mov	 edi, eax
  044cb	c1 e7 18	 shl	 edi, 24			; 00000018H
  044ce	89 54 24 34	 mov	 DWORD PTR $T7883[esp+4512], edx
  044d2	89 4c 24 14	 mov	 DWORD PTR _Quadruplet3rd$7831[esp+4512], ecx
  044d6	89 7c 24 44	 mov	 DWORD PTR _Quadruplet4th$7832[esp+4512], edi
  044da	8d 9b 00 00 00
	00		 npad	 6
$LL496@main:
  044e0	8b c2		 mov	 eax, edx
  044e2	2b c3		 sub	 eax, ebx
  044e4	8b 00		 mov	 eax, DWORD PTR [eax]
  044e6	33 f6		 xor	 esi, esi
  044e8	39 84 24 b0 09
	00 00		 cmp	 DWORD PTR _Pattern$[esp+4512], eax
  044ef	75 63		 jne	 SHORT $LN494@main
  044f1	8d 43 ff	 lea	 eax, DWORD PTR [ebx-1]
  044f4	85 c0		 test	 eax, eax
  044f6	74 43		 je	 SHORT $LN916@main
  044f8	8b 7c 24 2c	 mov	 edi, DWORD PTR _Patternlen$[esp+4512]
  044fc	8b ca		 mov	 ecx, edx
  044fe	2b c8		 sub	 ecx, eax
  04500	2b f8		 sub	 edi, eax
  04502	8d bc 3c b0 09
	00 00		 lea	 edi, DWORD PTR _Pattern$[esp+edi+4512]
  04509	8d a4 24 00 00
	00 00		 npad	 7
$LL493@main:
  04510	8a 19		 mov	 bl, BYTE PTR [ecx]
  04512	38 1f		 cmp	 BYTE PTR [edi], bl
  04514	75 30		 jne	 SHORT $LN492@main
  04516	8b 54 24 2c	 mov	 edx, DWORD PTR _Patternlen$[esp+4512]
  0451a	4a		 dec	 edx
  0451b	8d 1c 30	 lea	 ebx, DWORD PTR [eax+esi]
  0451e	3b d3		 cmp	 edx, ebx
  04520	75 10		 jne	 SHORT $LN491@main
  04522	0f be 19	 movsx	 ebx, BYTE PTR [ecx]
  04525	0f b6 94 24 b0
	09 00 00	 movzx	 edx, BYTE PTR _Pattern$[esp+4512]
  0452d	3b d3		 cmp	 edx, ebx
  0452f	74 01		 je	 SHORT $LN491@main
  04531	46		 inc	 esi
$LN491@main:
  04532	8b 54 24 34	 mov	 edx, DWORD PTR $T7883[esp+4512]
  04536	47		 inc	 edi
  04537	41		 inc	 ecx
  04538	48		 dec	 eax
  04539	75 d5		 jne	 SHORT $LL493@main
$LN916@main:
  0453b	2b 54 24 2c	 sub	 edx, DWORD PTR _Patternlen$[esp+4512]
  0453f	8b c2		 mov	 eax, edx
  04541	e9 27 01 00 00	 jmp	 $LN484@main
$LN492@main:
  04546	85 c0		 test	 eax, eax
  04548	74 f1		 je	 SHORT $LN916@main
  0454a	8b 4c 24 14	 mov	 ecx, DWORD PTR _Quadruplet3rd$7831[esp+4512]
  0454e	8b 7c 24 44	 mov	 edi, DWORD PTR _Quadruplet4th$7832[esp+4512]
  04552	eb 32		 jmp	 SHORT $LN486@main
$LN494@main:
  04554	8b d8		 mov	 ebx, eax
  04556	81 e3 00 ff 00
	00		 and	 ebx, 65280		; 0000ff00H
  0455c	39 5c 24 40	 cmp	 DWORD PTR _Quadruplet2nd$7830[esp+4512], ebx
  04560	74 24		 je	 SHORT $LN486@main
  04562	8b d8		 mov	 ebx, eax
  04564	81 e3 00 00 ff
	00		 and	 ebx, 16711680		; 00ff0000H
  0456a	be 01 00 00 00	 mov	 esi, 1
  0456f	3b cb		 cmp	 ecx, ebx
  04571	74 13		 je	 SHORT $LN486@main
  04573	25 00 00 00 ff	 and	 eax, -16777216		; ff000000H
  04578	be 02 00 00 00	 mov	 esi, 2
  0457d	3b f8		 cmp	 edi, eax
  0457f	74 05		 je	 SHORT $LN486@main
  04581	be 03 00 00 00	 mov	 esi, 3
$LN486@main:
  04586	8d 54 32 01	 lea	 edx, DWORD PTR [edx+esi+1]
  0458a	89 54 24 34	 mov	 DWORD PTR $T7883[esp+4512], edx
  0458e	3b 54 24 50	 cmp	 edx, DWORD PTR _pbTargetMax$7824[esp+4512]
  04592	0f 87 3e fb ff
	ff		 ja	 $LN131@main
  04598	8b 5c 24 2c	 mov	 ebx, DWORD PTR _Patternlen$[esp+4512]
  0459c	e9 3f ff ff ff	 jmp	 $LL496@main
$LN497@main:
  045a1	8b 5c 24 2c	 mov	 ebx, DWORD PTR _Patternlen$[esp+4512]
  045a5	8b c3		 mov	 eax, ebx
  045a7	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  045ac	8d bc 24 90 01
	00 00		 lea	 edi, DWORD PTR _bm_bc$7837[esp+4512]
  045b3	f3 ab		 rep stosd
  045b5	8d 4b ff	 lea	 ecx, DWORD PTR [ebx-1]
  045b8	33 c0		 xor	 eax, eax
  045ba	85 c9		 test	 ecx, ecx
  045bc	74 27		 je	 SHORT $LN478@main
  045be	8d 73 ff	 lea	 esi, DWORD PTR [ebx-1]
  045c1	eb 0d 8d a4 24
	00 00 00 00 8d
	9b 00 00 00 00	 npad	 15
$LL480@main:
  045d0	0f be bc 04 b0
	09 00 00	 movsx	 edi, BYTE PTR _Pattern$[esp+eax+4512]
  045d8	89 b4 bc 90 01
	00 00		 mov	 DWORD PTR _bm_bc$7837[esp+edi*4+4512], esi
  045df	40		 inc	 eax
  045e0	4e		 dec	 esi
  045e1	3b c1		 cmp	 eax, ecx
  045e3	72 eb		 jb	 SHORT $LL480@main
$LN478@main:
  045e5	0f be 8c 1c af
	09 00 00	 movsx	 ecx, BYTE PTR _Pattern$[esp+ebx+4511]
  045ed	33 f6		 xor	 esi, esi
  045ef	2b d3		 sub	 edx, ebx
  045f1	89 54 24 40	 mov	 DWORD PTR $T8336[esp+4512], edx
  045f5	89 4c 24 4c	 mov	 DWORD PTR tv4989[esp+4512], ecx
$LN477@main:
  045f9	8b 44 24 34	 mov	 eax, DWORD PTR tv4485[esp+4512]
  045fd	03 c6		 add	 eax, esi
  045ff	0f b6 4c 18 ff	 movzx	 ecx, BYTE PTR [eax+ebx-1]
  04604	89 4c 24 44	 mov	 DWORD PTR tv5188[esp+4512], ecx
  04608	3b 4c 24 4c	 cmp	 ecx, DWORD PTR tv4989[esp+4512]
  0460c	75 47		 jne	 SHORT $LN472@main
  0460e	8b 94 24 b0 09
	00 00		 mov	 edx, DWORD PTR _Pattern$[esp+4512]
  04615	39 10		 cmp	 DWORD PTR [eax], edx
  04617	75 3c		 jne	 SHORT $LN472@main
  04619	8d 4b fc	 lea	 ecx, DWORD PTR [ebx-4]
  0461c	85 c9		 test	 ecx, ecx
  0461e	74 47		 je	 SHORT $LN805@main
  04620	8d 84 24 b4 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4516]
  04627	8b f8		 mov	 edi, eax
  04629	8b d6		 mov	 edx, esi
  0462b	2b d7		 sub	 edx, edi
  0462d	8b 7c 24 34	 mov	 edi, DWORD PTR tv4485[esp+4512]
  04631	89 54 24 14	 mov	 DWORD PTR tv8096[esp+4512], edx
  04635	eb 04		 jmp	 SHORT $LN474@main
$LL987@main:
  04637	8b 54 24 14	 mov	 edx, DWORD PTR tv8096[esp+4512]
$LN474@main:
  0463b	8a 18		 mov	 bl, BYTE PTR [eax]
  0463d	03 d0		 add	 edx, eax
  0463f	3a 5c 3a 04	 cmp	 bl, BYTE PTR [edx+edi+4]
  04643	75 04		 jne	 SHORT $LN989@main
  04645	40		 inc	 eax
  04646	49		 dec	 ecx
  04647	75 ee		 jne	 SHORT $LL987@main
$LN989@main:
  04649	8b 5c 24 2c	 mov	 ebx, DWORD PTR _Patternlen$[esp+4512]
  0464d	85 c9		 test	 ecx, ecx
  0464f	7e 16		 jle	 SHORT $LN805@main
  04651	8b 4c 24 44	 mov	 ecx, DWORD PTR tv5188[esp+4512]
$LN472@main:
  04655	03 b4 8c 90 01
	00 00		 add	 esi, DWORD PTR _bm_bc$7837[esp+ecx*4+4512]
  0465c	3b 74 24 40	 cmp	 esi, DWORD PTR $T8336[esp+4512]
  04660	76 97		 jbe	 SHORT $LN477@main

; 5222 : 	if (ThunderwithR >= Strnglen-1) break;

  04662	e9 6f fa ff ff	 jmp	 $LN131@main
$LN805@main:

; 4916 : 	FoundInPTR = Railgun_Quadruplet_6pp(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  04667	8b 44 24 34	 mov	 eax, DWORD PTR tv4485[esp+4512]
  0466b	03 c6		 add	 eax, esi
$LN484@main:

; 4917 : 	if ( FoundInPTR != NULL) {Railgun_Quadruplet_6pp_GO++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  0466d	85 c0		 test	 eax, eax
  0466f	0f 84 61 fa ff
	ff		 je	 $LN131@main
  04675	2b 44 24 30	 sub	 eax, DWORD PTR _ThunderwithL$[esp+4512]
  04679	8b 4c 24 28	 mov	 ecx, DWORD PTR _Strng$[esp+4512]
  0467d	ff 44 24 74	 inc	 DWORD PTR _Railgun_Quadruplet_6pp_GO$[esp+4512]
  04681	8b 54 24 20	 mov	 edx, DWORD PTR _ThunderwithR$[esp+4512]
  04685	2b c1		 sub	 eax, ecx
  04687	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax
  0468b	e9 58 fa ff ff	 jmp	 $LN130@main
$LN120@main:

; 4949 : 	if ( FoundInPTR != NULL) {KarpRabinKaze_BOOSTEDhits++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  04690	8b ce		 mov	 ecx, esi
  04692	2b cf		 sub	 ecx, edi
  04694	01 4c 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], ecx
$LN119@main:

; 4950 : 	LinesEncountered++;

  04698	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]

; 4951 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;

  0469c	46		 inc	 esi
  0469d	8b fe		 mov	 edi, esi

; 4952 : 	if (ThunderwithR >= Strnglen-1) break;

  0469f	3b 74 24 24	 cmp	 esi, DWORD PTR tv4941[esp+4512]
  046a3	0f 8c 2f fb ff
	ff		 jl	 $LL124@main

; 4953 : 	}
; 4954 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  046a9	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  046ad	83 f8 0f	 cmp	 eax, 15			; 0000000fH
  046b0	74 08		 je	 SHORT $LN126@main
  046b2	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN126@main:

; 4940 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  046ba	40		 inc	 eax
  046bb	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  046bf	83 f8 10	 cmp	 eax, 16			; 00000010H
  046c2	0f 8c 08 fb ff
	ff		 jl	 $LL127@main

; 4955 : }
; 4956 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  046c8	e8 00 00 00 00	 call	 _clock

; 4957 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  046cd	8b 54 24 1c	 mov	 edx, DWORD PTR _LinesEncountered$[esp+4512]
  046d1	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  046d6	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  046dc	52		 push	 edx
  046dd	89 44 24 18	 mov	 DWORD PTR tv7383[esp+4516], eax
  046e1	db 44 24 18	 fild	 DWORD PTR tv7383[esp+4516]
  046e5	68 00 00 00 00	 push	 OFFSET $SG6767
  046ea	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  046f0	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  046f6	e8 00 00 00 00	 call	 _printf

; 4958 : printf( "KarpRabinKaze_BOOSTED_hits/KarpRabinKaze_BOOSTED_clocks: %lu/%lu\n", KarpRabinKaze_BOOSTEDhits>>4, (long)(TotalRoughSearchTime)>>4);

  046fb	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04701	e8 00 00 00 00	 call	 __ftol2_sse
  04706	c1 f8 04	 sar	 eax, 4
  04709	50		 push	 eax
  0470a	8b 44 24 7c	 mov	 eax, DWORD PTR _KarpRabinKaze_BOOSTEDhits$[esp+4524]
  0470e	c1 f8 04	 sar	 eax, 4
  04711	50		 push	 eax
  04712	68 00 00 00 00	 push	 OFFSET $SG6769
  04717	e8 00 00 00 00	 call	 _printf

; 4959 : printf( "KarpRabinKaze_BOOSTED performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  0471c	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04722	e8 00 00 00 00	 call	 __ftol2_sse
  04727	8b 74 24 24	 mov	 esi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  0472b	8b c8		 mov	 ecx, eax
  0472d	8b c6		 mov	 eax, esi
  0472f	99		 cdq
  04730	c1 f9 04	 sar	 ecx, 4
  04733	f7 f9		 idiv	 ecx
  04735	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  04738	50		 push	 eax
  04739	68 00 00 00 00	 push	 OFFSET $SG6771
  0473e	e8 00 00 00 00	 call	 _printf

; 4960 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  04743	56		 push	 esi
  04744	68 00 00 00 00	 push	 OFFSET $SG6772
  04749	e8 00 00 00 00	 call	 _printf
  0474e	83 c4 24	 add	 esp, 36			; 00000024H

; 4961 : // 6]
; 4962 : 
; 4963 : // 2[
; 4964 : clocks1 = clock();

  04751	e8 00 00 00 00	 call	 _clock
  04756	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 4965 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  0475b	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
$LL116@main:

; 4966 : {
; 4967 : //Search area is between Strng[0] .. Strng[n-1]
; 4968 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real

  04763	33 f6		 xor	 esi, esi
  04765	89 74 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], esi

; 4969 : ThunderwithL=0;ThunderwithR=0;

  04769	33 ff		 xor	 edi, edi
  0476b	eb 03 8d 49 00	 npad	 5
$LL113@main:

; 4970 : 	for (;;)
; 4971 : 	{
; 4972 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  04770	80 3c 1e 0a	 cmp	 BYTE PTR [esi+ebx], 10	; 0000000aH
  04774	74 15		 je	 SHORT $LN110@main
  04776	8b 44 24 24	 mov	 eax, DWORD PTR tv4941[esp+4512]
  0477a	8d 9b 00 00 00
	00		 npad	 6
$LL111@main:
  04780	3b f0		 cmp	 esi, eax
  04782	7d 07		 jge	 SHORT $LN110@main
  04784	46		 inc	 esi
  04785	80 3c 1e 0a	 cmp	 BYTE PTR [esi+ebx], 10	; 0000000aH
  04789	75 f5		 jne	 SHORT $LL111@main
$LN110@main:

; 4973 : 	FoundInPTR = KarpRabinKaze(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  0478b	8b 54 24 2c	 mov	 edx, DWORD PTR _Patternlen$[esp+4512]
  0478f	52		 push	 edx
  04790	8b c6		 mov	 eax, esi
  04792	2b c7		 sub	 eax, edi
  04794	50		 push	 eax
  04795	8d 84 24 b8 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4520]
  0479c	8d 0c 1f	 lea	 ecx, DWORD PTR [edi+ebx]
  0479f	50		 push	 eax
  047a0	51		 push	 ecx
  047a1	e8 00 00 00 00	 call	 _KarpRabinKaze
  047a6	83 c4 10	 add	 esp, 16			; 00000010H

; 4974 : 	if ( FoundInPTR != NULL) {KarpRabinKazehits++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  047a9	85 c0		 test	 eax, eax
  047ab	74 0e		 je	 SHORT $LN109@main
  047ad	ff 44 24 7c	 inc	 DWORD PTR _KarpRabinKazehits$[esp+4512]
  047b1	2b c7		 sub	 eax, edi
  047b3	2b c3		 sub	 eax, ebx
  047b5	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax
  047b9	eb 08		 jmp	 SHORT $LN108@main
$LN109@main:
  047bb	8b ce		 mov	 ecx, esi
  047bd	2b cf		 sub	 ecx, edi
  047bf	01 4c 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], ecx
$LN108@main:

; 4975 : 	LinesEncountered++;

  047c3	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]

; 4976 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;

  047c7	46		 inc	 esi
  047c8	8b fe		 mov	 edi, esi

; 4977 : 	if (ThunderwithR >= Strnglen-1) break;

  047ca	3b 74 24 24	 cmp	 esi, DWORD PTR tv4941[esp+4512]
  047ce	7c a0		 jl	 SHORT $LL113@main

; 4978 : 	}
; 4979 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  047d0	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  047d4	83 f8 0f	 cmp	 eax, 15			; 0000000fH
  047d7	74 08		 je	 SHORT $LN115@main
  047d9	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN115@main:

; 4965 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  047e1	40		 inc	 eax
  047e2	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  047e6	83 f8 10	 cmp	 eax, 16			; 00000010H
  047e9	0f 8c 74 ff ff
	ff		 jl	 $LL116@main

; 4980 : }
; 4981 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  047ef	e8 00 00 00 00	 call	 _clock

; 4982 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  047f4	8b 54 24 1c	 mov	 edx, DWORD PTR _LinesEncountered$[esp+4512]
  047f8	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  047fd	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  04803	52		 push	 edx
  04804	89 44 24 18	 mov	 DWORD PTR tv7361[esp+4516], eax
  04808	db 44 24 18	 fild	 DWORD PTR tv7361[esp+4516]
  0480c	68 00 00 00 00	 push	 OFFSET $SG6787
  04811	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  04817	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  0481d	e8 00 00 00 00	 call	 _printf

; 4983 : printf( "KarpRabinKaze_hits/KarpRabinKaze_clocks: %lu/%lu\n", KarpRabinKazehits>>4, (long)(TotalRoughSearchTime)>>4);

  04822	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04828	e8 00 00 00 00	 call	 __ftol2_sse
  0482d	c1 f8 04	 sar	 eax, 4
  04830	50		 push	 eax
  04831	8b 84 24 88 00
	00 00		 mov	 eax, DWORD PTR _KarpRabinKazehits$[esp+4524]
  04838	c1 f8 04	 sar	 eax, 4
  0483b	50		 push	 eax
  0483c	68 00 00 00 00	 push	 OFFSET $SG6789
  04841	e8 00 00 00 00	 call	 _printf

; 4984 : printf( "KarpRabinKaze performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  04846	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  0484c	e8 00 00 00 00	 call	 __ftol2_sse
  04851	8b 74 24 24	 mov	 esi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  04855	8b c8		 mov	 ecx, eax
  04857	8b c6		 mov	 eax, esi
  04859	99		 cdq
  0485a	c1 f9 04	 sar	 ecx, 4
  0485d	f7 f9		 idiv	 ecx
  0485f	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  04862	50		 push	 eax
  04863	68 00 00 00 00	 push	 OFFSET $SG6791
  04868	e8 00 00 00 00	 call	 _printf

; 4985 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  0486d	56		 push	 esi
  0486e	68 00 00 00 00	 push	 OFFSET $SG6792
  04873	e8 00 00 00 00	 call	 _printf
  04878	83 c4 24	 add	 esp, 36			; 00000024H

; 4986 : // 2]
; 4987 : 
; 4988 : // 3[
; 4989 : clocks1 = clock();

  0487b	e8 00 00 00 00	 call	 _clock
  04880	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 4990 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  04885	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
  0488d	8d 49 00	 npad	 3
$LL105@main:

; 4991 : {
; 4992 : //Search area is between Strng[0] .. Strng[n-1]
; 4993 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real

  04890	33 f6		 xor	 esi, esi
  04892	89 74 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], esi

; 4994 : ThunderwithL=0;ThunderwithR=0;

  04896	33 ff		 xor	 edi, edi
$LL102@main:

; 4995 : 	for (;;)
; 4996 : 	{
; 4997 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  04898	80 3c 1e 0a	 cmp	 BYTE PTR [esi+ebx], 10	; 0000000aH
  0489c	74 0f		 je	 SHORT $LN99@main
  0489e	8b 44 24 24	 mov	 eax, DWORD PTR tv4941[esp+4512]
$LL100@main:
  048a2	3b f0		 cmp	 esi, eax
  048a4	7d 07		 jge	 SHORT $LN99@main
  048a6	46		 inc	 esi
  048a7	80 3c 1e 0a	 cmp	 BYTE PTR [esi+ebx], 10	; 0000000aH
  048ab	75 f5		 jne	 SHORT $LL100@main
$LN99@main:

; 4998 : 	FoundIn = Karp_Rabin(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  048ad	8b 54 24 2c	 mov	 edx, DWORD PTR _Patternlen$[esp+4512]
  048b1	52		 push	 edx
  048b2	8b c6		 mov	 eax, esi
  048b4	2b c7		 sub	 eax, edi
  048b6	50		 push	 eax
  048b7	8d 84 24 b8 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4520]
  048be	8d 0c 1f	 lea	 ecx, DWORD PTR [edi+ebx]
  048c1	50		 push	 eax
  048c2	51		 push	 ecx
  048c3	e8 00 00 00 00	 call	 _Karp_Rabin
  048c8	83 c4 10	 add	 esp, 16			; 00000010H

; 4999 : 	if ( FoundIn != -1) {KarpRabinhits++; StrnglenTRAVERSED=StrnglenTRAVERSED+FoundIn;} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  048cb	83 f8 ff	 cmp	 eax, -1
  048ce	74 0a		 je	 SHORT $LN98@main
  048d0	ff 44 24 78	 inc	 DWORD PTR _KarpRabinhits$[esp+4512]
  048d4	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax
  048d8	eb 08		 jmp	 SHORT $LN97@main
$LN98@main:
  048da	8b ce		 mov	 ecx, esi
  048dc	2b cf		 sub	 ecx, edi
  048de	01 4c 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], ecx
$LN97@main:

; 5000 : 	LinesEncountered++;

  048e2	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]

; 5001 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;

  048e6	46		 inc	 esi
  048e7	8b fe		 mov	 edi, esi

; 5002 : 	if (ThunderwithR >= Strnglen-1) break;

  048e9	3b 74 24 24	 cmp	 esi, DWORD PTR tv4941[esp+4512]
  048ed	7c a9		 jl	 SHORT $LL102@main

; 5003 : 	}
; 5004 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  048ef	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  048f3	83 f8 0f	 cmp	 eax, 15			; 0000000fH
  048f6	74 08		 je	 SHORT $LN104@main
  048f8	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN104@main:

; 4990 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  04900	40		 inc	 eax
  04901	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  04905	83 f8 10	 cmp	 eax, 16			; 00000010H
  04908	7c 86		 jl	 SHORT $LL105@main

; 5005 : }
; 5006 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  0490a	e8 00 00 00 00	 call	 _clock

; 5007 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  0490f	8b 54 24 1c	 mov	 edx, DWORD PTR _LinesEncountered$[esp+4512]
  04913	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  04918	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  0491e	52		 push	 edx
  0491f	89 44 24 18	 mov	 DWORD PTR tv7338[esp+4516], eax
  04923	db 44 24 18	 fild	 DWORD PTR tv7338[esp+4516]
  04927	68 00 00 00 00	 push	 OFFSET $SG6806
  0492c	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  04932	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  04938	e8 00 00 00 00	 call	 _printf

; 5008 : printf( "Karp_Rabin_hits/Karp_Rabin_clocks: %lu/%lu\n", KarpRabinhits>>4, (long)(TotalRoughSearchTime)>>4);

  0493d	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04943	e8 00 00 00 00	 call	 __ftol2_sse
  04948	c1 f8 04	 sar	 eax, 4
  0494b	50		 push	 eax
  0494c	8b 84 24 84 00
	00 00		 mov	 eax, DWORD PTR _KarpRabinhits$[esp+4524]
  04953	c1 f8 04	 sar	 eax, 4
  04956	50		 push	 eax
  04957	68 00 00 00 00	 push	 OFFSET $SG6808
  0495c	e8 00 00 00 00	 call	 _printf

; 5009 : printf( "Karp_Rabin performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  04961	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04967	e8 00 00 00 00	 call	 __ftol2_sse
  0496c	8b 74 24 24	 mov	 esi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  04970	8b c8		 mov	 ecx, eax
  04972	8b c6		 mov	 eax, esi
  04974	99		 cdq
  04975	c1 f9 04	 sar	 ecx, 4
  04978	f7 f9		 idiv	 ecx
  0497a	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  0497d	50		 push	 eax
  0497e	68 00 00 00 00	 push	 OFFSET $SG6810
  04983	e8 00 00 00 00	 call	 _printf

; 5010 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  04988	56		 push	 esi
  04989	68 00 00 00 00	 push	 OFFSET $SG6811
  0498e	e8 00 00 00 00	 call	 _printf
  04993	83 c4 24	 add	 esp, 36			; 00000024H

; 5011 : // 3]
; 5012 : 
; 5013 : // 1[
; 5014 : clocks1 = clock();

  04996	e8 00 00 00 00	 call	 _clock

; 5015 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  0499b	8b 54 24 2c	 mov	 edx, DWORD PTR _Patternlen$[esp+4512]
  0499f	33 c9		 xor	 ecx, ecx
  049a1	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax
  049a6	8b 44 24 24	 mov	 eax, DWORD PTR tv4941[esp+4512]
  049aa	89 4c 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], ecx
  049ae	eb 02		 jmp	 SHORT $LN94@main
$LL1053@main:
  049b0	33 c9		 xor	 ecx, ecx
$LN94@main:

; 5016 : {
; 5017 : //Search area is between Strng[0] .. Strng[n-1]
; 5018 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real

  049b2	89 4c 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], ecx

; 5019 : ThunderwithL=0;ThunderwithR=0;

  049b6	89 4c 24 30	 mov	 DWORD PTR _ThunderwithL$[esp+4512], ecx
$LN91@main:

; 5020 : 	for (;;)
; 5021 : 	{
; 5022 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  049ba	80 3c 19 0a	 cmp	 BYTE PTR [ecx+ebx], 10	; 0000000aH
  049be	74 0b		 je	 SHORT $LN88@main
$LL89@main:
  049c0	3b c8		 cmp	 ecx, eax
  049c2	7d 07		 jge	 SHORT $LN88@main
  049c4	41		 inc	 ecx
  049c5	80 3c 19 0a	 cmp	 BYTE PTR [ecx+ebx], 10	; 0000000aH
  049c9	75 f5		 jne	 SHORT $LL89@main
$LN88@main:

; 5023 : 	FoundIn = Brute_Force_Dummy(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  049cb	8b c1		 mov	 eax, ecx
  049cd	2b 44 24 30	 sub	 eax, DWORD PTR _ThunderwithL$[esp+4512]
  049d1	33 f6		 xor	 esi, esi
  049d3	2b c2		 sub	 eax, edx
  049d5	89 44 24 14	 mov	 DWORD PTR $T8337[esp+4512], eax
  049d9	78 44		 js	 SHORT $LN87@main
  049db	eb 03 8d 49 00	 npad	 5
$LL521@main:
  049e0	33 c0		 xor	 eax, eax
  049e2	85 d2		 test	 edx, edx
  049e4	7e 1f		 jle	 SHORT $LN522@main
  049e6	8b 7c 24 30	 mov	 edi, DWORD PTR _ThunderwithL$[esp+4512]
  049ea	03 fb		 add	 edi, ebx
  049ec	03 fe		 add	 edi, esi
  049ee	8b ff		 npad	 2
$LL518@main:
  049f0	8a 14 07	 mov	 dl, BYTE PTR [edi+eax]
  049f3	3a 94 04 b0 09
	00 00		 cmp	 dl, BYTE PTR _Pattern$[esp+eax+4512]
  049fa	8b 54 24 2c	 mov	 edx, DWORD PTR _Patternlen$[esp+4512]
  049fe	75 14		 jne	 SHORT $LN517@main
  04a00	40		 inc	 eax
  04a01	3b c2		 cmp	 eax, edx
  04a03	7c eb		 jl	 SHORT $LL518@main
$LN522@main:

; 5024 : 	if ( FoundIn != -1) {BruteForceDummyhits++; StrnglenTRAVERSED=StrnglenTRAVERSED+FoundIn;} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  04a05	83 fe ff	 cmp	 esi, -1
  04a08	74 15		 je	 SHORT $LN87@main
  04a0a	ff 44 24 60	 inc	 DWORD PTR _BruteForceDummyhits$[esp+4512]
  04a0e	01 74 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], esi
  04a12	eb 15		 jmp	 SHORT $LN86@main

; 5023 : 	FoundIn = Brute_Force_Dummy(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

$LN517@main:
  04a14	3b c2		 cmp	 eax, edx
  04a16	7d ed		 jge	 SHORT $LN522@main
  04a18	46		 inc	 esi
  04a19	3b 74 24 14	 cmp	 esi, DWORD PTR $T8337[esp+4512]
  04a1d	7e c1		 jle	 SHORT $LL521@main
$LN87@main:

; 5024 : 	if ( FoundIn != -1) {BruteForceDummyhits++; StrnglenTRAVERSED=StrnglenTRAVERSED+FoundIn;} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  04a1f	8b c1		 mov	 eax, ecx
  04a21	2b 44 24 30	 sub	 eax, DWORD PTR _ThunderwithL$[esp+4512]
  04a25	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax
$LN86@main:

; 5025 : 	LinesEncountered++;
; 5026 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;
; 5027 : 	if (ThunderwithR >= Strnglen-1) break;

  04a29	8b 44 24 48	 mov	 eax, DWORD PTR _Strnglen$[esp+4512]
  04a2d	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]
  04a31	41		 inc	 ecx
  04a32	48		 dec	 eax
  04a33	89 4c 24 30	 mov	 DWORD PTR _ThunderwithL$[esp+4512], ecx
  04a37	89 44 24 24	 mov	 DWORD PTR tv4941[esp+4512], eax
  04a3b	3b c8		 cmp	 ecx, eax
  04a3d	0f 8c 77 ff ff
	ff		 jl	 $LN91@main

; 5028 : 	}
; 5029 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  04a43	8b 4c 24 18	 mov	 ecx, DWORD PTR _Bozan$[esp+4512]
  04a47	83 f9 0f	 cmp	 ecx, 15			; 0000000fH
  04a4a	74 08		 je	 SHORT $LN93@main
  04a4c	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN93@main:

; 5015 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  04a54	41		 inc	 ecx
  04a55	89 4c 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], ecx
  04a59	83 f9 10	 cmp	 ecx, 16			; 00000010H
  04a5c	0f 8c 4e ff ff
	ff		 jl	 $LL1053@main

; 5030 : }
; 5031 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  04a62	e8 00 00 00 00	 call	 _clock

; 5032 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  04a67	8b 4c 24 1c	 mov	 ecx, DWORD PTR _LinesEncountered$[esp+4512]
  04a6b	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  04a70	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  04a76	51		 push	 ecx
  04a77	89 44 24 18	 mov	 DWORD PTR tv7316[esp+4516], eax
  04a7b	db 44 24 18	 fild	 DWORD PTR tv7316[esp+4516]
  04a7f	68 00 00 00 00	 push	 OFFSET $SG6825
  04a84	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  04a8a	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  04a90	e8 00 00 00 00	 call	 _printf

; 5033 : printf( "Brute_Force_Dummy_hits/Brute_Force_Dummy_clocks: %lu/%lu\n", BruteForceDummyhits>>4, (long)(TotalRoughSearchTime)>>4);

  04a95	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04a9b	e8 00 00 00 00	 call	 __ftol2_sse
  04aa0	c1 f8 04	 sar	 eax, 4
  04aa3	50		 push	 eax
  04aa4	8b 44 24 6c	 mov	 eax, DWORD PTR _BruteForceDummyhits$[esp+4524]
  04aa8	c1 f8 04	 sar	 eax, 4
  04aab	50		 push	 eax
  04aac	68 00 00 00 00	 push	 OFFSET $SG6827
  04ab1	e8 00 00 00 00	 call	 _printf

; 5034 : printf( "Brute_Force_Dummy performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  04ab6	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04abc	e8 00 00 00 00	 call	 __ftol2_sse
  04ac1	8b 74 24 24	 mov	 esi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  04ac5	8b c8		 mov	 ecx, eax
  04ac7	8b c6		 mov	 eax, esi
  04ac9	99		 cdq
  04aca	c1 f9 04	 sar	 ecx, 4
  04acd	f7 f9		 idiv	 ecx
  04acf	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  04ad2	50		 push	 eax
  04ad3	68 00 00 00 00	 push	 OFFSET $SG6829
  04ad8	e8 00 00 00 00	 call	 _printf

; 5035 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  04add	56		 push	 esi
  04ade	68 00 00 00 00	 push	 OFFSET $SG6830
  04ae3	e8 00 00 00 00	 call	 _printf
  04ae8	83 c4 24	 add	 esp, 36			; 00000024H

; 5036 : // 1]
; 5037 : 
; 5038 : // 4[
; 5039 : clocks1 = clock();

  04aeb	e8 00 00 00 00	 call	 _clock
  04af0	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 5040 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  04af5	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
  04afd	8d 49 00	 npad	 3
$LL83@main:

; 5041 : {
; 5042 : //Search area is between Strng[0] .. Strng[n-1]
; 5043 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real

  04b00	33 f6		 xor	 esi, esi
  04b02	89 74 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], esi

; 5044 : ThunderwithL=0;ThunderwithR=0;

  04b06	33 ff		 xor	 edi, edi
$LL80@main:

; 5045 : 	for (;;)
; 5046 : 	{
; 5047 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  04b08	80 3c 1e 0a	 cmp	 BYTE PTR [esi+ebx], 10	; 0000000aH
  04b0c	74 0f		 je	 SHORT $LN77@main
  04b0e	8b 44 24 24	 mov	 eax, DWORD PTR tv4941[esp+4512]
$LL78@main:
  04b12	3b f0		 cmp	 esi, eax
  04b14	7d 07		 jge	 SHORT $LN77@main
  04b16	46		 inc	 esi
  04b17	80 3c 1e 0a	 cmp	 BYTE PTR [esi+ebx], 10	; 0000000aH
  04b1b	75 f5		 jne	 SHORT $LL78@main
$LN77@main:

; 5048 : 	FoundIn = HORSPOOL(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  04b1d	8b 54 24 2c	 mov	 edx, DWORD PTR _Patternlen$[esp+4512]
  04b21	52		 push	 edx
  04b22	8b c6		 mov	 eax, esi
  04b24	2b c7		 sub	 eax, edi
  04b26	50		 push	 eax
  04b27	8d 84 24 b8 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4520]
  04b2e	8d 0c 1f	 lea	 ecx, DWORD PTR [edi+ebx]
  04b31	50		 push	 eax
  04b32	51		 push	 ecx
  04b33	e8 00 00 00 00	 call	 _HORSPOOL
  04b38	83 c4 10	 add	 esp, 16			; 00000010H

; 5049 : 	if ( FoundIn != -1) {HORSPOOLhits++; StrnglenTRAVERSED=StrnglenTRAVERSED+FoundIn;} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  04b3b	83 f8 ff	 cmp	 eax, -1
  04b3e	74 0a		 je	 SHORT $LN76@main
  04b40	ff 44 24 68	 inc	 DWORD PTR _HORSPOOLhits$[esp+4512]
  04b44	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax
  04b48	eb 08		 jmp	 SHORT $LN75@main
$LN76@main:
  04b4a	8b ce		 mov	 ecx, esi
  04b4c	2b cf		 sub	 ecx, edi
  04b4e	01 4c 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], ecx
$LN75@main:

; 5050 : 	LinesEncountered++;

  04b52	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]

; 5051 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;

  04b56	46		 inc	 esi
  04b57	8b fe		 mov	 edi, esi

; 5052 : 	if (ThunderwithR >= Strnglen-1) break;

  04b59	3b 74 24 24	 cmp	 esi, DWORD PTR tv4941[esp+4512]
  04b5d	7c a9		 jl	 SHORT $LL80@main

; 5053 : 	}
; 5054 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  04b5f	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  04b63	83 f8 0f	 cmp	 eax, 15			; 0000000fH
  04b66	74 08		 je	 SHORT $LN82@main
  04b68	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN82@main:

; 5040 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  04b70	40		 inc	 eax
  04b71	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  04b75	83 f8 10	 cmp	 eax, 16			; 00000010H
  04b78	7c 86		 jl	 SHORT $LL83@main

; 5055 : }
; 5056 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  04b7a	e8 00 00 00 00	 call	 _clock

; 5057 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  04b7f	8b 54 24 1c	 mov	 edx, DWORD PTR _LinesEncountered$[esp+4512]
  04b83	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  04b88	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  04b8e	52		 push	 edx
  04b8f	89 44 24 18	 mov	 DWORD PTR tv7295[esp+4516], eax
  04b93	db 44 24 18	 fild	 DWORD PTR tv7295[esp+4516]
  04b97	68 00 00 00 00	 push	 OFFSET $SG6844
  04b9c	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  04ba2	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  04ba8	e8 00 00 00 00	 call	 _printf

; 5058 : printf( "Boyer-Moore-Horspool_hits/Boyer-Moore-Horspool_clocks: %lu/%lu\n", HORSPOOLhits>>4, (long)(TotalRoughSearchTime)>>4);

  04bad	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04bb3	e8 00 00 00 00	 call	 __ftol2_sse
  04bb8	c1 f8 04	 sar	 eax, 4
  04bbb	50		 push	 eax
  04bbc	8b 44 24 74	 mov	 eax, DWORD PTR _HORSPOOLhits$[esp+4524]
  04bc0	c1 f8 04	 sar	 eax, 4
  04bc3	50		 push	 eax
  04bc4	68 00 00 00 00	 push	 OFFSET $SG6846
  04bc9	e8 00 00 00 00	 call	 _printf

; 5059 : printf( "Boyer-Moore-Horspool performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  04bce	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04bd4	e8 00 00 00 00	 call	 __ftol2_sse
  04bd9	8b 74 24 24	 mov	 esi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  04bdd	8b c8		 mov	 ecx, eax
  04bdf	8b c6		 mov	 eax, esi
  04be1	99		 cdq
  04be2	c1 f9 04	 sar	 ecx, 4
  04be5	f7 f9		 idiv	 ecx
  04be7	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  04bea	50		 push	 eax
  04beb	68 00 00 00 00	 push	 OFFSET $SG6848
  04bf0	e8 00 00 00 00	 call	 _printf

; 5060 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  04bf5	56		 push	 esi
  04bf6	68 00 00 00 00	 push	 OFFSET $SG6849
  04bfb	e8 00 00 00 00	 call	 _printf
  04c00	83 c4 24	 add	 esp, 36			; 00000024H

; 5061 : // 4]
; 5062 : 
; 5063 : // 5[
; 5064 : clocks1 = clock();

  04c03	e8 00 00 00 00	 call	 _clock
  04c08	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 5065 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  04c0d	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
$LL72@main:

; 5066 : {
; 5067 : //Search area is between Strng[0] .. Strng[n-1]
; 5068 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real

  04c15	33 f6		 xor	 esi, esi
  04c17	89 74 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], esi

; 5069 : ThunderwithL=0;ThunderwithR=0;

  04c1b	33 ff		 xor	 edi, edi
  04c1d	8d 49 00	 npad	 3
$LL69@main:

; 5070 : 	for (;;)
; 5071 : 	{
; 5072 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  04c20	80 3c 1e 0a	 cmp	 BYTE PTR [esi+ebx], 10	; 0000000aH
  04c24	74 15		 je	 SHORT $LN66@main
  04c26	8b 44 24 24	 mov	 eax, DWORD PTR tv4941[esp+4512]
  04c2a	8d 9b 00 00 00
	00		 npad	 6
$LL67@main:
  04c30	3b f0		 cmp	 esi, eax
  04c32	7d 07		 jge	 SHORT $LN66@main
  04c34	46		 inc	 esi
  04c35	80 3c 1e 0a	 cmp	 BYTE PTR [esi+ebx], 10	; 0000000aH
  04c39	75 f5		 jne	 SHORT $LL67@main
$LN66@main:

; 5073 : 	FoundIn = Boyer_Moore_Horspool_Kaze(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  04c3b	8b 54 24 2c	 mov	 edx, DWORD PTR _Patternlen$[esp+4512]
  04c3f	52		 push	 edx
  04c40	8b c6		 mov	 eax, esi
  04c42	2b c7		 sub	 eax, edi
  04c44	50		 push	 eax
  04c45	8d 84 24 b8 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4520]
  04c4c	8d 0c 1f	 lea	 ecx, DWORD PTR [edi+ebx]
  04c4f	50		 push	 eax
  04c50	51		 push	 ecx
  04c51	e8 00 00 00 00	 call	 _Boyer_Moore_Horspool_Kaze
  04c56	83 c4 10	 add	 esp, 16			; 00000010H

; 5074 : 	if ( FoundIn != -1) {HORSPOOL_Kazehits++; StrnglenTRAVERSED=StrnglenTRAVERSED+FoundIn;} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  04c59	83 f8 ff	 cmp	 eax, -1
  04c5c	74 0a		 je	 SHORT $LN65@main
  04c5e	ff 44 24 58	 inc	 DWORD PTR _HORSPOOL_Kazehits$[esp+4512]
  04c62	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax
  04c66	eb 08		 jmp	 SHORT $LN64@main
$LN65@main:
  04c68	8b ce		 mov	 ecx, esi
  04c6a	2b cf		 sub	 ecx, edi
  04c6c	01 4c 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], ecx
$LN64@main:

; 5075 : 	LinesEncountered++;

  04c70	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]

; 5076 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;

  04c74	46		 inc	 esi
  04c75	8b fe		 mov	 edi, esi

; 5077 : 	if (ThunderwithR >= Strnglen-1) break;

  04c77	3b 74 24 24	 cmp	 esi, DWORD PTR tv4941[esp+4512]
  04c7b	7c a3		 jl	 SHORT $LL69@main

; 5078 : 	}
; 5079 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  04c7d	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  04c81	83 f8 0f	 cmp	 eax, 15			; 0000000fH
  04c84	74 08		 je	 SHORT $LN71@main
  04c86	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN71@main:

; 5065 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  04c8e	40		 inc	 eax
  04c8f	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  04c93	83 f8 10	 cmp	 eax, 16			; 00000010H
  04c96	0f 8c 79 ff ff
	ff		 jl	 $LL72@main

; 5080 : }
; 5081 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  04c9c	e8 00 00 00 00	 call	 _clock

; 5082 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  04ca1	8b 54 24 1c	 mov	 edx, DWORD PTR _LinesEncountered$[esp+4512]
  04ca5	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  04caa	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  04cb0	52		 push	 edx
  04cb1	89 44 24 18	 mov	 DWORD PTR tv7274[esp+4516], eax
  04cb5	db 44 24 18	 fild	 DWORD PTR tv7274[esp+4516]
  04cb9	68 00 00 00 00	 push	 OFFSET $SG6863
  04cbe	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  04cc4	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  04cca	e8 00 00 00 00	 call	 _printf

; 5083 : printf( "Boyer_Moore_Horspool_Kaze_hits/Boyer_Moore_Horspool_Kaze_clocks: %lu/%lu\n", HORSPOOL_Kazehits>>4, (long)(TotalRoughSearchTime)>>4);

  04ccf	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04cd5	e8 00 00 00 00	 call	 __ftol2_sse
  04cda	c1 f8 04	 sar	 eax, 4
  04cdd	50		 push	 eax
  04cde	8b 44 24 64	 mov	 eax, DWORD PTR _HORSPOOL_Kazehits$[esp+4524]
  04ce2	c1 f8 04	 sar	 eax, 4
  04ce5	50		 push	 eax
  04ce6	68 00 00 00 00	 push	 OFFSET $SG6865
  04ceb	e8 00 00 00 00	 call	 _printf

; 5084 : printf( "Boyer_Moore_Horspool_Kaze performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  04cf0	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04cf6	e8 00 00 00 00	 call	 __ftol2_sse
  04cfb	8b 74 24 24	 mov	 esi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  04cff	8b c8		 mov	 ecx, eax
  04d01	8b c6		 mov	 eax, esi
  04d03	99		 cdq
  04d04	c1 f9 04	 sar	 ecx, 4
  04d07	f7 f9		 idiv	 ecx
  04d09	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  04d0c	50		 push	 eax
  04d0d	68 00 00 00 00	 push	 OFFSET $SG6867
  04d12	e8 00 00 00 00	 call	 _printf

; 5085 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  04d17	56		 push	 esi
  04d18	68 00 00 00 00	 push	 OFFSET $SG6868
  04d1d	e8 00 00 00 00	 call	 _printf

; 5086 : // 5]
; 5087 : 
; 5088 : 
; 5089 : 
; 5090 : // DUMBO ... [
; 5091 : printf( "\nDUMBO 8x2 ...\n");

  04d22	68 00 00 00 00	 push	 OFFSET $SG6869
  04d27	e8 00 00 00 00	 call	 _printf
  04d2c	83 c4 28	 add	 esp, 40			; 00000028H

; 5092 : for (i = 0; i<8; i++)

  04d2f	c7 44 24 24 00
	00 00 00	 mov	 DWORD PTR _i$[esp+4512], 0
$LN61@main:

; 5093 :    {
; 5094 : for (j = 0; j<2; j++)

  04d37	c7 44 24 68 00
	00 00 00	 mov	 DWORD PTR _j$[esp+4512], 0
  04d3f	90		 npad	 1
$LL58@main:

; 5095 :    {
; 5096 : 
; 5097 : strcpy (Pattern, DumboBox[i][j]);

  04d40	8b 54 24 68	 mov	 edx, DWORD PTR _j$[esp+4512]
  04d44	8b 44 24 24	 mov	 eax, DWORD PTR _i$[esp+4512]
  04d48	8d 0c 42	 lea	 ecx, DWORD PTR [edx+eax*2]
  04d4b	8b 84 8c 80 00
	00 00		 mov	 eax, DWORD PTR _DumboBox$[esp+ecx*4+4512]
  04d52	8d 94 24 b0 09
	00 00		 lea	 edx, DWORD PTR _Pattern$[esp+4512]
  04d59	2b d0		 sub	 edx, eax
  04d5b	eb 03 8d 49 00	 npad	 5
$LL287@main:
  04d60	8a 08		 mov	 cl, BYTE PTR [eax]
  04d62	88 0c 10	 mov	 BYTE PTR [eax+edx], cl
  04d65	40		 inc	 eax
  04d66	84 c9		 test	 cl, cl
  04d68	75 f6		 jne	 SHORT $LL287@main

; 5098 : Patternlen = strlen(&Pattern[0]);

  04d6a	8d 84 24 b0 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4512]
  04d71	8d 50 01	 lea	 edx, DWORD PTR [eax+1]
$LL936@main:
  04d74	8a 08		 mov	 cl, BYTE PTR [eax]
  04d76	40		 inc	 eax
  04d77	84 c9		 test	 cl, cl
  04d79	75 f9		 jne	 SHORT $LL936@main
  04d7b	2b c2		 sub	 eax, edx

; 5099 : 
; 5100 : printf( "\nSearching for Pattern('%s',%dbytes) into String(%dbytes) line-by-line ...\n\n", Pattern, Patternlen, Strnglen);

  04d7d	8b 54 24 48	 mov	 edx, DWORD PTR _Strnglen$[esp+4512]
  04d81	52		 push	 edx
  04d82	50		 push	 eax
  04d83	89 44 24 34	 mov	 DWORD PTR tv4483[esp+4520], eax
  04d87	8d 84 24 b8 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4520]
  04d8e	50		 push	 eax
  04d8f	68 00 00 00 00	 push	 OFFSET $SG6876
  04d94	e8 00 00 00 00	 call	 _printf
  04d99	83 c4 10	 add	 esp, 16			; 00000010H

; 5101 : 
; 5102 : 
; 5103 : // 7[
; 5104 : clocks1 = clock();

  04d9c	e8 00 00 00 00	 call	 _clock
  04da1	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 5105 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  04da6	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
  04dae	8b ff		 npad	 2
$LL55@main:

; 5106 : {
; 5107 : strstrMicrosofthits=0;

  04db0	33 ff		 xor	 edi, edi
  04db2	89 7c 24 6c	 mov	 DWORD PTR _strstrMicrosofthits$[esp+4512], edi

; 5108 : //Search area is between Strng[0] .. Strng[n-1]
; 5109 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real

  04db6	89 7c 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], edi

; 5110 : ThunderwithL=0;ThunderwithR=0;

  04dba	89 7c 24 30	 mov	 DWORD PTR _ThunderwithL$[esp+4512], edi
  04dbe	8b ff		 npad	 2
$LL52@main:

; 5111 : 	for (;;)
; 5112 : 	{
; 5113 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  04dc0	8b 54 24 28	 mov	 edx, DWORD PTR _Strng$[esp+4512]
  04dc4	80 3c 17 0a	 cmp	 BYTE PTR [edi+edx], 10	; 0000000aH
  04dc8	74 14		 je	 SHORT $LN49@main
  04dca	8b 4c 24 48	 mov	 ecx, DWORD PTR _Strnglen$[esp+4512]
  04dce	8b ff		 npad	 2
$LL50@main:
  04dd0	8d 41 ff	 lea	 eax, DWORD PTR [ecx-1]
  04dd3	3b f8		 cmp	 edi, eax
  04dd5	7d 07		 jge	 SHORT $LN49@main
  04dd7	47		 inc	 edi
  04dd8	80 3c 17 0a	 cmp	 BYTE PTR [edi+edx], 10	; 0000000aH
  04ddc	75 f2		 jne	 SHORT $LL50@main
$LN49@main:

; 5114 : 	FoundInPTR = strstr_Microsoft(&Strng[ThunderwithL], &Pattern[0]);

  04dde	80 bc 24 b0 09
	00 00 00	 cmp	 BYTE PTR _Pattern$[esp+4512], 0
  04de6	8b 4c 24 30	 mov	 ecx, DWORD PTR _ThunderwithL$[esp+4512]
  04dea	8d 34 11	 lea	 esi, DWORD PTR [ecx+edx]
  04ded	0f 84 76 01 00
	00		 je	 $LN1101@main
  04df3	8a 0e		 mov	 cl, BYTE PTR [esi]
  04df5	84 c9		 test	 cl, cl
  04df7	74 43		 je	 SHORT $LN48@main
  04df9	8b d6		 mov	 edx, esi
  04dfb	8d 84 24 b0 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4512]
  04e02	2b d0		 sub	 edx, eax
$LL528@main:
  04e04	8d 84 24 b0 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4512]
  04e0b	84 c9		 test	 cl, cl
  04e0d	74 1b		 je	 SHORT $LN525@main
$LN526@main:
  04e0f	8a 08		 mov	 cl, BYTE PTR [eax]
  04e11	84 c9		 test	 cl, cl
  04e13	0f 84 4c 01 00
	00		 je	 $LN814@main
  04e19	0f be 1c 10	 movsx	 ebx, BYTE PTR [eax+edx]
  04e1d	0f be c9	 movsx	 ecx, cl
  04e20	2b d9		 sub	 ebx, ecx
  04e22	75 06		 jne	 SHORT $LN525@main
  04e24	40		 inc	 eax
  04e25	38 1c 10	 cmp	 BYTE PTR [eax+edx], bl
  04e28	75 e5		 jne	 SHORT $LN526@main
$LN525@main:
  04e2a	80 38 00	 cmp	 BYTE PTR [eax], 0
  04e2d	0f 84 32 01 00
	00		 je	 $LN814@main
  04e33	8a 4e 01	 mov	 cl, BYTE PTR [esi+1]
  04e36	46		 inc	 esi
  04e37	42		 inc	 edx
  04e38	84 c9		 test	 cl, cl
  04e3a	75 c8		 jne	 SHORT $LL528@main
$LN48@main:

; 5115 : 	if ( FoundInPTR != NULL) {strstrMicrosofthits++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  04e3c	8b d7		 mov	 edx, edi
  04e3e	2b 54 24 30	 sub	 edx, DWORD PTR _ThunderwithL$[esp+4512]
  04e42	01 54 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], edx
$LN47@main:

; 5116 : 	LinesEncountered++;
; 5117 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;
; 5118 : 	if (ThunderwithR >= Strnglen-1) break;

  04e46	8b 5c 24 48	 mov	 ebx, DWORD PTR _Strnglen$[esp+4512]
  04e4a	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]
  04e4e	47		 inc	 edi
  04e4f	4b		 dec	 ebx
  04e50	89 7c 24 30	 mov	 DWORD PTR _ThunderwithL$[esp+4512], edi
  04e54	3b fb		 cmp	 edi, ebx
  04e56	0f 8c 64 ff ff
	ff		 jl	 $LL52@main

; 5119 : 	}
; 5120 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  04e5c	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  04e60	83 f8 0f	 cmp	 eax, 15			; 0000000fH
  04e63	74 08		 je	 SHORT $LN54@main
  04e65	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN54@main:

; 5105 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  04e6d	40		 inc	 eax
  04e6e	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  04e72	83 f8 10	 cmp	 eax, 16			; 00000010H
  04e75	0f 8c 35 ff ff
	ff		 jl	 $LL55@main

; 5121 : }
; 5122 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  04e7b	e8 00 00 00 00	 call	 _clock
  04e80	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  04e85	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  04e8b	89 44 24 14	 mov	 DWORD PTR tv7240[esp+4512], eax
  04e8f	db 44 24 14	 fild	 DWORD PTR tv7240[esp+4512]

; 5123 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  04e93	8b 44 24 1c	 mov	 eax, DWORD PTR _LinesEncountered$[esp+4512]
  04e97	50		 push	 eax
  04e98	68 00 00 00 00	 push	 OFFSET $SG6891
  04e9d	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  04ea3	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  04ea9	e8 00 00 00 00	 call	 _printf

; 5124 : printf( "strstr_Microsoft_hits/strstr_Microsoft_clocks: %lu/%lu\n", strstrMicrosofthits, (long)(TotalRoughSearchTime)>>4);

  04eae	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04eb4	e8 00 00 00 00	 call	 __ftol2_sse
  04eb9	8b 4c 24 74	 mov	 ecx, DWORD PTR _strstrMicrosofthits$[esp+4520]
  04ebd	c1 f8 04	 sar	 eax, 4
  04ec0	50		 push	 eax
  04ec1	51		 push	 ecx
  04ec2	68 00 00 00 00	 push	 OFFSET $SG6893
  04ec7	e8 00 00 00 00	 call	 _printf

; 5125 : printf( "strstr_Microsoft performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  04ecc	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04ed2	e8 00 00 00 00	 call	 __ftol2_sse
  04ed7	8b 74 24 24	 mov	 esi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  04edb	8b c8		 mov	 ecx, eax
  04edd	8b c6		 mov	 eax, esi
  04edf	99		 cdq
  04ee0	c1 f9 04	 sar	 ecx, 4
  04ee3	f7 f9		 idiv	 ecx
  04ee5	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  04ee8	50		 push	 eax
  04ee9	68 00 00 00 00	 push	 OFFSET $SG6895
  04eee	e8 00 00 00 00	 call	 _printf

; 5126 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  04ef3	56		 push	 esi
  04ef4	68 00 00 00 00	 push	 OFFSET $SG6896
  04ef9	e8 00 00 00 00	 call	 _printf
  04efe	83 c4 24	 add	 esp, 36			; 00000024H

; 5127 : // 7]
; 5128 : 
; 5129 : // 8[
; 5130 : clocks1 = clock();

  04f01	e8 00 00 00 00	 call	 _clock
  04f06	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 5131 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  04f0b	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
$LL44@main:

; 5132 : {
; 5133 : strstrGNUCLibraryhits=0;

  04f13	33 f6		 xor	 esi, esi
  04f15	89 74 24 64	 mov	 DWORD PTR _strstrGNUCLibraryhits$[esp+4512], esi

; 5134 : //Search area is between Strng[0] .. Strng[n-1]
; 5135 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real

  04f19	89 74 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], esi

; 5136 : ThunderwithL=0;ThunderwithR=0;

  04f1d	33 ff		 xor	 edi, edi
  04f1f	90		 npad	 1
$LL41@main:

; 5137 : 	for (;;)
; 5138 : 	{
; 5139 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  04f20	8b 44 24 28	 mov	 eax, DWORD PTR _Strng$[esp+4512]
  04f24	80 3c 06 0a	 cmp	 BYTE PTR [esi+eax], 10	; 0000000aH
  04f28	74 11		 je	 SHORT $LN38@main
  04f2a	8d 9b 00 00 00
	00		 npad	 6
$LL39@main:
  04f30	3b f3		 cmp	 esi, ebx
  04f32	7d 07		 jge	 SHORT $LN38@main
  04f34	46		 inc	 esi
  04f35	80 3c 06 0a	 cmp	 BYTE PTR [esi+eax], 10	; 0000000aH
  04f39	75 f5		 jne	 SHORT $LL39@main
$LN38@main:

; 5140 : 	FoundInPTR = strstr_GNU_C_Library(&Strng[ThunderwithL], &Pattern[0]);

  04f3b	8b d0		 mov	 edx, eax
  04f3d	8d 8c 24 b0 09
	00 00		 lea	 ecx, DWORD PTR _Pattern$[esp+4512]
  04f44	8d 04 17	 lea	 eax, DWORD PTR [edi+edx]
  04f47	51		 push	 ecx
  04f48	50		 push	 eax
  04f49	e8 00 00 00 00	 call	 _strstr_GNU_C_Library
  04f4e	83 c4 08	 add	 esp, 8

; 5141 : 	if ( FoundInPTR != 0) {strstrGNUCLibraryhits++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  04f51	85 c0		 test	 eax, eax
  04f53	74 31		 je	 SHORT $LN37@main
  04f55	ff 44 24 64	 inc	 DWORD PTR _strstrGNUCLibraryhits$[esp+4512]
  04f59	2b c7		 sub	 eax, edi
  04f5b	2b 44 24 28	 sub	 eax, DWORD PTR _Strng$[esp+4512]
  04f5f	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax
  04f63	eb 29		 jmp	 SHORT $LN36@main
$LN814@main:

; 5114 : 	FoundInPTR = strstr_Microsoft(&Strng[ThunderwithL], &Pattern[0]);

  04f65	8b 54 24 28	 mov	 edx, DWORD PTR _Strng$[esp+4512]
$LN1101@main:
  04f69	8b c6		 mov	 eax, esi

; 5115 : 	if ( FoundInPTR != NULL) {strstrMicrosofthits++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  04f6b	85 c0		 test	 eax, eax
  04f6d	0f 84 c9 fe ff
	ff		 je	 $LN48@main
  04f73	2b 44 24 30	 sub	 eax, DWORD PTR _ThunderwithL$[esp+4512]
  04f77	ff 44 24 6c	 inc	 DWORD PTR _strstrMicrosofthits$[esp+4512]
  04f7b	2b c2		 sub	 eax, edx
  04f7d	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax
  04f81	e9 c0 fe ff ff	 jmp	 $LN47@main
$LN37@main:

; 5141 : 	if ( FoundInPTR != 0) {strstrGNUCLibraryhits++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  04f86	8b d6		 mov	 edx, esi
  04f88	2b d7		 sub	 edx, edi
  04f8a	01 54 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], edx
$LN36@main:

; 5142 : 	LinesEncountered++;

  04f8e	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]

; 5143 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;

  04f92	46		 inc	 esi
  04f93	8b fe		 mov	 edi, esi

; 5144 : 	if (ThunderwithR >= Strnglen-1) break;

  04f95	3b f3		 cmp	 esi, ebx
  04f97	7c 87		 jl	 SHORT $LL41@main

; 5145 : 	}
; 5146 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  04f99	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  04f9d	83 f8 0f	 cmp	 eax, 15			; 0000000fH
  04fa0	74 08		 je	 SHORT $LN43@main
  04fa2	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN43@main:

; 5131 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  04faa	40		 inc	 eax
  04fab	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  04faf	83 f8 10	 cmp	 eax, 16			; 00000010H
  04fb2	0f 8c 5b ff ff
	ff		 jl	 $LL44@main

; 5147 : }
; 5148 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  04fb8	e8 00 00 00 00	 call	 _clock
  04fbd	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  04fc2	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  04fc8	89 44 24 14	 mov	 DWORD PTR tv7218[esp+4512], eax
  04fcc	db 44 24 14	 fild	 DWORD PTR tv7218[esp+4512]

; 5149 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  04fd0	8b 44 24 1c	 mov	 eax, DWORD PTR _LinesEncountered$[esp+4512]
  04fd4	50		 push	 eax
  04fd5	68 00 00 00 00	 push	 OFFSET $SG6910
  04fda	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  04fe0	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  04fe6	e8 00 00 00 00	 call	 _printf

; 5150 : printf( "strstr_GNU_C_Library_hits/strstr_GNU_C_Library_clocks: %lu/%lu\n", strstrGNUCLibraryhits, (long)(TotalRoughSearchTime)>>4);

  04feb	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  04ff1	e8 00 00 00 00	 call	 __ftol2_sse
  04ff6	8b 4c 24 6c	 mov	 ecx, DWORD PTR _strstrGNUCLibraryhits$[esp+4520]
  04ffa	c1 f8 04	 sar	 eax, 4
  04ffd	50		 push	 eax
  04ffe	51		 push	 ecx
  04fff	68 00 00 00 00	 push	 OFFSET $SG6912
  05004	e8 00 00 00 00	 call	 _printf

; 5151 : printf( "strstr_GNU_C_Library performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  05009	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  0500f	e8 00 00 00 00	 call	 __ftol2_sse
  05014	8b 74 24 24	 mov	 esi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  05018	8b c8		 mov	 ecx, eax
  0501a	8b c6		 mov	 eax, esi
  0501c	99		 cdq
  0501d	c1 f9 04	 sar	 ecx, 4
  05020	f7 f9		 idiv	 ecx
  05022	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  05025	50		 push	 eax
  05026	68 00 00 00 00	 push	 OFFSET $SG6914
  0502b	e8 00 00 00 00	 call	 _printf

; 5152 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  05030	56		 push	 esi
  05031	68 00 00 00 00	 push	 OFFSET $SG6915
  05036	e8 00 00 00 00	 call	 _printf
  0503b	83 c4 24	 add	 esp, 36			; 00000024H

; 5153 : // 8]
; 5154 : 
; 5155 : // 9[
; 5156 : clocks1 = clock();

  0503e	e8 00 00 00 00	 call	 _clock
  05043	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 5157 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  05048	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
$LL33@main:

; 5158 : {
; 5159 : Karp_Rabin_Kaze_4_OCTETShits=0;

  05050	33 f6		 xor	 esi, esi
  05052	89 74 24 4c	 mov	 DWORD PTR _Karp_Rabin_Kaze_4_OCTETShits$[esp+4512], esi

; 5160 : //Search area is between Strng[0] .. Strng[n-1]
; 5161 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real

  05056	89 74 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], esi

; 5162 : ThunderwithL=0;ThunderwithR=0;

  0505a	33 ff		 xor	 edi, edi
  0505c	8d 64 24 00	 npad	 4
$LL30@main:

; 5163 : 	for (;;)
; 5164 : 	{
; 5165 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  05060	8b 44 24 28	 mov	 eax, DWORD PTR _Strng$[esp+4512]
  05064	80 3c 06 0a	 cmp	 BYTE PTR [esi+eax], 10	; 0000000aH
  05068	74 11		 je	 SHORT $LN27@main
  0506a	8d 9b 00 00 00
	00		 npad	 6
$LL28@main:
  05070	3b f3		 cmp	 esi, ebx
  05072	7d 07		 jge	 SHORT $LN27@main
  05074	46		 inc	 esi
  05075	80 3c 06 0a	 cmp	 BYTE PTR [esi+eax], 10	; 0000000aH
  05079	75 f5		 jne	 SHORT $LL28@main
$LN27@main:

; 5166 : 	FoundInPTR = Railgun(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  0507b	8b 54 24 28	 mov	 edx, DWORD PTR _Strng$[esp+4512]
  0507f	8d 0c 17	 lea	 ecx, DWORD PTR [edi+edx]
  05082	8b 54 24 2c	 mov	 edx, DWORD PTR tv4483[esp+4512]
  05086	52		 push	 edx
  05087	8b c6		 mov	 eax, esi
  05089	2b c7		 sub	 eax, edi
  0508b	50		 push	 eax
  0508c	8d 84 24 b8 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4520]
  05093	50		 push	 eax
  05094	51		 push	 ecx
  05095	e8 00 00 00 00	 call	 _Railgun
  0509a	83 c4 10	 add	 esp, 16			; 00000010H

; 5167 : 	if ( FoundInPTR != NULL) {Karp_Rabin_Kaze_4_OCTETShits++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  0509d	85 c0		 test	 eax, eax
  0509f	74 10		 je	 SHORT $LN26@main
  050a1	ff 44 24 4c	 inc	 DWORD PTR _Karp_Rabin_Kaze_4_OCTETShits$[esp+4512]
  050a5	2b c7		 sub	 eax, edi
  050a7	2b 44 24 28	 sub	 eax, DWORD PTR _Strng$[esp+4512]
  050ab	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax
  050af	eb 08		 jmp	 SHORT $LN25@main
$LN26@main:
  050b1	8b ce		 mov	 ecx, esi
  050b3	2b cf		 sub	 ecx, edi
  050b5	01 4c 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], ecx
$LN25@main:

; 5168 : 	LinesEncountered++;

  050b9	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]

; 5169 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;

  050bd	46		 inc	 esi
  050be	8b fe		 mov	 edi, esi

; 5170 : 	if (ThunderwithR >= Strnglen-1) break;

  050c0	3b f3		 cmp	 esi, ebx
  050c2	7c 9c		 jl	 SHORT $LL30@main

; 5171 : 	}
; 5172 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  050c4	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  050c8	83 f8 0f	 cmp	 eax, 15			; 0000000fH
  050cb	74 08		 je	 SHORT $LN32@main
  050cd	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN32@main:

; 5157 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  050d5	40		 inc	 eax
  050d6	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  050da	83 f8 10	 cmp	 eax, 16			; 00000010H
  050dd	0f 8c 6d ff ff
	ff		 jl	 $LL33@main

; 5173 : }
; 5174 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  050e3	e8 00 00 00 00	 call	 _clock

; 5175 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  050e8	8b 54 24 1c	 mov	 edx, DWORD PTR _LinesEncountered$[esp+4512]
  050ec	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  050f1	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  050f7	52		 push	 edx
  050f8	89 44 24 18	 mov	 DWORD PTR tv7196[esp+4516], eax
  050fc	db 44 24 18	 fild	 DWORD PTR tv7196[esp+4516]
  05100	68 00 00 00 00	 push	 OFFSET $SG6930
  05105	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  0510b	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  05111	e8 00 00 00 00	 call	 _printf

; 5176 : printf( "Railgun_hits/Railgun_clocks: %lu/%lu\n", Karp_Rabin_Kaze_4_OCTETShits, (long)(TotalRoughSearchTime)>>4);

  05116	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  0511c	e8 00 00 00 00	 call	 __ftol2_sse
  05121	c1 f8 04	 sar	 eax, 4
  05124	50		 push	 eax
  05125	8b 44 24 58	 mov	 eax, DWORD PTR _Karp_Rabin_Kaze_4_OCTETShits$[esp+4524]
  05129	50		 push	 eax
  0512a	68 00 00 00 00	 push	 OFFSET $SG6932
  0512f	e8 00 00 00 00	 call	 _printf

; 5177 : printf( "Railgun performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  05134	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  0513a	e8 00 00 00 00	 call	 __ftol2_sse
  0513f	8b 74 24 24	 mov	 esi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  05143	8b c8		 mov	 ecx, eax
  05145	8b c6		 mov	 eax, esi
  05147	99		 cdq
  05148	c1 f9 04	 sar	 ecx, 4
  0514b	f7 f9		 idiv	 ecx
  0514d	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  05150	50		 push	 eax
  05151	68 00 00 00 00	 push	 OFFSET $SG6934
  05156	e8 00 00 00 00	 call	 _printf

; 5178 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  0515b	56		 push	 esi
  0515c	68 00 00 00 00	 push	 OFFSET $SG6935
  05161	e8 00 00 00 00	 call	 _printf
  05166	83 c4 24	 add	 esp, 36			; 00000024H

; 5179 : // 9]
; 5180 : 
; 5181 : // +[
; 5182 : clocks1 = clock();

  05169	e8 00 00 00 00	 call	 _clock
  0516e	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 5183 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  05173	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
  0517b	eb 03 8d 49 00	 npad	 5
$LL22@main:

; 5184 : {
; 5185 : Karp_Rabin_Kaze_4_OCTETShits_DOUBLET=0;

  05180	33 c0		 xor	 eax, eax
  05182	89 44 24 54	 mov	 DWORD PTR _Karp_Rabin_Kaze_4_OCTETShits_DOUBLET$[esp+4512], eax

; 5186 : //Search area is between Strng[0] .. Strng[n-1]
; 5187 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real

  05186	89 44 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax

; 5188 : ThunderwithL=0;ThunderwithR=0;

  0518a	89 44 24 30	 mov	 DWORD PTR _ThunderwithL$[esp+4512], eax
  0518e	89 44 24 20	 mov	 DWORD PTR _ThunderwithR$[esp+4512], eax
$LL19@main:

; 5189 : 	for (;;)
; 5190 : 	{
; 5191 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  05192	8b 44 24 20	 mov	 eax, DWORD PTR _ThunderwithR$[esp+4512]
  05196	8b 4c 24 28	 mov	 ecx, DWORD PTR _Strng$[esp+4512]
  0519a	80 3c 08 0a	 cmp	 BYTE PTR [eax+ecx], 10	; 0000000aH
  0519e	74 0f		 je	 SHORT $LN16@main
$LL17@main:
  051a0	3b c3		 cmp	 eax, ebx
  051a2	7d 07		 jge	 SHORT $LN1057@main
  051a4	40		 inc	 eax
  051a5	80 3c 08 0a	 cmp	 BYTE PTR [eax+ecx], 10	; 0000000aH
  051a9	75 f5		 jne	 SHORT $LL17@main
$LN1057@main:
  051ab	89 44 24 20	 mov	 DWORD PTR _ThunderwithR$[esp+4512], eax
$LN16@main:

; 5192 : 	FoundInPTR = Railgun_Quadruplet(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  051af	8b 5c 24 30	 mov	 ebx, DWORD PTR _ThunderwithL$[esp+4512]
  051b3	8b 54 24 20	 mov	 edx, DWORD PTR _ThunderwithR$[esp+4512]
  051b7	2b d3		 sub	 edx, ebx
  051b9	03 d9		 add	 ebx, ecx
  051bb	8b 4c 24 2c	 mov	 ecx, DWORD PTR tv4483[esp+4512]
  051bf	8d 3c 1a	 lea	 edi, DWORD PTR [edx+ebx]
  051c2	89 7c 24 60	 mov	 DWORD PTR _pbTargetMax$7912[esp+4512], edi
  051c6	3b ca		 cmp	 ecx, edx
  051c8	77 5b		 ja	 SHORT $LN15@main
  051ca	83 f9 04	 cmp	 ecx, 4
  051cd	0f 83 3e 03 00
	00		 jae	 $LN572@main
  051d3	0f be 94 24 b0
	09 00 00	 movsx	 edx, BYTE PTR _Pattern$[esp+4512]
  051db	0f be b4 0c af
	09 00 00	 movsx	 esi, BYTE PTR _Pattern$[esp+ecx+4511]
  051e3	c1 e2 08	 shl	 edx, 8
  051e6	03 f2		 add	 esi, edx
  051e8	8d 04 0b	 lea	 eax, DWORD PTR [ebx+ecx]
  051eb	83 f9 03	 cmp	 ecx, 3
  051ee	0f 85 d6 02 00
	00		 jne	 $LN732@main
$LL570@main:
  051f4	0f be 48 fd	 movsx	 ecx, BYTE PTR [eax-3]
  051f8	0f be 50 ff	 movsx	 edx, BYTE PTR [eax-1]
  051fc	c1 e1 08	 shl	 ecx, 8
  051ff	03 ca		 add	 ecx, edx
  05201	3b f1		 cmp	 esi, ecx
  05203	75 10		 jne	 SHORT $LN567@main
  05205	8a 8c 24 b1 09
	00 00		 mov	 cl, BYTE PTR _Pattern$[esp+4513]
  0520c	3a 48 fe	 cmp	 cl, BYTE PTR [eax-2]
  0520f	0f 84 ad 02 00
	00		 je	 $LN818@main
$LN567@main:
  05215	8b d6		 mov	 edx, esi
  05217	c1 ea 08	 shr	 edx, 8
  0521a	3a 50 fe	 cmp	 dl, BYTE PTR [eax-2]
  0521d	74 01		 je	 SHORT $LN566@main
  0521f	40		 inc	 eax
$LN566@main:
  05220	40		 inc	 eax
  05221	3b c7		 cmp	 eax, edi
  05223	76 cf		 jbe	 SHORT $LL570@main
$LN15@main:

; 5193 : 	if ( FoundInPTR != NULL) {Karp_Rabin_Kaze_4_OCTETShits_DOUBLET++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  05225	8b 44 24 20	 mov	 eax, DWORD PTR _ThunderwithR$[esp+4512]
  05229	8b c8		 mov	 ecx, eax
  0522b	2b 4c 24 30	 sub	 ecx, DWORD PTR _ThunderwithL$[esp+4512]
  0522f	01 4c 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], ecx
$LN14@main:

; 5194 : 	LinesEncountered++;
; 5195 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;
; 5196 : 	if (ThunderwithR >= Strnglen-1) break;

  05233	8b 5c 24 48	 mov	 ebx, DWORD PTR _Strnglen$[esp+4512]
  05237	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]
  0523b	40		 inc	 eax
  0523c	4b		 dec	 ebx
  0523d	89 44 24 20	 mov	 DWORD PTR _ThunderwithR$[esp+4512], eax
  05241	89 44 24 30	 mov	 DWORD PTR _ThunderwithL$[esp+4512], eax
  05245	3b c3		 cmp	 eax, ebx
  05247	0f 8c 45 ff ff
	ff		 jl	 $LL19@main

; 5197 : 	}
; 5198 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  0524d	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  05251	83 f8 0f	 cmp	 eax, 15			; 0000000fH
  05254	74 08		 je	 SHORT $LN21@main
  05256	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN21@main:

; 5183 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  0525e	40		 inc	 eax
  0525f	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  05263	83 f8 10	 cmp	 eax, 16			; 00000010H
  05266	0f 8c 14 ff ff
	ff		 jl	 $LL22@main

; 5199 : }
; 5200 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  0526c	e8 00 00 00 00	 call	 _clock

; 5201 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  05271	8b 54 24 1c	 mov	 edx, DWORD PTR _LinesEncountered$[esp+4512]
  05275	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  0527a	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  05280	52		 push	 edx
  05281	89 44 24 18	 mov	 DWORD PTR tv7161[esp+4516], eax
  05285	db 44 24 18	 fild	 DWORD PTR tv7161[esp+4516]
  05289	68 00 00 00 00	 push	 OFFSET $SG6950
  0528e	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  05294	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  0529a	e8 00 00 00 00	 call	 _printf

; 5202 : printf( "Railgun_Quadruplet_hits/Railgun_Quadruplet_clocks: %lu/%lu\n", Karp_Rabin_Kaze_4_OCTETShits_DOUBLET, (long)(TotalRoughSearchTime)>>4);

  0529f	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  052a5	e8 00 00 00 00	 call	 __ftol2_sse
  052aa	c1 f8 04	 sar	 eax, 4
  052ad	50		 push	 eax
  052ae	8b 44 24 60	 mov	 eax, DWORD PTR _Karp_Rabin_Kaze_4_OCTETShits_DOUBLET$[esp+4524]
  052b2	50		 push	 eax
  052b3	68 00 00 00 00	 push	 OFFSET $SG6952
  052b8	e8 00 00 00 00	 call	 _printf

; 5203 : printf( "Railgun_Quadruplet performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  052bd	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  052c3	e8 00 00 00 00	 call	 __ftol2_sse
  052c8	8b 74 24 24	 mov	 esi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  052cc	8b c8		 mov	 ecx, eax
  052ce	8b c6		 mov	 eax, esi
  052d0	99		 cdq
  052d1	c1 f9 04	 sar	 ecx, 4
  052d4	f7 f9		 idiv	 ecx
  052d6	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  052d9	50		 push	 eax
  052da	68 00 00 00 00	 push	 OFFSET $SG6954
  052df	e8 00 00 00 00	 call	 _printf

; 5204 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  052e4	56		 push	 esi
  052e5	68 00 00 00 00	 push	 OFFSET $SG6955
  052ea	e8 00 00 00 00	 call	 _printf
  052ef	83 c4 24	 add	 esp, 36			; 00000024H

; 5205 : // +]
; 5206 : 
; 5207 : // Z[
; 5208 : clocks1 = clock();

  052f2	e8 00 00 00 00	 call	 _clock
  052f7	a3 00 00 00 00	 mov	 DWORD PTR _clocks1, eax

; 5209 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  052fc	c7 44 24 18 00
	00 00 00	 mov	 DWORD PTR _Bozan$[esp+4512], 0
$LL11@main:

; 5210 : {
; 5211 : Karp_Rabin_Kaze_4_OCTETShits_DOUBLET=0;

  05304	33 c0		 xor	 eax, eax
  05306	89 44 24 54	 mov	 DWORD PTR _Karp_Rabin_Kaze_4_OCTETShits_DOUBLET$[esp+4512], eax

; 5212 : //Search area is between Strng[0] .. Strng[n-1]
; 5213 : StrnglenTRAVERSED=0; // Only traversed chars i.e. real

  0530a	89 44 24 10	 mov	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax

; 5214 : ThunderwithL=0;ThunderwithR=0;

  0530e	89 44 24 30	 mov	 DWORD PTR _ThunderwithL$[esp+4512], eax
  05312	89 44 24 20	 mov	 DWORD PTR _ThunderwithR$[esp+4512], eax
  05316	eb 08 8d a4 24
	00 00 00 00 90	 npad	 10
$LL8@main:

; 5215 : 	for (;;)
; 5216 : 	{
; 5217 : 	while (Strng[ThunderwithR] != 10 && ThunderwithR < Strnglen-1) {ThunderwithR++;}

  05320	8b 44 24 20	 mov	 eax, DWORD PTR _ThunderwithR$[esp+4512]
  05324	8b 4c 24 28	 mov	 ecx, DWORD PTR _Strng$[esp+4512]
  05328	80 3c 08 0a	 cmp	 BYTE PTR [eax+ecx], 10	; 0000000aH
  0532c	74 11		 je	 SHORT $LN5@main
  0532e	8b ff		 npad	 2
$LL6@main:
  05330	3b c3		 cmp	 eax, ebx
  05332	7d 07		 jge	 SHORT $LN1058@main
  05334	40		 inc	 eax
  05335	80 3c 08 0a	 cmp	 BYTE PTR [eax+ecx], 10	; 0000000aH
  05339	75 f5		 jne	 SHORT $LL6@main
$LN1058@main:
  0533b	89 44 24 20	 mov	 DWORD PTR _ThunderwithR$[esp+4512], eax
$LN5@main:

; 5218 : 	FoundInPTR = Railgun_Quadruplet_6pp(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  0533f	8b 5c 24 30	 mov	 ebx, DWORD PTR _ThunderwithL$[esp+4512]
  05343	8b 54 24 20	 mov	 edx, DWORD PTR _ThunderwithR$[esp+4512]
  05347	2b d3		 sub	 edx, ebx
  05349	03 d9		 add	 ebx, ecx
  0534b	8b 4c 24 2c	 mov	 ecx, DWORD PTR tv4483[esp+4512]
  0534f	8d 3c 1a	 lea	 edi, DWORD PTR [edx+ebx]
  05352	89 7c 24 60	 mov	 DWORD PTR _pbTargetMax$7976[esp+4512], edi
  05356	3b ca		 cmp	 ecx, edx
  05358	77 5b		 ja	 SHORT $LN4@main
  0535a	83 f9 04	 cmp	 ecx, 4
  0535d	0f 83 e0 03 00
	00		 jae	 $LN616@main
  05363	0f be 94 24 b0
	09 00 00	 movsx	 edx, BYTE PTR _Pattern$[esp+4512]
  0536b	0f be b4 0c af
	09 00 00	 movsx	 esi, BYTE PTR _Pattern$[esp+ecx+4511]
  05373	c1 e2 08	 shl	 edx, 8
  05376	03 f2		 add	 esi, edx
  05378	8d 04 0b	 lea	 eax, DWORD PTR [ebx+ecx]
  0537b	83 f9 03	 cmp	 ecx, 3
  0537e	0f 85 78 03 00
	00		 jne	 $LN743@main
$LL614@main:
  05384	0f be 48 fd	 movsx	 ecx, BYTE PTR [eax-3]
  05388	0f be 50 ff	 movsx	 edx, BYTE PTR [eax-1]
  0538c	c1 e1 08	 shl	 ecx, 8
  0538f	03 ca		 add	 ecx, edx
  05391	3b f1		 cmp	 esi, ecx
  05393	75 10		 jne	 SHORT $LN611@main
  05395	8a 8c 24 b1 09
	00 00		 mov	 cl, BYTE PTR _Pattern$[esp+4513]
  0539c	3a 48 fe	 cmp	 cl, BYTE PTR [eax-2]
  0539f	0f 84 4f 03 00
	00		 je	 $LN826@main
$LN611@main:
  053a5	8b d6		 mov	 edx, esi
  053a7	c1 ea 08	 shr	 edx, 8
  053aa	3a 50 fe	 cmp	 dl, BYTE PTR [eax-2]
  053ad	74 01		 je	 SHORT $LN610@main
  053af	40		 inc	 eax
$LN610@main:
  053b0	40		 inc	 eax
  053b1	3b c7		 cmp	 eax, edi
  053b3	76 cf		 jbe	 SHORT $LL614@main
$LN4@main:

; 5219 : 	if ( FoundInPTR != NULL) {Karp_Rabin_Kaze_4_OCTETShits_DOUBLET++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  053b5	8b 4c 24 20	 mov	 ecx, DWORD PTR _ThunderwithR$[esp+4512]
  053b9	2b 4c 24 30	 sub	 ecx, DWORD PTR _ThunderwithL$[esp+4512]
  053bd	01 4c 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], ecx
$LN3@main:

; 5220 : 	LinesEncountered++;
; 5221 : 	ThunderwithR++;	ThunderwithL=ThunderwithR;

  053c1	8b 44 24 20	 mov	 eax, DWORD PTR _ThunderwithR$[esp+4512]

; 5222 : 	if (ThunderwithR >= Strnglen-1) break;

  053c5	8b 5c 24 48	 mov	 ebx, DWORD PTR _Strnglen$[esp+4512]
  053c9	ff 44 24 1c	 inc	 DWORD PTR _LinesEncountered$[esp+4512]
  053cd	40		 inc	 eax
  053ce	4b		 dec	 ebx
  053cf	89 44 24 20	 mov	 DWORD PTR _ThunderwithR$[esp+4512], eax
  053d3	89 44 24 30	 mov	 DWORD PTR _ThunderwithL$[esp+4512], eax
  053d7	3b c3		 cmp	 eax, ebx
  053d9	0f 8c 41 ff ff
	ff		 jl	 $LL8@main

; 5223 : 	}
; 5224 : if (Bozan != (1<<4)-1) LinesEncountered=0;

  053df	8b 44 24 18	 mov	 eax, DWORD PTR _Bozan$[esp+4512]
  053e3	83 f8 0f	 cmp	 eax, 15			; 0000000fH
  053e6	74 08		 je	 SHORT $LN10@main
  053e8	c7 44 24 1c 00
	00 00 00	 mov	 DWORD PTR _LinesEncountered$[esp+4512], 0
$LN10@main:

; 5209 :     for (Bozan=0; Bozan < (1<<4); Bozan++) // 16 times, at end >>4

  053f0	40		 inc	 eax
  053f1	89 44 24 18	 mov	 DWORD PTR _Bozan$[esp+4512], eax
  053f5	83 f8 10	 cmp	 eax, 16			; 00000010H
  053f8	0f 8c 06 ff ff
	ff		 jl	 $LL11@main

; 5225 : }
; 5226 : clocks2 = clock(); TotalRoughSearchTime = clocks2 - clocks1; TotalRoughSearchTime++;

  053fe	e8 00 00 00 00	 call	 _clock

; 5227 : printf( "LinesEncountered: %lu\n", LinesEncountered);

  05403	8b 54 24 1c	 mov	 edx, DWORD PTR _LinesEncountered$[esp+4512]
  05407	a3 00 00 00 00	 mov	 DWORD PTR _clocks2, eax
  0540c	2b 05 00 00 00
	00		 sub	 eax, DWORD PTR _clocks1
  05412	52		 push	 edx
  05413	89 44 24 18	 mov	 DWORD PTR tv7129[esp+4516], eax
  05417	db 44 24 18	 fild	 DWORD PTR tv7129[esp+4516]
  0541b	68 00 00 00 00	 push	 OFFSET $SG6970
  05420	dc 05 00 00 00
	00		 fadd	 QWORD PTR __real@3ff0000000000000
  05426	dd 1d 00 00 00
	00		 fstp	 QWORD PTR _TotalRoughSearchTime
  0542c	e8 00 00 00 00	 call	 _printf

; 5228 : printf( "Railgun_Quadruplet_6pp_hits/Railgun_Quadruplet_6pp_clocks: %lu/%lu\n", Karp_Rabin_Kaze_4_OCTETShits_DOUBLET, (long)(TotalRoughSearchTime)>>4);

  05431	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  05437	e8 00 00 00 00	 call	 __ftol2_sse
  0543c	c1 f8 04	 sar	 eax, 4
  0543f	50		 push	 eax
  05440	8b 44 24 60	 mov	 eax, DWORD PTR _Karp_Rabin_Kaze_4_OCTETShits_DOUBLET$[esp+4524]
  05444	50		 push	 eax
  05445	68 00 00 00 00	 push	 OFFSET $SG6972
  0544a	e8 00 00 00 00	 call	 _printf

; 5229 : printf( "Railgun_Quadruplet_6pp performance: %luKB/clock\n", (StrnglenTRAVERSED/((long)(TotalRoughSearchTime)>>4))>>10);

  0544f	dd 05 00 00 00
	00		 fld	 QWORD PTR _TotalRoughSearchTime
  05455	e8 00 00 00 00	 call	 __ftol2_sse
  0545a	8b 74 24 24	 mov	 esi, DWORD PTR _StrnglenTRAVERSED$[esp+4532]
  0545e	8b c8		 mov	 ecx, eax
  05460	8b c6		 mov	 eax, esi
  05462	99		 cdq
  05463	c1 f9 04	 sar	 ecx, 4
  05466	f7 f9		 idiv	 ecx
  05468	c1 f8 0a	 sar	 eax, 10			; 0000000aH
  0546b	50		 push	 eax
  0546c	68 00 00 00 00	 push	 OFFSET $SG6974
  05471	e8 00 00 00 00	 call	 _printf

; 5230 : printf( "StrnglenTRAVERSED: %lu bytes\n", StrnglenTRAVERSED);

  05476	56		 push	 esi
  05477	68 00 00 00 00	 push	 OFFSET $SG6975
  0547c	e8 00 00 00 00	 call	 _printf
  05481	8b 84 24 8c 00
	00 00		 mov	 eax, DWORD PTR _j$[esp+4548]
  05488	40		 inc	 eax
  05489	83 c4 24	 add	 esp, 36			; 00000024H
  0548c	89 44 24 68	 mov	 DWORD PTR _j$[esp+4512], eax
  05490	83 f8 02	 cmp	 eax, 2
  05493	0f 8c a7 f8 ff
	ff		 jl	 $LL58@main

; 5092 : for (i = 0; i<8; i++)

  05499	8b 44 24 24	 mov	 eax, DWORD PTR _i$[esp+4512]
  0549d	40		 inc	 eax
  0549e	89 44 24 24	 mov	 DWORD PTR _i$[esp+4512], eax
  054a2	83 f8 08	 cmp	 eax, 8
  054a5	0f 8c 8c f8 ff
	ff		 jl	 $LN61@main
$LN59@main:

; 5231 : // Z]
; 5232 : 
; 5233 :    }
; 5234 :    }
; 5235 : // DUMBO ... ]
; 5236 : 
; 5237 : } //if (argc==1) {
; 5238 : 
; 5239 : //exit(1); // Comment it to get on!
; 5240 : 
; 5241 : return(0);
; 5242 :   }

  054ab	8b 8c 24 9c 11
	00 00		 mov	 ecx, DWORD PTR __$ArrayPad$[esp+4512]
  054b2	5f		 pop	 edi
  054b3	5e		 pop	 esi
  054b4	5b		 pop	 ebx
  054b5	33 cc		 xor	 ecx, esp
  054b7	33 c0		 xor	 eax, eax
  054b9	e8 00 00 00 00	 call	 @__security_check_cookie@4
  054be	8b e5		 mov	 esp, ebp
  054c0	5d		 pop	 ebp
  054c1	c3		 ret	 0
$LN818@main:

; 5192 : 	FoundInPTR = Railgun_Quadruplet(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  054c2	83 c0 fd	 add	 eax, -3			; fffffffdH
  054c5	e9 09 02 00 00	 jmp	 $LN544@main
$LN732@main:
  054ca	8a 48 ff	 mov	 cl, BYTE PTR [eax-1]
  054cd	0f be 50 fe	 movsx	 edx, BYTE PTR [eax-2]
  054d1	0f be d9	 movsx	 ebx, cl
  054d4	c1 e2 08	 shl	 edx, 8
  054d7	03 d3		 add	 edx, ebx
  054d9	3b f2		 cmp	 esi, edx
  054db	74 2c		 je	 SHORT $LN820@main
  054dd	8b d6		 mov	 edx, esi
  054df	c1 ea 08	 shr	 edx, 8
  054e2	eb 04		 jmp	 SHORT $LN563@main
$LL1023@main:
  054e4	8b 7c 24 60	 mov	 edi, DWORD PTR _pbTargetMax$7912[esp+4512]
$LN563@main:
  054e8	3a d1		 cmp	 dl, cl
  054ea	74 01		 je	 SHORT $LN560@main
  054ec	40		 inc	 eax
$LN560@main:
  054ed	40		 inc	 eax
  054ee	3b c7		 cmp	 eax, edi
  054f0	0f 87 2f fd ff
	ff		 ja	 $LN15@main
  054f6	8a 48 ff	 mov	 cl, BYTE PTR [eax-1]
  054f9	0f be 78 fe	 movsx	 edi, BYTE PTR [eax-2]
  054fd	0f be d9	 movsx	 ebx, cl
  05500	c1 e7 08	 shl	 edi, 8
  05503	03 fb		 add	 edi, ebx
  05505	3b f7		 cmp	 esi, edi
  05507	75 db		 jne	 SHORT $LL1023@main
$LN820@main:
  05509	83 c0 fe	 add	 eax, -2			; fffffffeH
  0550c	e9 c2 01 00 00	 jmp	 $LN544@main
$LN572@main:
  05511	81 fa c1 03 00
	00		 cmp	 edx, 961		; 000003c1H
  05517	0f 83 ec 00 00
	00		 jae	 $LN557@main
  0551d	0f b6 84 24 b0
	09 00 00	 movzx	 eax, BYTE PTR _Pattern$[esp+4512]
  05525	8b f8		 mov	 edi, eax
  05527	8b f0		 mov	 esi, eax
  05529	c1 e7 08	 shl	 edi, 8
  0552c	c1 e6 10	 shl	 esi, 16			; 00000010H
  0552f	89 44 24 4c	 mov	 DWORD PTR tv6297[esp+4512], eax
  05533	8d 14 0b	 lea	 edx, DWORD PTR [ebx+ecx]
  05536	c1 e0 18	 shl	 eax, 24			; 00000018H
  05539	89 54 24 58	 mov	 DWORD PTR $T7971[esp+4512], edx
  0553d	89 7c 24 40	 mov	 DWORD PTR _Quadruplet2nd$7918[esp+4512], edi
  05541	89 74 24 14	 mov	 DWORD PTR _Quadruplet3rd$7919[esp+4512], esi
  05545	89 44 24 44	 mov	 DWORD PTR _Quadruplet4th$7920[esp+4512], eax
  05549	8d a4 24 00 00
	00 00		 npad	 7
$LL556@main:
  05550	8b c2		 mov	 eax, edx
  05552	2b c1		 sub	 eax, ecx
  05554	8b 00		 mov	 eax, DWORD PTR [eax]
  05556	33 f6		 xor	 esi, esi
  05558	39 84 24 b0 09
	00 00		 cmp	 DWORD PTR _Pattern$[esp+4512], eax
  0555f	75 59		 jne	 SHORT $LN554@main
  05561	8d 41 ff	 lea	 eax, DWORD PTR [ecx-1]
  05564	85 c0		 test	 eax, eax
  05566	74 3d		 je	 SHORT $LN919@main
  05568	8b 7c 24 2c	 mov	 edi, DWORD PTR tv4483[esp+4512]
  0556c	8b ca		 mov	 ecx, edx
  0556e	2b c8		 sub	 ecx, eax
  05570	2b f8		 sub	 edi, eax
  05572	8d bc 3c b0 09
	00 00		 lea	 edi, DWORD PTR _Pattern$[esp+edi+4512]
  05579	8d a4 24 00 00
	00 00		 npad	 7
$LL553@main:
  05580	8a 19		 mov	 bl, BYTE PTR [ecx]
  05582	38 1f		 cmp	 BYTE PTR [edi], bl
  05584	75 2a		 jne	 SHORT $LN552@main
  05586	8b 54 24 2c	 mov	 edx, DWORD PTR tv4483[esp+4512]
  0558a	8d 1c 30	 lea	 ebx, DWORD PTR [eax+esi]
  0558d	4a		 dec	 edx
  0558e	3b d3		 cmp	 edx, ebx
  05590	75 0a		 jne	 SHORT $LN551@main
  05592	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  05595	39 54 24 4c	 cmp	 DWORD PTR tv6297[esp+4512], edx
  05599	74 01		 je	 SHORT $LN551@main
  0559b	46		 inc	 esi
$LN551@main:
  0559c	8b 54 24 58	 mov	 edx, DWORD PTR $T7971[esp+4512]
  055a0	47		 inc	 edi
  055a1	41		 inc	 ecx
  055a2	48		 dec	 eax
  055a3	75 db		 jne	 SHORT $LL553@main
$LN919@main:
  055a5	2b 54 24 2c	 sub	 edx, DWORD PTR tv4483[esp+4512]
  055a9	8b c2		 mov	 eax, edx
  055ab	e9 23 01 00 00	 jmp	 $LN544@main
$LN552@main:
  055b0	85 c0		 test	 eax, eax
  055b2	74 f1		 je	 SHORT $LN919@main
  055b4	8b 4c 24 2c	 mov	 ecx, DWORD PTR tv4483[esp+4512]
  055b8	eb 34		 jmp	 SHORT $LN546@main
$LN554@main:
  055ba	8b d8		 mov	 ebx, eax
  055bc	81 e3 00 ff 00
	00		 and	 ebx, 65280		; 0000ff00H
  055c2	3b fb		 cmp	 edi, ebx
  055c4	74 28		 je	 SHORT $LN546@main
  055c6	8b f8		 mov	 edi, eax
  055c8	81 e7 00 00 ff
	00		 and	 edi, 16711680		; 00ff0000H
  055ce	be 01 00 00 00	 mov	 esi, 1
  055d3	39 7c 24 14	 cmp	 DWORD PTR _Quadruplet3rd$7919[esp+4512], edi
  055d7	74 15		 je	 SHORT $LN546@main
  055d9	25 00 00 00 ff	 and	 eax, -16777216		; ff000000H
  055de	be 02 00 00 00	 mov	 esi, 2
  055e3	39 44 24 44	 cmp	 DWORD PTR _Quadruplet4th$7920[esp+4512], eax
  055e7	74 05		 je	 SHORT $LN546@main
  055e9	be 03 00 00 00	 mov	 esi, 3
$LN546@main:
  055ee	8d 54 32 01	 lea	 edx, DWORD PTR [edx+esi+1]
  055f2	89 54 24 58	 mov	 DWORD PTR $T7971[esp+4512], edx
  055f6	3b 54 24 60	 cmp	 edx, DWORD PTR _pbTargetMax$7912[esp+4512]
  055fa	0f 87 25 fc ff
	ff		 ja	 $LN15@main
  05600	8b 7c 24 40	 mov	 edi, DWORD PTR _Quadruplet2nd$7918[esp+4512]
  05604	e9 47 ff ff ff	 jmp	 $LL556@main
$LN557@main:
  05609	8b 74 24 2c	 mov	 esi, DWORD PTR tv4483[esp+4512]
  0560d	8b c6		 mov	 eax, esi
  0560f	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  05614	8d bc 24 90 01
	00 00		 lea	 edi, DWORD PTR _bm_bc$7925[esp+4512]
  0561b	f3 ab		 rep stosd
  0561d	8d 4e ff	 lea	 ecx, DWORD PTR [esi-1]
  05620	33 c0		 xor	 eax, eax
  05622	85 c9		 test	 ecx, ecx
  05624	74 1f		 je	 SHORT $LN538@main
  05626	4e		 dec	 esi
  05627	eb 07 8d a4 24
	00 00 00 00	 npad	 9
$LL540@main:
  05630	0f be bc 04 b0
	09 00 00	 movsx	 edi, BYTE PTR _Pattern$[esp+eax+4512]
  05638	89 b4 bc 90 01
	00 00		 mov	 DWORD PTR _bm_bc$7925[esp+edi*4+4512], esi
  0563f	40		 inc	 eax
  05640	4e		 dec	 esi
  05641	3b c1		 cmp	 eax, ecx
  05643	72 eb		 jb	 SHORT $LL540@main
$LN538@main:
  05645	8b 7c 24 2c	 mov	 edi, DWORD PTR tv4483[esp+4512]
  05649	0f be 84 3c af
	09 00 00	 movsx	 eax, BYTE PTR _Pattern$[esp+edi+4511]
  05651	33 f6		 xor	 esi, esi
  05653	2b d7		 sub	 edx, edi
  05655	89 54 24 5c	 mov	 DWORD PTR $T8339[esp+4512], edx
  05659	89 44 24 4c	 mov	 DWORD PTR tv4989[esp+4512], eax
  0565d	8d 49 00	 npad	 3
$LL537@main:
  05660	8d 04 1e	 lea	 eax, DWORD PTR [esi+ebx]
  05663	0f b6 4c 38 ff	 movzx	 ecx, BYTE PTR [eax+edi-1]
  05668	89 4c 24 40	 mov	 DWORD PTR tv5358[esp+4512], ecx
  0566c	3b 4c 24 4c	 cmp	 ecx, DWORD PTR tv4989[esp+4512]
  05670	75 47		 jne	 SHORT $LN532@main
  05672	8a 94 24 b0 09
	00 00		 mov	 dl, BYTE PTR _Pattern$[esp+4512]
  05679	38 10		 cmp	 BYTE PTR [eax], dl
  0567b	75 3c		 jne	 SHORT $LN532@main
  0567d	8d 4f fe	 lea	 ecx, DWORD PTR [edi-2]
  05680	85 c9		 test	 ecx, ecx
  05682	74 4c		 je	 SHORT $LN824@main
  05684	8d 84 24 b1 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4513]
  0568b	8b d6		 mov	 edx, esi
  0568d	8b f8		 mov	 edi, eax
  0568f	2b d7		 sub	 edx, edi
  05691	89 54 24 44	 mov	 DWORD PTR tv8528[esp+4512], edx
$LL534@main:
  05695	89 4c 24 14	 mov	 DWORD PTR tv6978[esp+4512], ecx
  05699	8a 08		 mov	 cl, BYTE PTR [eax]
  0569b	03 d3		 add	 edx, ebx
  0569d	3a 4c 02 01	 cmp	 cl, BYTE PTR [edx+eax+1]
  056a1	8b 4c 24 14	 mov	 ecx, DWORD PTR tv6978[esp+4512]
  056a5	75 0a		 jne	 SHORT $LN533@main
  056a7	40		 inc	 eax
  056a8	49		 dec	 ecx
  056a9	74 25		 je	 SHORT $LN824@main
  056ab	8b 54 24 44	 mov	 edx, DWORD PTR tv8528[esp+4512]
  056af	eb e4		 jmp	 SHORT $LL534@main
$LN533@main:
  056b1	85 c9		 test	 ecx, ecx
  056b3	74 1b		 je	 SHORT $LN824@main
  056b5	8b 4c 24 40	 mov	 ecx, DWORD PTR tv5358[esp+4512]
$LN532@main:
  056b9	03 b4 8c 90 01
	00 00		 add	 esi, DWORD PTR _bm_bc$7925[esp+ecx*4+4512]
  056c0	3b 74 24 5c	 cmp	 esi, DWORD PTR $T8339[esp+4512]
  056c4	0f 87 5b fb ff
	ff		 ja	 $LN15@main
  056ca	8b 7c 24 2c	 mov	 edi, DWORD PTR tv4483[esp+4512]
  056ce	eb 90		 jmp	 SHORT $LL537@main
$LN824@main:
  056d0	8d 04 1e	 lea	 eax, DWORD PTR [esi+ebx]
$LN544@main:

; 5193 : 	if ( FoundInPTR != NULL) {Karp_Rabin_Kaze_4_OCTETShits_DOUBLET++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  056d3	85 c0		 test	 eax, eax
  056d5	0f 84 4a fb ff
	ff		 je	 $LN15@main
  056db	2b 44 24 30	 sub	 eax, DWORD PTR _ThunderwithL$[esp+4512]
  056df	ff 44 24 54	 inc	 DWORD PTR _Karp_Rabin_Kaze_4_OCTETShits_DOUBLET$[esp+4512]
  056e3	2b 44 24 28	 sub	 eax, DWORD PTR _Strng$[esp+4512]
  056e7	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax
  056eb	8b 44 24 20	 mov	 eax, DWORD PTR _ThunderwithR$[esp+4512]
  056ef	e9 3f fb ff ff	 jmp	 $LN14@main
$LN826@main:

; 5218 : 	FoundInPTR = Railgun_Quadruplet_6pp(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  056f4	83 c0 fd	 add	 eax, -3			; fffffffdH
  056f7	e9 0b 02 00 00	 jmp	 $LN588@main
$LN743@main:
  056fc	8a 48 ff	 mov	 cl, BYTE PTR [eax-1]
  056ff	0f be 50 fe	 movsx	 edx, BYTE PTR [eax-2]
  05703	0f be d9	 movsx	 ebx, cl
  05706	c1 e2 08	 shl	 edx, 8
  05709	03 d3		 add	 edx, ebx
  0570b	3b f2		 cmp	 esi, edx
  0570d	74 2c		 je	 SHORT $LN828@main
  0570f	8b d6		 mov	 edx, esi
  05711	c1 ea 08	 shr	 edx, 8
  05714	eb 04		 jmp	 SHORT $LN607@main
$LL1021@main:
  05716	8b 7c 24 60	 mov	 edi, DWORD PTR _pbTargetMax$7976[esp+4512]
$LN607@main:
  0571a	3a d1		 cmp	 dl, cl
  0571c	74 01		 je	 SHORT $LN604@main
  0571e	40		 inc	 eax
$LN604@main:
  0571f	40		 inc	 eax
  05720	3b c7		 cmp	 eax, edi
  05722	0f 87 8d fc ff
	ff		 ja	 $LN4@main
  05728	8a 48 ff	 mov	 cl, BYTE PTR [eax-1]
  0572b	0f be 78 fe	 movsx	 edi, BYTE PTR [eax-2]
  0572f	0f be d9	 movsx	 ebx, cl
  05732	c1 e7 08	 shl	 edi, 8
  05735	03 fb		 add	 edi, ebx
  05737	3b f7		 cmp	 esi, edi
  05739	75 db		 jne	 SHORT $LL1021@main
$LN828@main:
  0573b	83 c0 fe	 add	 eax, -2			; fffffffeH
  0573e	e9 c4 01 00 00	 jmp	 $LN588@main
$LN616@main:
  05743	81 fa c1 03 00
	00		 cmp	 edx, 961		; 000003c1H
  05749	0f 83 ea 00 00
	00		 jae	 $LN601@main
  0574f	0f b6 84 24 b0
	09 00 00	 movzx	 eax, BYTE PTR _Pattern$[esp+4512]
  05757	8b f8		 mov	 edi, eax
  05759	8b f0		 mov	 esi, eax
  0575b	c1 e7 08	 shl	 edi, 8
  0575e	c1 e6 10	 shl	 esi, 16			; 00000010H
  05761	89 44 24 4c	 mov	 DWORD PTR tv6297[esp+4512], eax
  05765	8d 14 0b	 lea	 edx, DWORD PTR [ebx+ecx]
  05768	c1 e0 18	 shl	 eax, 24			; 00000018H
  0576b	89 54 24 58	 mov	 DWORD PTR $T8035[esp+4512], edx
  0576f	89 7c 24 40	 mov	 DWORD PTR _Quadruplet2nd$7982[esp+4512], edi
  05773	89 74 24 14	 mov	 DWORD PTR _Quadruplet3rd$7983[esp+4512], esi
  05777	89 44 24 44	 mov	 DWORD PTR _Quadruplet4th$7984[esp+4512], eax
  0577b	eb 03 8d 49 00	 npad	 5
$LL600@main:
  05780	8b c2		 mov	 eax, edx
  05782	2b c1		 sub	 eax, ecx
  05784	8b 00		 mov	 eax, DWORD PTR [eax]
  05786	33 f6		 xor	 esi, esi
  05788	39 84 24 b0 09
	00 00		 cmp	 DWORD PTR _Pattern$[esp+4512], eax
  0578f	75 59		 jne	 SHORT $LN598@main
  05791	8d 41 ff	 lea	 eax, DWORD PTR [ecx-1]
  05794	85 c0		 test	 eax, eax
  05796	74 3d		 je	 SHORT $LN922@main
  05798	8b 7c 24 2c	 mov	 edi, DWORD PTR tv4483[esp+4512]
  0579c	8b ca		 mov	 ecx, edx
  0579e	2b c8		 sub	 ecx, eax
  057a0	2b f8		 sub	 edi, eax
  057a2	8d bc 3c b0 09
	00 00		 lea	 edi, DWORD PTR _Pattern$[esp+edi+4512]
  057a9	8d a4 24 00 00
	00 00		 npad	 7
$LL597@main:
  057b0	8a 19		 mov	 bl, BYTE PTR [ecx]
  057b2	38 1f		 cmp	 BYTE PTR [edi], bl
  057b4	75 2a		 jne	 SHORT $LN596@main
  057b6	8b 54 24 2c	 mov	 edx, DWORD PTR tv4483[esp+4512]
  057ba	4a		 dec	 edx
  057bb	8d 1c 30	 lea	 ebx, DWORD PTR [eax+esi]
  057be	3b d3		 cmp	 edx, ebx
  057c0	75 0a		 jne	 SHORT $LN595@main
  057c2	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  057c5	39 54 24 4c	 cmp	 DWORD PTR tv6297[esp+4512], edx
  057c9	74 01		 je	 SHORT $LN595@main
  057cb	46		 inc	 esi
$LN595@main:
  057cc	8b 54 24 58	 mov	 edx, DWORD PTR $T8035[esp+4512]
  057d0	47		 inc	 edi
  057d1	41		 inc	 ecx
  057d2	48		 dec	 eax
  057d3	75 db		 jne	 SHORT $LL597@main
$LN922@main:
  057d5	2b 54 24 2c	 sub	 edx, DWORD PTR tv4483[esp+4512]
  057d9	8b c2		 mov	 eax, edx
  057db	e9 27 01 00 00	 jmp	 $LN588@main
$LN596@main:
  057e0	85 c0		 test	 eax, eax
  057e2	74 f1		 je	 SHORT $LN922@main
  057e4	8b 4c 24 2c	 mov	 ecx, DWORD PTR tv4483[esp+4512]
  057e8	eb 34		 jmp	 SHORT $LN590@main
$LN598@main:
  057ea	8b d8		 mov	 ebx, eax
  057ec	81 e3 00 ff 00
	00		 and	 ebx, 65280		; 0000ff00H
  057f2	3b fb		 cmp	 edi, ebx
  057f4	74 28		 je	 SHORT $LN590@main
  057f6	8b f8		 mov	 edi, eax
  057f8	81 e7 00 00 ff
	00		 and	 edi, 16711680		; 00ff0000H
  057fe	be 01 00 00 00	 mov	 esi, 1
  05803	39 7c 24 14	 cmp	 DWORD PTR _Quadruplet3rd$7983[esp+4512], edi
  05807	74 15		 je	 SHORT $LN590@main
  05809	25 00 00 00 ff	 and	 eax, -16777216		; ff000000H
  0580e	be 02 00 00 00	 mov	 esi, 2
  05813	39 44 24 44	 cmp	 DWORD PTR _Quadruplet4th$7984[esp+4512], eax
  05817	74 05		 je	 SHORT $LN590@main
  05819	be 03 00 00 00	 mov	 esi, 3
$LN590@main:
  0581e	8d 54 32 01	 lea	 edx, DWORD PTR [edx+esi+1]
  05822	89 54 24 58	 mov	 DWORD PTR $T8035[esp+4512], edx
  05826	3b 54 24 60	 cmp	 edx, DWORD PTR _pbTargetMax$7976[esp+4512]
  0582a	0f 87 85 fb ff
	ff		 ja	 $LN4@main
  05830	8b 7c 24 40	 mov	 edi, DWORD PTR _Quadruplet2nd$7982[esp+4512]
  05834	e9 47 ff ff ff	 jmp	 $LL600@main
$LN601@main:
  05839	8b 74 24 2c	 mov	 esi, DWORD PTR tv4483[esp+4512]
  0583d	8b c6		 mov	 eax, esi
  0583f	b9 00 01 00 00	 mov	 ecx, 256		; 00000100H
  05844	8d bc 24 90 05
	00 00		 lea	 edi, DWORD PTR _bm_bc$7989[esp+4512]
  0584b	f3 ab		 rep stosd
  0584d	8d 4e ff	 lea	 ecx, DWORD PTR [esi-1]
  05850	33 c0		 xor	 eax, eax
  05852	85 c9		 test	 ecx, ecx
  05854	74 1f		 je	 SHORT $LN582@main
  05856	4e		 dec	 esi
  05857	eb 07 8d a4 24
	00 00 00 00	 npad	 9
$LL584@main:
  05860	0f be bc 04 b0
	09 00 00	 movsx	 edi, BYTE PTR _Pattern$[esp+eax+4512]
  05868	89 b4 bc 90 05
	00 00		 mov	 DWORD PTR _bm_bc$7989[esp+edi*4+4512], esi
  0586f	40		 inc	 eax
  05870	4e		 dec	 esi
  05871	3b c1		 cmp	 eax, ecx
  05873	72 eb		 jb	 SHORT $LL584@main
$LN582@main:
  05875	8b 4c 24 2c	 mov	 ecx, DWORD PTR tv4483[esp+4512]
  05879	0f be 84 0c af
	09 00 00	 movsx	 eax, BYTE PTR _Pattern$[esp+ecx+4511]
  05881	33 f6		 xor	 esi, esi
  05883	2b d1		 sub	 edx, ecx
  05885	89 54 24 5c	 mov	 DWORD PTR $T8341[esp+4512], edx
  05889	89 44 24 4c	 mov	 DWORD PTR tv4989[esp+4512], eax
  0588d	eb 05		 jmp	 SHORT $LN581@main
  0588f	90		 npad	 1
$LL950@main:
  05890	8b 4c 24 2c	 mov	 ecx, DWORD PTR tv4483[esp+4512]
$LN581@main:
  05894	8d 04 1e	 lea	 eax, DWORD PTR [esi+ebx]
  05897	0f b6 54 08 ff	 movzx	 edx, BYTE PTR [eax+ecx-1]
  0589c	89 54 24 40	 mov	 DWORD PTR tv5464[esp+4512], edx
  058a0	3b 54 24 4c	 cmp	 edx, DWORD PTR tv4989[esp+4512]
  058a4	75 4c		 jne	 SHORT $LN576@main
  058a6	8b bc 24 b0 09
	00 00		 mov	 edi, DWORD PTR _Pattern$[esp+4512]
  058ad	39 38		 cmp	 DWORD PTR [eax], edi
  058af	75 41		 jne	 SHORT $LN576@main
  058b1	83 c1 fc	 add	 ecx, -4			; fffffffcH
  058b4	74 34		 je	 SHORT $LN577@main
  058b6	8d 84 24 b4 09
	00 00		 lea	 eax, DWORD PTR _Pattern$[esp+4516]
  058bd	8b d6		 mov	 edx, esi
  058bf	8b f8		 mov	 edi, eax
  058c1	2b d7		 sub	 edx, edi
  058c3	89 54 24 14	 mov	 DWORD PTR tv8817[esp+4512], edx
  058c7	eb 0b		 jmp	 SHORT $LN578@main
  058c9	8d a4 24 00 00
	00 00		 npad	 7
$LL941@main:
  058d0	8b 54 24 14	 mov	 edx, DWORD PTR tv8817[esp+4512]
$LN578@main:
  058d4	03 d0		 add	 edx, eax
  058d6	89 44 24 44	 mov	 DWORD PTR tv6977[esp+4512], eax
  058da	8a 00		 mov	 al, BYTE PTR [eax]
  058dc	3a 44 1a 04	 cmp	 al, BYTE PTR [edx+ebx+4]
  058e0	8b 44 24 44	 mov	 eax, DWORD PTR tv6977[esp+4512]
  058e4	75 04		 jne	 SHORT $LN577@main
  058e6	40		 inc	 eax
  058e7	49		 dec	 ecx
  058e8	75 e6		 jne	 SHORT $LL941@main
$LN577@main:
  058ea	85 c9		 test	 ecx, ecx
  058ec	7e 16		 jle	 SHORT $LN832@main
  058ee	8b 54 24 40	 mov	 edx, DWORD PTR tv5464[esp+4512]
$LN576@main:
  058f2	03 b4 94 90 05
	00 00		 add	 esi, DWORD PTR _bm_bc$7989[esp+edx*4+4512]
  058f9	3b 74 24 5c	 cmp	 esi, DWORD PTR $T8341[esp+4512]
  058fd	76 91		 jbe	 SHORT $LL950@main

; 5222 : 	if (ThunderwithR >= Strnglen-1) break;

  058ff	e9 b1 fa ff ff	 jmp	 $LN4@main
$LN832@main:

; 5218 : 	FoundInPTR = Railgun_Quadruplet_6pp(&Strng[ThunderwithL], &Pattern[0], ThunderwithR - ThunderwithL, Patternlen);

  05904	8d 04 1e	 lea	 eax, DWORD PTR [esi+ebx]
$LN588@main:

; 5219 : 	if ( FoundInPTR != NULL) {Karp_Rabin_Kaze_4_OCTETShits_DOUBLET++; StrnglenTRAVERSED=StrnglenTRAVERSED+(FoundInPTR-&Strng[ThunderwithL]);} else StrnglenTRAVERSED=StrnglenTRAVERSED+(ThunderwithR - ThunderwithL);

  05907	85 c0		 test	 eax, eax
  05909	0f 84 a6 fa ff
	ff		 je	 $LN4@main
  0590f	2b 44 24 30	 sub	 eax, DWORD PTR _ThunderwithL$[esp+4512]
  05913	ff 44 24 54	 inc	 DWORD PTR _Karp_Rabin_Kaze_4_OCTETShits_DOUBLET$[esp+4512]
  05917	2b 44 24 28	 sub	 eax, DWORD PTR _Strng$[esp+4512]
  0591b	01 44 24 10	 add	 DWORD PTR _StrnglenTRAVERSED$[esp+4512], eax
  0591f	e9 9d fa ff ff	 jmp	 $LN3@main
_main	ENDP
_TEXT	ENDS
END
