; -- Machine type P
; mark_description "Intel(R) C Compiler Version 4.0 99026";
; mark_description "-Qvc5 -nologo -ML -W3 -GX -O2 -D WIN32 -D NDEBUG -D _CONSOLE -D _MBCS -FAs -FaRelease/wstream.asm.c -FpRelea";
; mark_description "se/win32_stream.pch -YX -FoRelease/ -FdRelease/ -FD -Qunroll8 -c";
;ident "Intel(R) C Compiler Version 4.0 99026"
;ident "-Qvc5 -nologo -ML -W3 -GX -O2 -D WIN32 -D NDEBUG -D _CONSOLE -D _MBCS -FAs -FaRelease/wstream.asm.c -FpRelease/win32_stream.pc"
	.486P
 	.387
_TEXT	SEGMENT PARA PUBLIC USE32 'CODE'
_TEXT	ENDS
_DATA	SEGMENT PARA PUBLIC USE32 'DATA'
	ALIGN 010H
_DATA	ENDS
_BSS	SEGMENT PARA PUBLIC USE32 'BSS'
	ALIGN 010H
_BSS	ENDS
_TLS	SEGMENT PARA PUBLIC USE32 'TLS'
_TLS	ENDS
_TEXT1	SEGMENT PARA PUBLIC USE32 'CODE'
	ALIGN 010H
_TEXT1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	ALIGN 010H
_DATA1	ENDS
	ASSUME	CS:FLAT,DS:FLAT,SS:FLAT
_BSS	SEGMENT PARA PUBLIC USE32 'BSS'
_rmstime	DB 32 DUP (0)	; pad
_maxtime	DB 32 DUP (0)	; pad
_BSS	ENDS
_DATA	SEGMENT PARA PUBLIC USE32 'DATA'
_mintime	DD 0e0000000H,047efffffH	; xf64
	DD 0e0000000H,047efffffH	; xf64
	DD 0e0000000H,047efffffH	; xf64
	DD 0e0000000H,047efffffH	; xf64
_label	DD OFFSET FLAT: ??_C@_0M@A@Copy?3?5?5?5?5?5?5?$AA@	; p32
	DD OFFSET FLAT: ??_C@_0M@A@Scale?3?5?5?5?5?5?$AA@	; p32
	DD OFFSET FLAT: ??_C@_0M@A@Add?3?5?5?5?5?5?5?5?$AA@	; p32
	DD OFFSET FLAT: ??_C@_0M@A@Triad?3?5?5?5?5?5?$AA@	; p32
_DATA	ENDS
_DATA	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA	ENDS
_TEXT	SEGMENT PARA PUBLIC USE32 'CODE'
;	COMDAT _main
; -- Begin  _main
; mark_begin;
       ALIGN     4                                             ;
	PUBLIC   _main
_main	PROC NEAR
$B1$1:                          ; Preds $B1$0

;;; int main(int argc, char **argv) {

        push      ebx                                           ; 83.33
        mov       ebx, esp                                      ; 83.33
        sub       esp, 8                                        ; 83.33
        and       esp, -16                                      ; 83.33
        add       esp, 8                                        ; 83.33
        jmp       $L1                                           ; 83.33
_main$$1::                                                      ;
        push      ebx                                           ; 83.33
        mov       ebx, esp                                      ; 83.33
$L1:                                                            ;
        push      ebp                                           ; 83.33
        push      ebp                                           ; 83.33
        mov       ebp, DWORD PTR [ebx+4]                        ; 83.33
        mov       DWORD PTR [esp+4], ebp                        ; 83.33
        mov       ebp, esp                                      ; 83.33
        sub       esp, 256                                      ; 83.33
        mov       DWORD PTR [esp+8], edi                        ; 83.33
        mov       DWORD PTR [esp+4], esi                        ; 83.33
                                ; LOE ebx ebp esp bl bh
$B1$156:                        ; Preds $B1$1
        mov       eax, DWORD PTR [ebx+8]                        ; 83.33
        mov       esi, DWORD PTR [ebx+12]                       ; 83.33

;;; 
;;; 	double *a, *b, *c, *d, *e;
;;; 	int NTIMES;
;;;     int	quantum, checktick(double);
;;;     int	BytesPerWord;
;;;     register int j, k;
;;; 	FILE *time_file=NULL;
;;; 	int ti=0;
;;; 	double core=0.0;
;;; 
;;; 	if (argc != 3) {

        cmp       eax, 3                                        ; 94.2
        je        $B1$4         ; Prob 50%                      ; 94.2
                                ; LOE ebx ebp esi esp bl bh
$B1$2:                          ; Preds $B1$156

;;; 		printf ("\n usage: %s <core_frequency(MHz)> <iterations>\n", argv[0]);

        add       esp, -8                                       ; 95.64
        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0DA@CNBAEGDJ@?6?5usage?3?5?$CFs?5?$DMcore_frequency?$CIMHz?$CJ@ ; 95.64
        mov       esi, DWORD PTR [esi]                          ; 95.64
        mov       DWORD PTR [esp+4], esi                        ; 95.64
        call      _printf                                       ; 95.64
                                ; LOE ebx ebp esp bl bh
$B1$3:                          ; Preds $B1$2
        add       esp, 8                                        ; 95.64

;;; 		return 1;

        mov       eax, 1                                        ; 96.3
        mov       esi, DWORD PTR [esp+4]                        ; 96.3
        mov       edi, DWORD PTR [esp+8]                        ; 96.3
        mov       esp, ebp                                      ; 96.3
        pop       ebp                                           ; 96.3
        mov       esp, ebx                                      ; 96.3
        pop       ebx                                           ; 96.3
        ret                                                     ; 96.3
                                ; LOE ebx ebp esi edi esp bl bh
$B1$4:                          ; Preds $B1$156

;;; 	}
;;; 	core=1000000*atof(argv[1]);

        add       esp, -8                                       ; 98.20
        mov       eax, DWORD PTR [esi+4]                        ; 98.20
        mov       DWORD PTR [esp], eax                          ; 98.20
        call      _atof                                         ; 98.20
                                ; LOE ebx ebp esi esp bl bh mm0
$B1$5:                          ; Preds $B1$4
        fmul      QWORD PTR $2$1_2il0floatpacket$1              ; 98.20

;;; 	NTIMES=atoi(argv[2]);

        mov       esi, DWORD PTR [esi+8]                        ; 99.14
        fstp      QWORD PTR [ebp-56]                            ; 98.20
        mov       DWORD PTR [esp], esi                          ; 99.14
        call      _atoi                                         ; 99.14
                                ; LOE eax ebx ebp esp al ah bl bh
$B1$6:                          ; Preds $B1$5

;;; 
;;; 	double	bytes[4] = {

        fld       QWORD PTR $2$1_2il0floatpacket$3              ; 101.9
        fld       QWORD PTR $2$1_2il0floatpacket$5              ; 101.9
        fld       QWORD PTR $2$1_2il0floatpacket$7              ; 101.9
        fxch      st(2)                                         ; 101.9
        fstp      QWORD PTR [ebp-200]                           ; 101.9
        fstp      QWORD PTR [ebp-192]                           ; 101.9
        fstp      QWORD PTR [ebp-184]                           ; 101.9
        fld       QWORD PTR $2$1_2il0floatpacket$9              ; 101.9

;;; 	    2 * sizeof(double) * NSIZE,
;;; 	    2 * sizeof(double) * NSIZE,
;;; 	    3 * sizeof(double) * NSIZE,
;;; 	    3 * sizeof(double) * NSIZE
;;;     };
;;;     double	t;
;;; 	const double scalar=3.0;
;;; 	double  *times[4];
;;; 	for (ti=0; ti<4; ti++) {
;;; 		times[ti]=new double[NTIMES];
;;; 		if (times[ti]==NULL) {
;;; 			printf ("\nError allocating arrays. Quitting.\n");
;;; 			exit(0);

        xor       edx, edx                                      ; 114.4
        mov       edi, eax                                      ; 99.14
        fstp      QWORD PTR [ebp-176]                           ; 101.9
        add       esp, 8                                        ; 99.14
        mov       esi, ebp                                      ; 110.7
        mov       DWORD PTR [ebp-100], edx                      ; 114.4
        ALIGN     4                                             ;
                                ; LOE ebx ebp esi edi esp bl bh
$B1$7:                          ; Preds $B1$9 $B1$6
        lea       eax, DWORD PTR [edi+edi]                      ; 111.24
        add       esp, -8                                       ; 111.24
        add       eax, eax                                      ; 111.24
        add       eax, eax                                      ; 111.24
        mov       DWORD PTR [esp], eax                          ; 111.24
        call      ??2@YAPAXI@Z                                  ; 111.24
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$8:                          ; Preds $B1$7
        add       esp, 8                                        ; 111.24
        test      eax, eax                                      ; 112.3
        mov       DWORD PTR [esi-168], eax                      ; 111.3
        je        $B1$143       ; Prob 12%                      ; 112.3
                                ; LOE ebx ebp esi edi esp bl bh
$B1$9:                          ; Preds $B1$145 $B1$8
        add       esi, 4                                        ; 110.19
        lea       eax, DWORD PTR [ebp+16]                       ; 110.19
        cmp       eax, esi                                      ; 110.2
        jg        $B1$7         ; Prob 80%                      ; 110.2
                                ; LOE ebx ebp esi edi esp bl bh
$B1$10:                         ; Preds $B1$9

;;; 		}
;;; 	}
;;; 
;;;     /* --- SETUP --- determine precision and check timing --- */
;;; 
;;;     printf(HLINE);

        add       esp, -8                                       ; 120.5
        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0DP@LMFECGLD@?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9@ ; 120.5
        call      _printf                                       ; 120.5
                                ; LOE ebx ebp edi esp bl bh
$B1$11:                         ; Preds $B1$10

;;;     BytesPerWord = sizeof(double);
;;;     printf("This system uses %d bytes per DOUBLE PRECISION word.\n",
;;; 	BytesPerWord);

        mov       DWORD PTR [esp+4], 8                          ; 123.2
        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0DG@OCCAPABI@This?5system?5uses?5?$CFd?5bytes?5per?5DO@ ; 123.2
        call      _printf                                       ; 123.2
                                ; LOE ebx ebp edi esp bl bh
$B1$12:                         ; Preds $B1$11

;;; 
;;;     printf(HLINE);

        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0DP@LMFECGLD@?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9@ ; 125.5
        call      _printf                                       ; 125.5
                                ; LOE ebx ebp edi esp bl bh
$B1$13:                         ; Preds $B1$12

;;;     printf("Array size = %d\n" , NSIZE);

        mov       DWORD PTR [esp+4], 999936                     ; 126.5
        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0BB@A@Array?5size?5?$DN?5?$CFd?6?$AA@ ; 126.5
        call      _printf                                       ; 126.5
                                ; LOE ebx ebp edi esp bl bh
$B1$14:                         ; Preds $B1$13
        add       esp, -8                                       ; 126.5

;;;     printf("Total memory required = %.1f MB.\n",
;;; 	((2*CACHEBLOW + 3*NSIZE)*BytesPerWord) / 1048576.0);

        fld       QWORD PTR $2$1_2il0floatpacket$11             ; 128.27
        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0CC@CGC@Total?5memory?5required?5?$DN?5?$CF?41f?5MB?4@ ; 128.27
        fstp      QWORD PTR [esp+4]                             ; 128.27
        call      _printf                                       ; 128.27
                                ; LOE ebx ebp edi esp bl bh
$B1$15:                         ; Preds $B1$14
        add       esp, 8                                        ; 128.27

;;;     printf("Each test is run %d times, but only\n", NTIMES);

        mov       DWORD PTR [esp+4], edi                        ; 129.53
        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0CF@FMEELHJM@Each?5test?5is?5run?5?$CFd?5times?0?5but?5o@ ; 129.53
        call      _printf                                       ; 129.53
                                ; LOE ebx ebp edi esp bl bh
$B1$16:                         ; Preds $B1$15

;;;     printf("the *best* time for each is used.\n");

        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0CD@CJPAA@the?5?$CKbest?$CK?5time?5for?5each?5is?5used@ ; 130.5
        call      _printf                                       ; 130.5
                                ; LOE ebx ebp edi esp bl bh
$B1$17:                         ; Preds $B1$16

;;; 
;;;     /* Get initial value for system clock. */
;;; 
;;;     printf(HLINE);

        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0DP@LMFECGLD@?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9@ ; 134.5
        call      _printf                                       ; 134.5
                                ; LOE ebx ebp edi esp bl bh
$B1$18:                         ; Preds $B1$17
        fld       QWORD PTR [ebp-56]                            ;

;;; 
;;;     if  ( (quantum = checktick(core)) >= 1) 

        fstp      QWORD PTR [esp]                               ; 136.32
        call      ?checktick@@YAHN@Z                            ; 136.32
                                ; LOE eax ebx ebp edi esp al ah bl bh
$B1$19:                         ; Preds $B1$18
        add       esp, 8                                        ; 136.32
        test      eax, eax                                      ; 136.5
        mov       DWORD PTR [ebp-48], eax                       ; 136.32
        jle       $B1$141       ; Prob 16%                      ; 136.5
                                ; LOE eax ebx ebp edi esp al ah bl bh
$B1$20:                         ; Preds $B1$19

;;; 	printf("Your clock granularity/precision appears to be "
;;; 	    "%d microseconds.\n", quantum);

        add       esp, -8                                       ; 138.28
        mov       DWORD PTR [esp+4], eax                        ; 138.28
        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0EB@DNIEJKDD@Your?5clock?5granularity?1precision@ ; 138.28
        call      _printf                                       ; 138.28
                                ; LOE ebx ebp edi esp bl bh
$B1$21:                         ; Preds $B1$20
        add       esp, 8                                        ; 138.28
                                ; LOE ebx ebp edi esp bl bh
$B1$22:                         ; Preds $B1$21 $B1$142

;;;     else
;;; 	printf("Your clock granularity appears to be "
;;; 	    "less than one microsecond.\n");
;;; 
;;; 	a=new double [NSIZE];

        add       esp, -8                                       ; 143.2
        mov       DWORD PTR [esp], 7999488                      ; 143.2
        call      ??2@YAPAXI@Z                                  ; 143.2
                                ; LOE eax ebx ebp edi esp al ah bl bh
$B1$23:                         ; Preds $B1$22
        mov       esi, eax                                      ; 143.2
        add       esp, 8                                        ; 143.2
        mov       DWORD PTR [ebp-92], esi                       ; 143.2

;;; 	if (a==NULL) {

        test      esi, esi                                      ; 144.2
        je        $B1$139       ; Prob 12%                      ; 144.2
                                ; LOE ebx ebp esi edi esp bl bh
$B1$24:                         ; Preds $B1$23

;;; 		printf ("Error allocating arrays\n");
;;; 		return 1;
;;; 	}
;;; 	for (j=0; j<NSIZE; j++) a[j]=3.0;

        mov       eax, esi                                      ; 148.7
        lea       edx, DWORD PTR [esi+7999488]                  ; 148.7
        ALIGN     4                                             ;
                                ; LOE eax edx ebx ebp esi edi esp al ah dl dh bl bh
$B1$25:                         ; Preds $B1$25 $B1$24
                                ;unroll=1
        fld       QWORD PTR $2$1_2il0floatpacket$13             ; 148.26
        fstp      QWORD PTR [eax]                               ; 148.26
        fld       QWORD PTR $2$1_2il0floatpacket$13             ; 148.26
        fstp      QWORD PTR [eax+8]                             ; 148.26
        add       eax, 16                                       ; 148.21
        cmp       eax, edx                                      ; 148.2
        jl        $B1$25        ; Prob 80%                      ; 148.2
                                ; LOE eax edx ebx ebp esi edi esp al ah dl dh bl bh
$B1$26:                         ; Preds $B1$25

;;;     t = second(core);

        add       esp, -8                                       ; 149.16
        fld       QWORD PTR [ebp-56]                            ;
        fstp      QWORD PTR [esp]                               ; 149.16
        call      ?second@@YANN@Z                               ; 149.16
                                ; LOE ebx ebp esi edi esp bl bh mm0
$B1$27:                         ; Preds $B1$26
        add       esp, 8                                        ; 149.16

;;; 	for (j = 0; j < NSIZE; j++)

        mov       eax, esi                                      ; 150.7
        fstp      QWORD PTR [ebp-32]                            ; 149.16
        lea       edx, DWORD PTR [esi+7999488]                  ; 150.7
                                ; LOE eax edx ebx ebp esi edi esp al ah dl dh bl bh
$B1$28:                         ; Preds $B1$28 $B1$27
                                ;unroll=1
        jmp       $L2                                           ;
        ALIGN     4                                             ;
$L3:                                                            ;
        fstp      QWORD PTR [eax-8]                             ;
$L2:                                                            ;

;;; 		a[j] = 2.0E0 * a[j];

        fld       QWORD PTR [eax]                               ; 151.18
        fmul      QWORD PTR $2$1_2il0floatpacket$15             ; 151.18
        fld       QWORD PTR [eax+8]                             ; 151.18
        fxch      st(1)                                         ; 151.18
        fstp      QWORD PTR [eax]                               ; 151.3
        fmul      QWORD PTR $2$1_2il0floatpacket$15             ; 151.18
        add       eax, 16                                       ; 150.25
        cmp       eax, edx                                      ; 150.2
        jl        $L3                                           ; 150.2
        fstp      QWORD PTR [eax-8]                             ; 151.3
                                ; LOE eax edx ebx ebp esi edi esp al ah dl dh bl bh
$B1$29:                         ; Preds $B1$28

;;; 	t = 1.0E6 * (second(core) - t);

        add       esp, -8                                       ; 152.22
        fld       QWORD PTR [ebp-56]                            ;
        fstp      QWORD PTR [esp]                               ; 152.22
        call      ?second@@YANN@Z                               ; 152.22
                                ; LOE ebx ebp esi edi esp bl bh mm0
$B1$30:                         ; Preds $B1$29
        fsub      QWORD PTR [ebp-32]                            ; 152.30
        fmul      QWORD PTR $2$1_2il0floatpacket$17             ; 152.30

;;; 	delete [] a;

        mov       DWORD PTR [esp], esi                          ; 153.12
        fstp      QWORD PTR [ebp-24]                            ; 152.30
        call      ??3@YAXPAX@Z                                  ; 153.12
                                ; LOE ebx ebp edi esp bl bh
$B1$31:                         ; Preds $B1$30
        fld       QWORD PTR [ebp-24]                            ;

;;; 
;;;     printf("Each test below will take on the order"
;;; 	" of %d microseconds.\n", (int) t  );

        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0DM@KJOJGAEE@Each?5test?5below?5will?5take?5on?5the@ ; 156.34
        fstp      QWORD PTR [ebp-128]                           ; 156.34
        mov       esi, DWORD PTR [ebp-124]                      ; 156.34
        mov       eax, DWORD PTR [ebp-128]                      ; 156.34
        mov       edx, esi                                      ; 156.34
        shr       edx, 20                                       ; 156.34
        mov       DWORD PTR [ebp-40], eax                       ; 156.34
        and       edx, 2047                                     ; 156.34
        cmp       edx, 1022                                     ; 156.34
        mov       DWORD PTR [ebp-44], edx                       ; 156.34
        jle       $B1$151       ; Prob 50%                      ; 156.34
                                ; LOE eax edx ebx ebp esi edi esp al ah dl dh bl bh
$B1$149:                        ; Preds $B1$31
        mov       ecx, 1054                                     ; 156.34
        sub       ecx, edx                                      ; 156.34
        mov       edx, esi                                      ; 156.34
        shld      edx, eax, 11                                  ; 156.34
        or        edx, -2147483648                              ; 156.34
        mov       eax, edx                                      ; 156.34
        shr       eax, cl                                       ; 156.34
        test      esi, esi                                      ; 156.34
        jge       $B1$148       ; Prob 50%                      ; 156.34
                                ; LOE eax ebx ebp edi esp al ah bl bh
$B1$150:                        ; Preds $B1$149
        neg       eax                                           ; 156.34
        jmp       $B1$148       ; Prob 50%                      ; 156.34
                                ; LOE eax ebx ebp edi esp al ah bl bh
$B1$151:                        ; Preds $B1$31 $B1$150
        xor       eax, eax                                      ; 156.34
                                ; LOE eax ebx ebp edi esp al ah bl bh
$B1$148:                        ; Preds $B1$150 $B1$149 $B1$151
        mov       DWORD PTR [esp+4], eax                        ; 156.34
        mov       DWORD PTR [ebp-152], eax                      ; 156.34
        call      _printf                                       ; 156.34
                                ; LOE ebx ebp edi esp bl bh
$B1$32:                         ; Preds $B1$148
        mov       eax, DWORD PTR [ebp-48]                       ;

;;;     printf("   (= %d clock ticks)\n", (int) (t/quantum) );

        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0BH@A@?5?5?5?$CI?$DN?5?$CFd?5clock?5ticks?$CJ?6?$AA@ ; 157.48
        mov       DWORD PTR [ebp-152], eax                      ; 157.48
        fild      DWORD PTR [ebp-152]                           ; 157.48
        fdivr     QWORD PTR [ebp-24]                            ; 157.48
        fstp      QWORD PTR [ebp-112]                           ; 157.48
        mov       esi, DWORD PTR [ebp-108]                      ; 157.48
        mov       eax, DWORD PTR [ebp-112]                      ; 157.48
        mov       edx, esi                                      ; 157.48
        shr       edx, 20                                       ; 157.48
        mov       DWORD PTR [ebp-40], eax                       ; 157.48
        and       edx, 2047                                     ; 157.48
        cmp       edx, 1022                                     ; 157.48
        mov       DWORD PTR [ebp-44], edx                       ; 157.48
        jle       $B1$155       ; Prob 50%                      ; 157.48
                                ; LOE eax edx ebx ebp esi edi esp al ah dl dh bl bh
$B1$153:                        ; Preds $B1$32
        mov       ecx, 1054                                     ; 157.48
        sub       ecx, edx                                      ; 157.48
        mov       edx, esi                                      ; 157.48
        shld      edx, eax, 11                                  ; 157.48
        or        edx, -2147483648                              ; 157.48
        mov       eax, edx                                      ; 157.48
        shr       eax, cl                                       ; 157.48
        test      esi, esi                                      ; 157.48
        jge       $B1$152       ; Prob 50%                      ; 157.48
                                ; LOE eax ebx ebp edi esp al ah bl bh
$B1$154:                        ; Preds $B1$153
        neg       eax                                           ; 157.48
        jmp       $B1$152       ; Prob 50%                      ; 157.48
                                ; LOE eax ebx ebp edi esp al ah bl bh
$B1$155:                        ; Preds $B1$32 $B1$154
        xor       eax, eax                                      ; 157.48
                                ; LOE eax ebx ebp edi esp al ah bl bh
$B1$152:                        ; Preds $B1$154 $B1$153 $B1$155
        mov       DWORD PTR [esp+4], eax                        ; 157.48
        mov       DWORD PTR [ebp-152], eax                      ; 157.48
        call      _printf                                       ; 157.48
                                ; LOE ebx ebp edi esp bl bh
$B1$33:                         ; Preds $B1$152

;;;     printf("Increase the size of the arrays if this shows that\n");

        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0DE@LKLKBFJA@Increase?5the?5size?5of?5the?5arrays?5@ ; 158.5
        call      _printf                                       ; 158.5
                                ; LOE ebx ebp edi esp bl bh
$B1$34:                         ; Preds $B1$33

;;;     printf("you are not getting at least 20 clock ticks per test.\n");

        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0DH@EBDCDCK@you?5are?5not?5getting?5at?5least?520?5@ ; 159.5
        call      _printf                                       ; 159.5
                                ; LOE ebx ebp edi esp bl bh
$B1$35:                         ; Preds $B1$34

;;; 
;;;     printf(HLINE);

        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0DP@LMFECGLD@?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9@ ; 161.5
        call      _printf                                       ; 161.5
                                ; LOE ebx ebp edi esp bl bh
$B1$36:                         ; Preds $B1$35

;;; 
;;;     printf("WARNING -- The above is only a rough guideline.\n");

        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0DB@HCLFLMNE@WARNING?5?9?9?5The?5above?5is?5only?5a?5r@ ; 163.5
        call      _printf                                       ; 163.5
                                ; LOE ebx ebp edi esp bl bh
$B1$37:                         ; Preds $B1$36

;;;     printf("For best results, please be sure you know the\n");

        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0CP@BINKKLJE@For?5best?5results?0?5please?5be?5sure@ ; 164.5
        call      _printf                                       ; 164.5
                                ; LOE ebx ebp edi esp bl bh
$B1$38:                         ; Preds $B1$37

;;;     printf("precision of your system timer.\n");

        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0CB@A@precision?5of?5your?5system?5timer?4?6@ ; 165.5
        call      _printf                                       ; 165.5
                                ; LOE ebx ebp edi esp bl bh
$B1$39:                         ; Preds $B1$38

;;;     printf(HLINE);

        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0DP@LMFECGLD@?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9@ ; 166.5
        call      _printf                                       ; 166.5
                                ; LOE ebx ebp edi esp bl bh
$B1$40:                         ; Preds $B1$39
        add       esp, 8                                        ; 166.5

;;; 
;;; 	// bump process priority to real-time
;;; 	SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);

        call      DWORD PTR __imp__GetCurrentProcess@0          ; 169.19
                                ; LOE eax ebx ebp edi esp al ah bl bh
$B1$41:                         ; Preds $B1$40
        add       esp, -8                                       ; 169.19
        mov       DWORD PTR [esp+4], 256                        ; 169.19
        mov       DWORD PTR [esp], eax                          ; 169.19
        call      DWORD PTR __imp__SetPriorityClass@8           ; 169.19
                                ; LOE ebx ebp edi esp bl bh
$B1$42:                         ; Preds $B1$41

;;; 	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);

        call      DWORD PTR __imp__GetCurrentThread@0           ; 170.20
                                ; LOE eax ebx ebp edi esp al ah bl bh
$B1$43:                         ; Preds $B1$42
        add       esp, -8                                       ; 170.20
        mov       DWORD PTR [esp+4], 15                         ; 170.20
        mov       DWORD PTR [esp], eax                          ; 170.20
        call      DWORD PTR __imp__SetThreadPriority@8          ; 170.20
                                ; LOE ebx ebp edi esp bl bh
$B1$44:                         ; Preds $B1$43

;;;     
;;;     /*	--- MAIN LOOP --- repeat test cases NTIMES times --- */
;;;     for (k=0; k<NTIMES; k++)
;;; 	{
;;; 		// allocate arrays for testing and clearing the cache
;;; 		a=new double[NSIZE]; 
;;; 		b=new double[NSIZE]; 
;;; 		c=new double[NSIZE];
;;; 		d=new double[CACHEBLOW];
;;; 		e=new double[CACHEBLOW];
;;; 
;;; 		if (a==NULL || b==NULL || c==NULL || d==NULL || e==NULL) 
;;; 			break;
;;; 		// initialize arrays to some value
;;; 		for (j=0; j<NSIZE; j++) {
;;; 			a[j] = 1.0;
;;; 			b[j] = 2.0;
;;; 			c[j] = 0.0;
;;; 		}
;;; 		for (j=0; j<CACHEBLOW; j++) {
;;; 			d[j] = 5.0;
;;; 			e[j] = 1.0;
;;; 		}
;;; 		// dirty up the cache
;;; 		for (j=0; j<CACHEBLOW; j++)
;;; 		    d[j] = e[j];
;;; 
;;; 		times[0][k] = second(core);
;;; 		for (j=0; j<NSIZE; j++){
;;; 		    c[j] = a[j];
;;; 	//		j++;
;;; 	//		c[j] = a[j];
;;; 		}
;;; 		times[0][k] = second(core) - times[0][k];
;;; 		// dirty up the caches:mbc
;;; 		for (j=0; j<CACHEBLOW; j++)
;;; 		    d[j] = 5.0E0*e[j];
;;; 
;;; 		times[1][k] = second(core);
;;; 		for (j=0; j<NSIZE; j++) {
;;; 			// the compiler may not be smart enough to unroll loops
;;; 			// so explicitly unroll a few iterations just in case
;;; 			b[j] = scalar*c[j];
;;; 	//		j++;
;;; 	//		b[j] = scalar*c[j];
;;; 		}
;;; 		times[1][k] = second(core) - times[1][k];
;;; 		// dirty up the caches
;;; 		for (j=0; j<CACHEBLOW; j++)
;;; 		    e[j] = 1.5E0*d[j];
;;; 
;;; 		times[2][k] = second(core);
;;; 		for (j=0; j<NSIZE; j++) {
;;; 		    c[j] = a[j]+b[j];
;;; 	//		j++;
;;; 	//	    c[j] = a[j]+b[j];
;;; 		}
;;; 		times[2][k] = second(core) - times[2][k];
;;; 		// dirty up the caches
;;; 		for (j=0; j<CACHEBLOW; j++)
;;; 		    e[j] = 0.5E0*d[j];
;;; 
;;; 		times[3][k] = second(core);
;;; 		for (j=0; j<NSIZE; j++) {
;;; 		    a[j] = b[j]+scalar*c[j];
;;; 	//		j++;
;;; 	//	    a[j] = b[j]+scalar*c[j];
;;; 		}
;;; 		times[3][k] = second(core) - times[3][k];
;;; 
;;; 		// deallocate the arrays: they will be reallocated on the next iteration
;;; 		// this de- and re-alloc captures the random allocation of NT virtual memory
;;; 		delete [] a;
;;; 		delete [] b;
;;; 		delete [] c;
;;; 		delete [] d;
;;; 		delete [] e;
;;; 	}
;;; 
;;;    	SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);

        xor       eax, eax                                      ; 173.10
        test      edi, edi                                      ; 173.5
        mov       DWORD PTR [ebp-72], eax                       ; 173.10
        jle       $B1$91        ; Prob 20%                      ; 173.5
                                ; LOE ebx ebp edi esp bl bh
$B1$45:                         ; Preds $B1$44
        mov       DWORD PTR [ebp-96], edi                       ;
                                ; LOE ebx ebp esp bl bh
$B1$46:                         ; Preds $B1$45 $B1$89
        add       esp, -8                                       ; 176.3
        mov       DWORD PTR [esp], 7999488                      ; 176.3
        call      ??2@YAPAXI@Z                                  ; 176.3
                                ; LOE eax ebx ebp esp al ah bl bh
$B1$47:                         ; Preds $B1$46
        mov       DWORD PTR [ebp-92], eax                       ; 176.3
        mov       DWORD PTR [esp], 7999488                      ; 177.3
        mov       DWORD PTR [ebp-64], eax                       ; 176.3
        call      ??2@YAPAXI@Z                                  ; 177.3
                                ; LOE eax ebx ebp esp al ah bl bh
$B1$48:                         ; Preds $B1$47
        mov       DWORD PTR [ebp-88], eax                       ; 177.3
        mov       DWORD PTR [esp], 7999488                      ; 178.3
        mov       DWORD PTR [ebp-68], eax                       ; 177.3
        call      ??2@YAPAXI@Z                                  ; 178.3
                                ; LOE eax ebx ebp esp al ah bl bh
$B1$49:                         ; Preds $B1$48
        mov       DWORD PTR [ebp-84], eax                       ; 178.3
        mov       DWORD PTR [esp], 1048576                      ; 179.3
        mov       DWORD PTR [ebp-100], eax                      ; 178.3
        call      ??2@YAPAXI@Z                                  ; 179.3
                                ; LOE eax ebx ebp esp al ah bl bh
$B1$50:                         ; Preds $B1$49
        mov       esi, eax                                      ; 179.3
        mov       DWORD PTR [esp], 1048576                      ; 180.3
        mov       DWORD PTR [ebp-80], esi                       ; 179.3
        call      ??2@YAPAXI@Z                                  ; 180.3
                                ; LOE eax ebx ebp esi esp al ah bl bh
$B1$51:                         ; Preds $B1$50
        mov       edi, eax                                      ; 180.3
        add       esp, 8                                        ; 180.3
        mov       DWORD PTR [ebp-76], edi                       ; 180.3
        mov       eax, DWORD PTR [ebp-64]                       ;
        test      eax, eax                                      ; 182.3
        je        $B1$134       ; Prob 12%                      ; 182.3
                                ; LOE ebx ebp esi edi esp bl bh
$B1$52:                         ; Preds $B1$51
        mov       eax, DWORD PTR [ebp-68]                       ;
        test      eax, eax                                      ; 182.3
        je        $B1$134       ; Prob 12%                      ; 182.3
                                ; LOE ebx ebp esi edi esp bl bh
$B1$53:                         ; Preds $B1$52
        mov       eax, DWORD PTR [ebp-100]                      ;
        test      eax, eax                                      ; 182.3
        je        $B1$134       ; Prob 12%                      ; 182.3
                                ; LOE ebx ebp esi edi esp bl bh
$B1$54:                         ; Preds $B1$53
        test      esi, esi                                      ; 182.3
        je        $B1$138       ; Prob 12%                      ; 182.3
                                ; LOE ebx ebp esi edi esp bl bh
$B1$55:                         ; Preds $B1$54
        test      edi, edi                                      ; 182.3
        je        $B1$134       ; Prob 12%                      ; 182.3
                                ; LOE ebx ebp esi edi esp bl bh
$B1$56:                         ; Preds $B1$55
        mov       eax, -999936                                  ; 185.8
        mov       DWORD PTR [ebp-44], esi                       ;
        mov       esi, DWORD PTR [ebp-64]                       ;
        mov       DWORD PTR [ebp-48], edi                       ;
        mov       edi, DWORD PTR [ebp-68]                       ;
        ALIGN     4                                             ;
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$57:                         ; Preds $B1$57 $B1$56
                                ;unroll=1
        fld       QWORD PTR $2$1_2il0floatpacket$23             ; 186.4
        mov       edx, DWORD PTR [ebp-100]                      ;
        fstp      QWORD PTR [esi+eax*8+7999488]                 ; 186.4
        fld       QWORD PTR $2$1_2il0floatpacket$25             ; 187.4
        fstp      QWORD PTR [edi+eax*8+7999488]                 ; 187.4
        fld       QWORD PTR $2$1_2il0floatpacket$27             ; 188.4
        fstp      QWORD PTR [edx+eax*8+7999488]                 ; 188.4
        fld       QWORD PTR $2$1_2il0floatpacket$23             ; 186.4
        fstp      QWORD PTR [esi+eax*8+7999496]                 ; 186.4
        fld       QWORD PTR $2$1_2il0floatpacket$25             ; 187.4
        fstp      QWORD PTR [edi+eax*8+7999496]                 ; 187.4
        fld       QWORD PTR $2$1_2il0floatpacket$27             ; 188.4
        fstp      QWORD PTR [edx+eax*8+7999496]                 ; 188.4
        add       eax, 2                                        ; 185.22
        jne       $B1$57        ; Prob 80%                      ; 185.3
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$58:                         ; Preds $B1$57
        mov       edi, DWORD PTR [ebp-48]                       ;
        mov       esi, DWORD PTR [ebp-44]                       ;
        mov       eax, -131072                                  ; 190.8
        ALIGN     4                                             ;
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$59:                         ; Preds $B1$59 $B1$58
                                ;unroll=1
        fld       QWORD PTR $2$1_2il0floatpacket$29             ; 191.4
        fstp      QWORD PTR [esi+eax*8+1048576]                 ; 191.4
        fld       QWORD PTR $2$1_2il0floatpacket$31             ; 192.4
        fstp      QWORD PTR [edi+eax*8+1048576]                 ; 192.4
        fld       QWORD PTR $2$1_2il0floatpacket$29             ; 191.4
        fstp      QWORD PTR [esi+eax*8+1048584]                 ; 191.4
        fld       QWORD PTR $2$1_2il0floatpacket$31             ; 192.4
        fstp      QWORD PTR [edi+eax*8+1048584]                 ; 192.4
        add       eax, 2                                        ; 190.26
        jne       $B1$59        ; Prob 80%                      ; 190.3
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$60:                         ; Preds $B1$59
        mov       eax, -131072                                  ; 195.8
        ALIGN     4                                             ;
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$61:                         ; Preds $B1$61 $B1$60
                                ;unroll=1
        fld       QWORD PTR [edi+eax*8+1048576]                 ; 196.14
        fstp      QWORD PTR [esi+eax*8+1048576]                 ; 196.7
        fld       QWORD PTR [edi+eax*8+1048584]                 ; 196.14
        fstp      QWORD PTR [esi+eax*8+1048584]                 ; 196.7
        add       eax, 2                                        ; 195.26
        jne       $B1$61        ; Prob 80%                      ; 195.3
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$62:                         ; Preds $B1$61
        add       esp, -8                                       ; 198.24
        fld       QWORD PTR [ebp-56]                            ;
        fstp      QWORD PTR [esp]                               ; 198.24
        call      ?second@@YANN@Z                               ; 198.24
                                ; LOE ebx ebp esi edi esp bl bh mm0
$B1$63:                         ; Preds $B1$62
        mov       eax, DWORD PTR [ebp-168]                      ; 198.3
        mov       edx, DWORD PTR [ebp-72]                       ;
        add       esp, 8                                        ; 198.24
        mov       DWORD PTR [ebp-44], esi                       ;
        fstp      QWORD PTR [eax+edx*8]                         ; 198.3
        mov       eax, -999936                                  ; 199.8
        mov       esi, DWORD PTR [ebp-64]                       ;
        mov       DWORD PTR [ebp-48], edi                       ;
        mov       edi, DWORD PTR [ebp-100]                      ;
        ALIGN     4                                             ;
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$64:                         ; Preds $B1$64 $B1$63
                                ;unroll=1
        fld       QWORD PTR [esi+eax*8+7999488]                 ; 200.14
        fstp      QWORD PTR [edi+eax*8+7999488]                 ; 200.7
        fld       QWORD PTR [esi+eax*8+7999496]                 ; 200.14
        fstp      QWORD PTR [edi+eax*8+7999496]                 ; 200.7
        add       eax, 2                                        ; 199.22
        jne       $B1$64        ; Prob 80%                      ; 199.3
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$65:                         ; Preds $B1$64
        add       esp, -8                                       ; 204.24
        mov       edi, DWORD PTR [ebp-48]                       ;
        fld       QWORD PTR [ebp-56]                            ;
        mov       esi, DWORD PTR [ebp-44]                       ;
        fstp      QWORD PTR [esp]                               ; 204.24
        call      ?second@@YANN@Z                               ; 204.24
                                ; LOE ebx ebp esi edi esp bl bh mm0
$B1$66:                         ; Preds $B1$65
        mov       eax, DWORD PTR [ebp-168]                      ; 204.32
        mov       edx, DWORD PTR [ebp-72]                       ;
        fsub      QWORD PTR [eax+edx*8]                         ; 204.32
        add       esp, 8                                        ; 204.24
        fstp      QWORD PTR [eax+edx*8]                         ; 204.3
        mov       eax, -131072                                  ; 206.8
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$67:                         ; Preds $B1$67 $B1$66
                                ;unroll=1
        jmp       $L4                                           ;
        ALIGN     4                                             ;
$L5:                                                            ;
        fstp      QWORD PTR [esi+eax*8+1048568]                 ;
$L4:                                                            ;
        fld       QWORD PTR [edi+eax*8+1048576]                 ; 207.20
        fmul      QWORD PTR $2$1_2il0floatpacket$33             ; 207.20
        fstp      QWORD PTR [esi+eax*8+1048576]                 ; 207.7
        fld       QWORD PTR [edi+eax*8+1048584]                 ; 207.20
        fmul      QWORD PTR $2$1_2il0floatpacket$33             ; 207.20
        add       eax, 2                                        ; 206.26
        jne       $L5                                           ; 206.3
        fstp      QWORD PTR [esi+eax*8+1048568]                 ; 207.7
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$68:                         ; Preds $B1$67
        add       esp, -8                                       ; 209.24
        fld       QWORD PTR [ebp-56]                            ;
        fstp      QWORD PTR [esp]                               ; 209.24
        call      ?second@@YANN@Z                               ; 209.24
                                ; LOE ebx ebp esi edi esp bl bh mm0
$B1$69:                         ; Preds $B1$68
        mov       eax, DWORD PTR [ebp-164]                      ; 209.3
        mov       edx, DWORD PTR [ebp-72]                       ;
        add       esp, 8                                        ; 209.24
        mov       DWORD PTR [ebp-44], esi                       ;
        fstp      QWORD PTR [eax+edx*8]                         ; 209.3
        mov       eax, -999936                                  ; 210.8
        mov       esi, DWORD PTR [ebp-100]                      ;
        mov       DWORD PTR [ebp-48], edi                       ;
        mov       edi, DWORD PTR [ebp-68]                       ;
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$70:                         ; Preds $B1$70 $B1$69
                                ;unroll=1
        jmp       $L6                                           ;
        ALIGN     4                                             ;
$L7:                                                            ;
        fstp      QWORD PTR [edi+eax*8+7999480]                 ;
$L6:                                                            ;
        fld       QWORD PTR [esi+eax*8+7999488]                 ; 213.18
        fmul      QWORD PTR $2$1_2il0floatpacket$35             ; 213.18
        fstp      QWORD PTR [edi+eax*8+7999488]                 ; 213.4
        fld       QWORD PTR [esi+eax*8+7999496]                 ; 213.18
        fmul      QWORD PTR $2$1_2il0floatpacket$35             ; 213.18
        add       eax, 2                                        ; 210.22
        jne       $L7                                           ; 210.3
        fstp      QWORD PTR [edi+eax*8+7999480]                 ; 213.4
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$71:                         ; Preds $B1$70
        add       esp, -8                                       ; 217.24
        mov       edi, DWORD PTR [ebp-48]                       ;
        fld       QWORD PTR [ebp-56]                            ;
        mov       esi, DWORD PTR [ebp-44]                       ;
        fstp      QWORD PTR [esp]                               ; 217.24
        call      ?second@@YANN@Z                               ; 217.24
                                ; LOE ebx ebp esi edi esp bl bh mm0
$B1$72:                         ; Preds $B1$71
        mov       eax, DWORD PTR [ebp-164]                      ; 217.32
        mov       edx, DWORD PTR [ebp-72]                       ;
        fsub      QWORD PTR [eax+edx*8]                         ; 217.32
        add       esp, 8                                        ; 217.24
        fstp      QWORD PTR [eax+edx*8]                         ; 217.3
        mov       eax, -131072                                  ; 219.8
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$73:                         ; Preds $B1$73 $B1$72
                                ;unroll=1
        jmp       $L8                                           ;
        ALIGN     4                                             ;
$L9:                                                            ;
        fstp      QWORD PTR [edi+eax*8+1048568]                 ;
$L8:                                                            ;
        fld       QWORD PTR [esi+eax*8+1048576]                 ; 220.20
        fmul      QWORD PTR $2$1_2il0floatpacket$37             ; 220.20
        fstp      QWORD PTR [edi+eax*8+1048576]                 ; 220.7
        fld       QWORD PTR [esi+eax*8+1048584]                 ; 220.20
        fmul      QWORD PTR $2$1_2il0floatpacket$37             ; 220.20
        add       eax, 2                                        ; 219.26
        jne       $L9                                           ; 219.3
        fstp      QWORD PTR [edi+eax*8+1048568]                 ; 220.7
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$74:                         ; Preds $B1$73
        add       esp, -8                                       ; 222.24
        fld       QWORD PTR [ebp-56]                            ;
        fstp      QWORD PTR [esp]                               ; 222.24
        call      ?second@@YANN@Z                               ; 222.24
                                ; LOE ebx ebp esi edi esp bl bh mm0
$B1$75:                         ; Preds $B1$74
        mov       eax, DWORD PTR [ebp-160]                      ; 222.3
        mov       edx, DWORD PTR [ebp-72]                       ;
        add       esp, 8                                        ; 222.24
        mov       DWORD PTR [ebp-44], esi                       ;
        fstp      QWORD PTR [eax+edx*8]                         ; 222.3
        mov       eax, -999936                                  ; 223.8
        mov       esi, DWORD PTR [ebp-64]                       ;
        mov       DWORD PTR [ebp-48], edi                       ;
        mov       edi, DWORD PTR [ebp-68]                       ;
        ALIGN     4                                             ;
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$76:                         ; Preds $B1$76 $B1$75
                                ;unroll=1
        fld       QWORD PTR [edi+eax*8+7999488]                 ; 224.19
        fadd      QWORD PTR [esi+eax*8+7999488]                 ; 224.19
        mov       edx, DWORD PTR [ebp-100]                      ;
        fstp      QWORD PTR [edx+eax*8+7999488]                 ; 224.7
        fld       QWORD PTR [edi+eax*8+7999496]                 ; 224.19
        fadd      QWORD PTR [esi+eax*8+7999496]                 ; 224.19
        fstp      QWORD PTR [edx+eax*8+7999496]                 ; 224.7
        add       eax, 2                                        ; 223.22
        jne       $B1$76        ; Prob 80%                      ; 223.3
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$77:                         ; Preds $B1$76
        add       esp, -8                                       ; 228.24
        mov       edi, DWORD PTR [ebp-48]                       ;
        fld       QWORD PTR [ebp-56]                            ;
        mov       esi, DWORD PTR [ebp-44]                       ;
        fstp      QWORD PTR [esp]                               ; 228.24
        call      ?second@@YANN@Z                               ; 228.24
                                ; LOE ebx ebp esi edi esp bl bh mm0
$B1$78:                         ; Preds $B1$77
        mov       eax, DWORD PTR [ebp-160]                      ; 228.32
        mov       edx, DWORD PTR [ebp-72]                       ;
        fsub      QWORD PTR [eax+edx*8]                         ; 228.32
        add       esp, 8                                        ; 228.24
        fstp      QWORD PTR [eax+edx*8]                         ; 228.3
        mov       eax, -131072                                  ; 230.8
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$79:                         ; Preds $B1$79 $B1$78
                                ;unroll=1
        jmp       $L10                                          ;
        ALIGN     4                                             ;
$L11:                                                           ;
        fstp      QWORD PTR [edi+eax*8+1048568]                 ;
$L10:                                                           ;
        fld       QWORD PTR [esi+eax*8+1048576]                 ; 231.20
        fmul      QWORD PTR $2$1_2il0floatpacket$39             ; 231.20
        fstp      QWORD PTR [edi+eax*8+1048576]                 ; 231.7
        fld       QWORD PTR [esi+eax*8+1048584]                 ; 231.20
        fmul      QWORD PTR $2$1_2il0floatpacket$39             ; 231.20
        add       eax, 2                                        ; 230.26
        jne       $L11                                          ; 230.3
        fstp      QWORD PTR [edi+eax*8+1048568]                 ; 231.7
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$80:                         ; Preds $B1$79
        add       esp, -8                                       ; 233.24
        fld       QWORD PTR [ebp-56]                            ;
        fstp      QWORD PTR [esp]                               ; 233.24
        call      ?second@@YANN@Z                               ; 233.24
                                ; LOE ebx ebp esi edi esp bl bh mm0
$B1$81:                         ; Preds $B1$80
        mov       eax, DWORD PTR [ebp-156]                      ; 233.3
        mov       edx, DWORD PTR [ebp-72]                       ;
        add       esp, 8                                        ; 233.24
        mov       DWORD PTR [ebp-44], esi                       ;
        fstp      QWORD PTR [eax+edx*8]                         ; 233.3
        mov       eax, -999936                                  ; 234.8
        mov       esi, DWORD PTR [ebp-64]                       ;
        mov       DWORD PTR [ebp-48], edi                       ;
        mov       edi, DWORD PTR [ebp-68]                       ;
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$82:                         ; Preds $B1$82 $B1$81
                                ;unroll=1
        jmp       $L12                                          ;
        ALIGN     4                                             ;
$L13:                                                           ;
        fstp      QWORD PTR [esi+eax*8+7999480]                 ;
$L12:                                                           ;
        mov       edx, DWORD PTR [ebp-100]                      ;
        fld       QWORD PTR $2$1_2il0floatpacket$41             ; 235.7
        fmul      QWORD PTR [edx+eax*8+7999488]                 ; 235.26
        fadd      QWORD PTR [edi+eax*8+7999488]                 ; 235.26
        fstp      QWORD PTR [esi+eax*8+7999488]                 ; 235.7
        fld       QWORD PTR $2$1_2il0floatpacket$41             ; 235.7
        fmul      QWORD PTR [edx+eax*8+7999496]                 ; 235.26
        fadd      QWORD PTR [edi+eax*8+7999496]                 ; 235.26
        add       eax, 2                                        ; 234.22
        jne       $L13                                          ; 234.3
        fstp      QWORD PTR [esi+eax*8+7999480]                 ; 235.7
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B1$83:                         ; Preds $B1$82
        add       esp, -8                                       ; 239.24
        mov       edi, DWORD PTR [ebp-48]                       ;
        fld       QWORD PTR [ebp-56]                            ;
        mov       esi, DWORD PTR [ebp-44]                       ;
        fstp      QWORD PTR [esp]                               ; 239.24
        call      ?second@@YANN@Z                               ; 239.24
                                ; LOE ebx ebp esi edi esp bl bh mm0
$B1$84:                         ; Preds $B1$83
        mov       eax, DWORD PTR [ebp-156]                      ; 239.32
        mov       edx, DWORD PTR [ebp-72]                       ;
        fsub      QWORD PTR [eax+edx*8]                         ; 239.32
        mov       ecx, DWORD PTR [ebp-64]                       ;
        fstp      QWORD PTR [eax+edx*8]                         ; 239.3
        mov       DWORD PTR [esp], ecx                          ; 243.13
        call      ??3@YAXPAX@Z                                  ; 243.13
                                ; LOE ebx ebp esi edi esp bl bh
$B1$85:                         ; Preds $B1$84
        mov       eax, DWORD PTR [ebp-68]                       ;
        mov       DWORD PTR [esp], eax                          ; 244.13
        call      ??3@YAXPAX@Z                                  ; 244.13
                                ; LOE ebx ebp esi edi esp bl bh
$B1$86:                         ; Preds $B1$85
        mov       eax, DWORD PTR [ebp-100]                      ;
        mov       DWORD PTR [esp], eax                          ; 245.13
        call      ??3@YAXPAX@Z                                  ; 245.13
                                ; LOE ebx ebp esi edi esp bl bh
$B1$87:                         ; Preds $B1$86
        mov       DWORD PTR [esp], esi                          ; 246.13
        call      ??3@YAXPAX@Z                                  ; 246.13
                                ; LOE ebx ebp edi esp bl bh
$B1$88:                         ; Preds $B1$87
        mov       DWORD PTR [esp], edi                          ; 247.13
        call      ??3@YAXPAX@Z                                  ; 247.13
                                ; LOE ebx ebp esp bl bh
$B1$89:                         ; Preds $B1$88
        mov       eax, DWORD PTR [ebp-72]                       ;
        add       esp, 8                                        ; 247.13
        inc       eax                                           ; 173.25
        mov       edx, DWORD PTR [ebp-96]                       ;
        mov       DWORD PTR [ebp-72], eax                       ; 173.25
        cmp       eax, edx                                      ; 173.5
        jl        $B1$46        ; Prob 80%                      ; 173.5
                                ; LOE edx ebx ebp esp dl dh bl bh
$B1$90:                         ; Preds $B1$89
        mov       edi, edx                                      ;
                                ; LOE ebx ebp edi esp bl bh
$B1$91:                         ; Preds $B1$90 $B1$138 $B1$134 $B1$44
        call      DWORD PTR __imp__GetCurrentProcess@0          ; 250.22
                                ; LOE eax ebx ebp edi esp al ah bl bh
$B1$92:                         ; Preds $B1$91
        add       esp, -8                                       ; 250.22
        mov       DWORD PTR [esp+4], 32                         ; 250.22
        mov       DWORD PTR [esp], eax                          ; 250.22
        call      DWORD PTR __imp__SetPriorityClass@8           ; 250.22
                                ; LOE ebx ebp edi esp bl bh
$B1$93:                         ; Preds $B1$92

;;; 	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);

        call      DWORD PTR __imp__GetCurrentThread@0           ; 251.20
                                ; LOE eax ebx ebp edi esp al ah bl bh
$B1$94:                         ; Preds $B1$93
        add       esp, -8                                       ; 251.20
        mov       DWORD PTR [esp+4], 0                          ; 251.20
        mov       DWORD PTR [esp], eax                          ; 251.20
        call      DWORD PTR __imp__SetThreadPriority@8          ; 251.20
                                ; LOE ebx ebp edi esp bl bh
$B1$95:                         ; Preds $B1$94
        mov       eax, DWORD PTR [ebp-92]                       ;

;;; 
;;; 	if (a==NULL || b==NULL || c==NULL || d==NULL || e==NULL) {

        test      eax, eax                                      ; 253.2
        je        $B1$132       ; Prob 12%                      ; 253.2
                                ; LOE ebx ebp edi esp bl bh
$B1$96:                         ; Preds $B1$95
        mov       eax, DWORD PTR [ebp-88]                       ;
        test      eax, eax                                      ; 253.2
        je        $B1$132       ; Prob 12%                      ; 253.2
                                ; LOE ebx ebp edi esp bl bh
$B1$97:                         ; Preds $B1$96
        mov       eax, DWORD PTR [ebp-84]                       ;
        test      eax, eax                                      ; 253.2
        je        $B1$132       ; Prob 12%                      ; 253.2
                                ; LOE ebx ebp edi esp bl bh
$B1$98:                         ; Preds $B1$97
        mov       eax, DWORD PTR [ebp-80]                       ;
        test      eax, eax                                      ; 253.2
        je        $B1$132       ; Prob 12%                      ; 253.2
                                ; LOE ebx ebp edi esp bl bh
$B1$99:                         ; Preds $B1$98
        mov       eax, DWORD PTR [ebp-76]                       ;
        test      eax, eax                                      ; 253.2
        je        $B1$132       ; Prob 12%                      ; 253.2
                                ; LOE ebx ebp edi esp bl bh
$B1$100:                        ; Preds $B1$99

;;; 		printf ("\nerror allocating arrays\n");
;;; 		return 1;
;;; 	}
;;; 
;;;     /*	--- SUMMARY --- */
;;;     for (k=0; k<NTIMES; k++)

        xor       ecx, ecx                                      ; 259.10
        test      edi, edi                                      ; 259.5
        jle       $B1$110       ; Prob 20%                      ; 259.5
                                ; LOE ecx ebx ebp edi esp cl ch bl bh
$B1$102:                        ; Preds $B1$100 $B1$108

;;; 	{
;;; 		for (j=0; j<4; j++)

        mov       edx, -4                                       ; 261.8
        ALIGN     4                                             ;
                                ; LOE edx ecx ebx ebp edi esp dl dh cl ch bl bh
$B1$103:                        ; Preds $B1$107 $B1$102

;;; 	    {
;;; 			rmstime[j] = rmstime[j] + (times[j][k] * times[j][k]);

        mov       eax, DWORD PTR [ebp+edx*4-152]                ; 263.45
        fld       QWORD PTR _rmstime[0+edx*8+32]                ; 263.25
        fld       QWORD PTR [eax+ecx*8]                         ; 263.31

;;; 			mintime[j] = MIN(mintime[j], times[j][k]);

        fld       QWORD PTR _mintime[0+edx*8+32]                ; 264.17
        fxch      st(1)                                         ; 264.17
        fmul      st, st(0)                                     ; 263.45
        faddp     st(2), st                                     ; 263.45
        fxch      st(1)                                         ; 263.45
        fstp      QWORD PTR _rmstime[0+edx*8+32]                ; 263.12
        mov       eax, DWORD PTR [ebp+edx*4-152]                ; 264.17
        fld       QWORD PTR [eax+ecx*8]                         ; 264.17
        fcom                                                    ; 264.12
        fnstsw    ax                                            ; 264.12
        sahf                                                    ; 264.12
        jbe       $B1$131       ; Prob 16%                      ; 264.12
                                ; LOE edx ecx ebx ebp edi esp dl dh cl ch bl bh mm0 mm1
$B1$104:                        ; Preds $B1$103
        fstp      st(0)                                         ;
                                ; LOE edx ecx ebx ebp edi esp dl dh cl ch bl bh mm2
$B1$105:                        ; Preds $B1$104 $B1$131
        fstp      QWORD PTR _mintime[0+edx*8+32]                ; 264.12

;;; 			maxtime[j] = MAX(maxtime[j], times[j][k]);

        mov       eax, DWORD PTR [ebp+edx*4-152]                ; 265.17
        fld       QWORD PTR _maxtime[0+edx*8+32]                ; 265.17
        fld       QWORD PTR [eax+ecx*8]                         ; 265.17
        fcom                                                    ; 265.12
        fnstsw    ax                                            ; 265.12
        sahf                                                    ; 265.12
        jae       $B1$130       ; Prob 16%                      ; 265.12
                                ; LOE edx ecx ebx ebp edi esp dl dh cl ch bl bh mm0 mm1
$B1$106:                        ; Preds $B1$105
        fstp      st(0)                                         ;
                                ; LOE edx ecx ebx ebp edi esp dl dh cl ch bl bh mm2
$B1$107:                        ; Preds $B1$106 $B1$130
        fstp      QWORD PTR _maxtime[0+edx*8+32]                ; 265.12
        inc       edx                                           ; 261.18
        jne       $B1$103       ; Prob 80%                      ; 261.3
                                ; LOE edx ecx ebx ebp edi esp dl dh cl ch bl bh
$B1$108:                        ; Preds $B1$107
        inc       ecx                                           ; 259.25
        cmp       ecx, edi                                      ; 259.5
        jl        $B1$102       ; Prob 80%                      ; 259.5
                                ; LOE ecx ebx ebp edi esp cl ch bl bh
$B1$110:                        ; Preds $B1$108 $B1$100

;;; 	    }
;;; 	}
;;;    
;;; 	time_file=fopen("times.txt", "w");

        add       esp, -8                                       ; 269.12
        mov       DWORD PTR [esp+4], OFFSET FLAT: ??_C@_01A@w?$AA@ ; 269.12
        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_09A@times?4txt?$AA@ ; 269.12
        call      _fopen                                        ; 269.12
                                ; LOE eax ebx ebp edi esp al ah bl bh
$B1$111:                        ; Preds $B1$110
        add       esp, 8                                        ; 269.12

;;; 	if (time_file==NULL) 

        test      eax, eax                                      ; 270.2
        mov       DWORD PTR [ebp-44], eax                       ; 269.12
        je        $B1$128       ; Prob 12%                      ; 270.2
                                ; LOE eax ebx ebp edi esp al ah bl bh
$B1$112:                        ; Preds $B1$111

;;; 		printf ("\ncouldn't open times.txt\n");
;;; 	else {
;;; 		fprintf(time_file, "copy\tscale\tadd\ttriad\n");

        add       esp, -8                                       ; 273.11
        mov       DWORD PTR [esp+4], eax                        ; 273.11
        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0BG@A@copy?7scale?7add?7triad?6?$AA@ ; 273.11
        call      _fputs                                        ; 273.11
                                ; LOE ebx ebp edi esp bl bh
$B1$113:                        ; Preds $B1$112

;;; 		for (ti=0; ti<NTIMES; ti++) {

        xor       esi, esi                                      ; 274.8
        add       esp, 8                                        ; 273.11
        test      edi, edi                                      ; 274.3
        jle       $B1$118       ; Prob 20%                      ; 274.3
        ALIGN     4                                             ;
                                ; LOE ebx ebp esi edi esp bl bh
$B1$115:                        ; Preds $B1$113 $B1$116

;;; 			fprintf(time_file, "%f\t%f\t%f\t%f\n", 
;;; 				times[0][ti],
;;; 				times[1][ti],
;;; 				times[2][ti],
;;; 				times[3][ti]);

        add       esp, -40                                      ; 279.5
        mov       eax, OFFSET FLAT: ??_C@_0N@A@?$CFf?7?$CFf?7?$CFf?7?$CFf?6?$AA@ ; 279.5
        mov       edx, DWORD PTR [ebp-44]                       ;
        mov       DWORD PTR [esp+4], eax                        ; 279.5
        mov       eax, DWORD PTR [ebp-168]                      ; 276.5
        mov       DWORD PTR [esp], edx                          ; 279.5
        fld       QWORD PTR [eax+esi*8]                         ; 276.5
        fstp      QWORD PTR [esp+8]                             ; 279.5
        mov       eax, DWORD PTR [ebp-164]                      ; 277.5
        fld       QWORD PTR [eax+esi*8]                         ; 277.5
        fstp      QWORD PTR [esp+16]                            ; 279.5
        mov       eax, DWORD PTR [ebp-160]                      ; 278.5
        fld       QWORD PTR [eax+esi*8]                         ; 278.5
        fstp      QWORD PTR [esp+24]                            ; 279.5
        mov       eax, DWORD PTR [ebp-156]                      ; 279.5
        fld       QWORD PTR [eax+esi*8]                         ; 279.5
        fstp      QWORD PTR [esp+32]                            ; 279.5
        call      _fprintf                                      ; 279.5
                                ; LOE ebx ebp esi edi esp bl bh
$B1$116:                        ; Preds $B1$115
        inc       esi                                           ; 274.25
        add       esp, 40                                       ; 279.5
        cmp       esi, edi                                      ; 274.3
        jl        $B1$115       ; Prob 80%                      ; 274.3
                                ; LOE ebx ebp esi edi esp bl bh
$B1$118:                        ; Preds $B1$116 $B1$113

;;; 		}
;;; 		fclose (time_file);

        add       esp, -8                                       ; 281.11
        mov       eax, DWORD PTR [ebp-44]                       ;
        mov       DWORD PTR [esp], eax                          ; 281.11
        call      _fclose                                       ; 281.11
                                ; LOE ebx ebp edi esp bl bh
$B1$119:                        ; Preds $B1$118
        add       esp, 8                                        ; 281.11
                                ; LOE ebx ebp edi esp bl bh
$B1$120:                        ; Preds $B1$129 $B1$119

;;; 	}
;;; 	for (ti=0; ti<4; ti++) {

        mov       esi, ebp                                      ; 283.7
        mov       DWORD PTR [ebp-96], edi                       ;
        mov       DWORD PTR [ebp-40], esi                       ; 283.7
        mov       eax, esi                                      ; 283.7
        lea       esi, DWORD PTR [ebp+16]                       ; 283.7
        mov       edi, esi                                      ;
        mov       esi, eax                                      ;
        ALIGN     4                                             ;
                                ; LOE ebx ebp esi edi esp bl bh
$B1$121:                        ; Preds $B1$122 $B1$120

;;; 		delete [] times[ti];

        add       esp, -8                                       ; 284.13
        mov       eax, DWORD PTR [esi-168]                      ; 284.13
        mov       DWORD PTR [esp], eax                          ; 284.13
        call      ??3@YAXPAX@Z                                  ; 284.13
                                ; LOE ebx ebp esi edi esp bl bh
$B1$122:                        ; Preds $B1$121
        add       esi, 4                                        ; 283.19
        add       esp, 8                                        ; 284.13
        cmp       edi, esi                                      ; 283.2
        jg        $B1$121       ; Prob 80%                      ; 283.2
                                ; LOE ebx ebp esi edi esp bl bh
$B1$123:                        ; Preds $B1$122

;;; 	}
;;;     printf("Function      Rate (MB/s)   RMS time     Min time     Max time\n");

        add       esp, -8                                       ; 286.5
        mov       edi, DWORD PTR [ebp-96]                       ;
        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0EA@KCIKNIDN@Function?5?5?5?5?5?5Rate?5?$CIMB?1s?$CJ?5?5?5RMS?5@ ; 286.5
        call      _printf                                       ; 286.5
                                ; LOE ebx ebp edi esp bl bh
$B1$124:                        ; Preds $B1$123

;;;     for (j=0; j<4; j++) {
;;; 		rmstime[j] = sqrt(rmstime[j]/(double)NTIMES);

        mov       DWORD PTR [ebp-152], edi                      ; 288.40
        add       esp, 8                                        ; 286.5
        fild      DWORD PTR [ebp-152]                           ; 288.40
        fdivr     QWORD PTR $2$1_2il0floatpacket$19             ; 288.40
        mov       esi, -4                                       ; 288.40

;;; 
;;; 		printf("%s%11.4f  %11.4f  %11.4f  %11.4f\n", label[j],
;;; 	       1.0E-06 * bytes[j]/mintime[j],
;;; 	       rmstime[j],
;;; 	       mintime[j],
;;; 	       maxtime[j]);

        mov       edi, OFFSET FLAT: ??_C@_0CC@CGC@?$CFs?$CF11?44f?5?5?$CF11?44f?5?5?$CF11?44f?5?5?$CF11?44f@ ; 294.17
        fstp      QWORD PTR [ebp-40]                            ; 288.40
        ALIGN     4                                             ;
                                ; LOE ebx ebp esi edi esp bl bh
$B1$125:                        ; Preds $B1$126 $B1$124
        fld       QWORD PTR _rmstime[0+esi*8+32]                ; 288.29
        fmul      QWORD PTR [ebp-40]                            ; 288.40
        fsqrt                                                   ; 288.40
        add       esp, -40                                      ; 294.17
        mov       eax, DWORD PTR _label[0+esi*4+16]             ; 290.54
        fld       QWORD PTR _mintime[0+esi*8+32]                ; 291.36
        fld       QWORD PTR _mintime[0+esi*8+32]                ; 291.36
        fxch      st(2)                                         ; 291.36
        fst       QWORD PTR _rmstime[0+esi*8+32]                ; 288.11
        mov       DWORD PTR [esp+4], eax                        ; 294.17
        mov       DWORD PTR [esp], edi                          ; 294.17
        fxch      st(1)                                         ; 294.17
        fdivr     QWORD PTR [ebp+esi*8-168]                     ; 291.19
        fxch      st(2)                                         ; 291.19
        fstp      QWORD PTR [esp+24]                            ; 294.17
        fstp      QWORD PTR [esp+16]                            ; 294.17
        fmul      QWORD PTR $2$1_2il0floatpacket$21             ; 291.36
        fstp      QWORD PTR [esp+8]                             ; 294.17
        fld       QWORD PTR _maxtime[0+esi*8+32]                ; 294.17
        fstp      QWORD PTR [esp+32]                            ; 294.17
        call      _printf                                       ; 294.17
                                ; LOE ebx ebp esi edi esp bl bh
$B1$126:                        ; Preds $B1$125
        add       esp, 40                                       ; 294.17
        inc       esi                                           ; 287.20
        jne       $B1$125       ; Prob 80%                      ; 287.5
                                ; LOE ebx ebp esi edi esp bl bh
$B1$127:                        ; Preds $B1$126

;;;     }
;;;     return 0;

        xor       eax, eax                                      ; 296.5
        mov       esi, DWORD PTR [esp+4]                        ; 296.5
        mov       edi, DWORD PTR [esp+8]                        ; 296.5
        mov       esp, ebp                                      ; 296.5
        pop       ebp                                           ; 296.5
        mov       esp, ebx                                      ; 296.5
        pop       ebx                                           ; 296.5
        ret                                                     ; 296.5
                                ; LOE ebx ebp esi edi esp bl bh
$B1$128:                        ; Preds $B1$111                 ; Infreq
        add       esp, -8                                       ; 271.3
        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0BK@A@?6couldn?8t?5open?5times?4txt?6?$AA@ ; 271.3
        call      _printf                                       ; 271.3
                                ; LOE ebx ebp edi esp bl bh
$B1$129:                        ; Preds $B1$128
        add       esp, 8                                        ; 271.3
        jmp       $B1$120       ; Prob 100%                     ; 271.3
                                ; LOE ebx ebp edi esp bl bh
$B1$130:                        ; Preds $B1$105                 ; Infreq
        fstp      st(1)                                         ; 265.17
        jmp       $B1$107       ; Prob 100%                     ; 265.17
        ALIGN     4                                             ;
                                ; LOE edx ecx ebx ebp edi esp dl dh cl ch bl bh mm2
$B1$131:                        ; Preds $B1$103                 ; Infreq
        fstp      st(1)                                         ; 264.17
        jmp       $B1$105       ; Prob 100%                     ; 264.17
        ALIGN     4                                             ;
                                ; LOE edx ecx ebx ebp edi esp dl dh cl ch bl bh mm2
$B1$132:                        ; Preds $B1$95 $B1$96 $B1$97 $B1$98 $B1$99
                                ;      
        add       esp, -8                                       ; 254.3
        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0BK@A@?6error?5allocating?5arrays?6?$AA@ ; 254.3
        call      _printf                                       ; 254.3
                                ; LOE ebx ebp esp bl bh
$B1$133:                        ; Preds $B1$132
        add       esp, 8                                        ; 254.3
        mov       eax, 1                                        ; 255.3
        mov       esi, DWORD PTR [esp+4]                        ; 255.3
        mov       edi, DWORD PTR [esp+8]                        ; 255.3
        mov       esp, ebp                                      ; 255.3
        pop       ebp                                           ; 255.3
        mov       esp, ebx                                      ; 255.3
        pop       ebx                                           ; 255.3
        ret                                                     ; 255.3
                                ; LOE ebx ebp esi edi esp bl bh
$B1$134:                        ; Preds $B1$51 $B1$52 $B1$53 $B1$55 ; Infreq
        mov       edi, DWORD PTR [ebp-96]                       ;
        jmp       $B1$91        ; Prob 100%                     ;
                                ; LOE ebx ebp edi esp bl bh
$B1$138:                        ; Preds $B1$54                  ; Infreq
        mov       edi, DWORD PTR [ebp-96]                       ;
        jmp       $B1$91        ; Prob 100%                     ;
                                ; LOE ebx ebp edi esp bl bh
$B1$139:                        ; Preds $B1$23                  ; Infreq
        add       esp, -8                                       ; 145.3
        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0BJ@A@Error?5allocating?5arrays?6?$AA@ ; 145.3
        call      _printf                                       ; 145.3
                                ; LOE ebx ebp esp bl bh
$B1$140:                        ; Preds $B1$139
        add       esp, 8                                        ; 145.3
        mov       eax, 1                                        ; 146.3
        mov       esi, DWORD PTR [esp+4]                        ; 146.3
        mov       edi, DWORD PTR [esp+8]                        ; 146.3
        mov       esp, ebp                                      ; 146.3
        pop       ebp                                           ; 146.3
        mov       esp, ebx                                      ; 146.3
        pop       ebx                                           ; 146.3
        ret                                                     ; 146.3
                                ; LOE ebx ebp esi edi esp bl bh
$B1$141:                        ; Preds $B1$19                  ; Infreq
        add       esp, -8                                       ; 140.2
        mov       DWORD PTR [esp], OFFSET FLAT: ??_C@_0EB@GHNAPMKF@Your?5clock?5granularity?5appears?5t@ ; 140.2
        call      _printf                                       ; 140.2
                                ; LOE ebx ebp edi esp bl bh
$B1$142:                        ; Preds $B1$141
        add       esp, 8                                        ; 140.2
        jmp       $B1$22        ; Prob 100%                     ; 140.2
                                ; LOE ebx ebp edi esp bl bh
$B1$143:                        ; Preds $B1$8                   ; Infreq
        add       esp, -8                                       ; 113.4
        mov       edx, OFFSET FLAT: ??_C@_0CF@FMCPCEEA@?6Error?5allocating?5arrays?4?5Quitti@ ; 113.4
        mov       DWORD PTR [esp], edx                          ; 113.4
        call      _printf                                       ; 113.4
                                ; LOE ebx ebp esi edi esp bl bh
$B1$144:                        ; Preds $B1$143
        mov       eax, DWORD PTR [ebp-100]                      ;
        mov       DWORD PTR [esp], eax                          ; 114.4
        call      _exit                                         ; 114.4
                                ; LOE ebx ebp esi edi esp bl bh
$B1$145:                        ; Preds $B1$144
        add       esp, 8                                        ; 114.4
        jmp       $B1$9         ; Prob 100%                     ; 114.4
        ALIGN     4                                             ;
        ALIGN     4                                             ;
                                ; LOE ebx ebp esi edi esp bl bh
; mark_end;
_main ENDP
;_main	ENDS
_TEXT	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
bytes_6073$0	DD 000000000H,0416e8400H	; xf64
	DD 000000000H,0416e8400H	; xf64
	DD 000000000H,04176e300H	; xf64
	DD 000000000H,04176e300H	; xf64
$2$1_2il0floatpacket$1	DD 000000000H,0412e8480H	; xf64
$2$1_2il0floatpacket$3	DD 000000000H,0416e8400H	; xf64
$2$1_2il0floatpacket$5	DD 000000000H,0416e8400H	; xf64
$2$1_2il0floatpacket$7	DD 000000000H,04176e300H	; xf64
$2$1_2il0floatpacket$9	DD 000000000H,04176e300H	; xf64
$2$1_2il0floatpacket$11	DD 000000000H,04038e300H	; xf64
$2$1_2il0floatpacket$13	DD 000000000H,040080000H	; xf64
$2$1_2il0floatpacket$15	DD 000000000H,040000000H	; xf64
$2$1_2il0floatpacket$17	DD 000000000H,0412e8480H	; xf64
$2$1_2il0floatpacket$19	DD 000000000H,03ff00000H	; xf64
$2$1_2il0floatpacket$21	DD 0a0b5ed8dH,03eb0c6f7H	; xf64
$2$1_2il0floatpacket$23	DD 000000000H,03ff00000H	; xf64
$2$1_2il0floatpacket$25	DD 000000000H,040000000H	; xf64
$2$1_2il0floatpacket$27	DD 000000000H,000000000H	; xf64
$2$1_2il0floatpacket$29	DD 000000000H,040140000H	; xf64
$2$1_2il0floatpacket$31	DD 000000000H,03ff00000H	; xf64
$2$1_2il0floatpacket$33	DD 000000000H,040140000H	; xf64
$2$1_2il0floatpacket$35	DD 000000000H,040080000H	; xf64
$2$1_2il0floatpacket$37	DD 000000000H,03ff80000H	; xf64
$2$1_2il0floatpacket$39	DD 000000000H,03fe00000H	; xf64
$2$1_2il0floatpacket$41	DD 000000000H,040080000H	; xf64
_DATA1	ENDS
_DATA	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA	ENDS
; -- End  _main
_DATA	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA	ENDS
_TEXT	SEGMENT PARA PUBLIC USE32 'CODE'
;	COMDAT ?checktick@@YAHN@Z
; -- Begin  ?checktick@@YAHN@Z
; mark_begin;
       ALIGN     4                                             ;
	PUBLIC   ?checktick@@YAHN@Z
?checktick@@YAHN@Z	PROC NEAR
$B2$1:                          ; Preds $B2$0

;;; {

        push      ebx                                           ; 302.1
        mov       ebx, esp                                      ; 302.1
        sub       esp, 8                                        ; 302.1
        and       esp, -16                                      ; 302.1
        add       esp, 8                                        ; 302.1
        jmp       $L14                                          ; 302.1
?checktick$$1@@YAHN@Z::                                         ;
        push      ebx                                           ; 302.1
        mov       ebx, esp                                      ; 302.1
$L14:                                                           ;
        push      edi                                           ; 302.1
        push      esi                                           ; 302.1
        push      ebp                                           ; 302.1
        sub       esp, 268                                      ; 302.1
                                ; LOE ebx esp bl bh
$B2$27:                         ; Preds $B2$1

;;;     int		i, minDelta, Delta;
;;;     double	t1, t2, timesfound[M];
;;; 
;;; /*  Collect a sequence of M unique time values from the system. */
;;; 
;;;     for (i = 0; i < M; i++) {

        mov       ebp, esp                                      ; 308.10
        lea       esi, DWORD PTR [esp+160]                      ; 308.10
                                ; LOE ebx ebp esi esp
$B2$2:                          ; Preds $B2$27 $B2$9

;;; 	t1 = second(core_freq);

        fld       QWORD PTR [ebx+8]                             ; 309.14
        fstp      QWORD PTR [esp]                               ; 309.14
        call      ?second@@YANN@Z                               ; 309.14
                                ; LOE ebx ebp esi esp mm0
$B2$3:                          ; Preds $B2$2

;;; 	while( ((t2=second(core_freq)) - t1) < 1.0E-6 )

        fld       QWORD PTR [ebx+8]                             ; 310.21
        fxch      st(1)                                         ; 310.21
        fstp      QWORD PTR [esp+208]                           ; 310.21
        fstp      QWORD PTR [esp]                               ; 310.21
        call      ?second@@YANN@Z                               ; 310.21
                                ; LOE ebx ebp esi esp mm0
$B2$4:                          ; Preds $B2$3
        fld       QWORD PTR [esp+208]                           ;
        fsubr     st, st(1)                                     ; 310.35
        fcomp     QWORD PTR $2$2_2il0floatpacket$43             ; 310.2
        fnstsw    ax                                            ; 310.2
        sahf                                                    ; 310.2
        fstp      QWORD PTR [esp+216]                           ; 310.21
        jae       $B2$9         ; Prob 16%                      ; 310.2
        ALIGN     4                                             ;
                                ; LOE ebx ebp esi esp
$B2$6:                          ; Preds $B2$4 $B2$7
        fld       QWORD PTR [ebx+8]                             ; 310.21
        fstp      QWORD PTR [esp]                               ; 310.21
        call      ?second@@YANN@Z                               ; 310.21
                                ; LOE ebx ebp esi esp mm0
$B2$7:                          ; Preds $B2$6
        fld       QWORD PTR [esp+208]                           ;
        fsubr     st, st(1)                                     ; 310.35
        fcomp     QWORD PTR $2$2_2il0floatpacket$45             ; 310.2
        fnstsw    ax                                            ; 310.2
        sahf                                                    ; 310.2
        fstp      QWORD PTR [esp+216]                           ; 310.21
        jb        $B2$6         ; Prob 84%                      ; 310.2
                                ; LOE ebx ebp esi esp
$B2$9:                          ; Preds $B2$7 $B2$4
        fld       QWORD PTR [esp+216]                           ;
        add       ebp, 8                                        ; 308.24
        cmp       esi, ebp                                      ; 308.5

;;; 	    ;
;;; 	timesfound[i] = t1 = t2;

        fstp      QWORD PTR [ebp]                               ; 312.2
        jg        $B2$2         ; Prob 80%                      ; 308.5
                                ; LOE ebx ebp esi esp
$B2$10:                         ; Preds $B2$9

;;; 	}
;;; 
;;; /*
;;;  * Determine the minimum difference between these M values.
;;;  * This result will be our estimate (in microseconds) for the
;;;  * clock granularity.
;;;  */
;;; 
;;;     minDelta = 1000000;

        mov       edi, 1000000                                  ; 321.5

;;;     for (i = 1; i < M; i++) {

        lea       edx, DWORD PTR [esp+8]                        ; 322.10
        ALIGN     4                                             ;
                                ; LOE edx ebx edi esp dl dh
$B2$11:                         ; Preds $B2$17 $B2$10

;;; 	Delta = (int)( 1.0E6 * (timesfound[i]-timesfound[i-1]));

        fld       QWORD PTR [edx+8]                             ; 323.26
        fsub      QWORD PTR [edx]                               ; 323.40
        fmul      QWORD PTR $2$2_2il0floatpacket$47             ; 323.40
        fstp      QWORD PTR [esp+192]                           ; 323.40
        mov       eax, DWORD PTR [esp+196]                      ; 323.40
        mov       esi, DWORD PTR [esp+192]                      ; 323.40
        mov       ecx, eax                                      ; 323.40
        shr       ecx, 20                                       ; 323.40
        and       ecx, 2047                                     ; 323.40
        cmp       ecx, 1022                                     ; 323.40
        jle       $B2$26        ; Prob 50%                      ; 323.40
                                ; LOE eax edx ecx ebx esi edi esp al ah dl dh cl ch
$B2$24:                         ; Preds $B2$11
        mov       ebp, 1054                                     ; 323.40
        mov       DWORD PTR [esp+224], edi                      ;
        mov       edi, eax                                      ;
        shld      edi, esi, 11                                  ; 323.40
        or        edi, -2147483648                              ; 323.40
        mov       esi, ecx                                      ; 323.40
        mov       ecx, ebp                                      ; 323.40
        sub       ecx, esi                                      ; 323.40
        mov       ebp, eax                                      ; 323.40
        mov       eax, edi                                      ; 323.40
        shr       eax, cl                                       ; 323.40
        test      ebp, ebp                                      ; 323.40
        mov       edi, DWORD PTR [esp+224]                      ;
        jge       $B2$23        ; Prob 50%                      ; 323.40
                                ; LOE eax edx ebx edi esp al ah dl dh
$B2$25:                         ; Preds $B2$24
        neg       eax                                           ; 323.40
        jmp       $B2$23        ; Prob 50%                      ; 323.40
        ALIGN     4                                             ;
                                ; LOE eax edx ebx edi esp al ah dl dh
$B2$26:                         ; Preds $B2$11 $B2$25
        xor       eax, eax                                      ; 323.40
                                ; LOE eax edx ebx edi esp al ah dl dh
$B2$23:                         ; Preds $B2$25 $B2$24 $B2$26

;;; 	minDelta = MIN(minDelta, MAX(Delta,0));

        test      eax, eax                                      ; 324.39
        mov       DWORD PTR [esp+168], eax                      ; 323.40
        jle       $B2$20        ; Prob 16%                      ; 324.39
                                ; LOE eax edx ebx edi esp al ah dl dh
$B2$12:                         ; Preds $B2$23
        mov       ecx, eax                                      ; 323.2
                                ; LOE eax edx ecx ebx edi esp al ah dl dh cl ch
$B2$13:                         ; Preds $B2$12 $B2$20
        cmp       edi, ecx                                      ; 324.2
        jge       $B2$15        ; Prob 50%                      ; 324.2
                                ; LOE eax edx ebx edi esp al ah dl dh
$B2$14:                         ; Preds $B2$13
        mov       eax, edi                                      ; 323.2
        jmp       $B2$17        ; Prob 100%                     ; 323.2
        ALIGN     4                                             ;
                                ; LOE eax edx ebx esp al ah dl dh
$B2$15:                         ; Preds $B2$13
        test      eax, eax                                      ; 324.2
        jle       $B2$19        ; Prob 16%                      ; 324.2
                                ; LOE eax edx ebx esp al ah dl dh
$B2$17:                         ; Preds $B2$15 $B2$14 $B2$19
        add       edx, 8                                        ; 322.24
        lea       ecx, DWORD PTR [esp+160]                      ; 324.2
        mov       edi, eax                                      ; 324.2
        cmp       ecx, edx                                      ; 322.5
        jg        $B2$11        ; Prob 80%                      ; 322.5
                                ; LOE eax edx ebx edi esp al ah dl dh
$B2$18:                         ; Preds $B2$17

;;; 	}
;;; 
;;;     return(minDelta);

        add       esp, 268                                      ; 327.11
        pop       ebp                                           ; 327.11
        pop       esi                                           ; 327.11
        pop       edi                                           ; 327.11
        mov       esp, ebx                                      ; 327.11
        pop       ebx                                           ; 327.11
        ret                                                     ; 327.11
                                ; LOE eax ebx ebp esi edi esp al ah bl bh
$B2$19:                         ; Preds $B2$15                  ; Infreq
        xor       eax, eax                                      ; 324.2
        jmp       $B2$17        ; Prob 100%                     ; 324.2
        ALIGN     4                                             ;
                                ; LOE eax edx ebx esp al ah dl dh
$B2$20:                         ; Preds $B2$23                  ; Infreq
        xor       ecx, ecx                                      ; 324.39
        jmp       $B2$13        ; Prob 100%                     ; 324.39
        ALIGN     4                                             ;
        ALIGN     4                                             ;
                                ; LOE eax edx ecx ebx edi esp al ah dl dh cl ch
; mark_end;
?checktick@@YAHN@Z ENDP
;?checktick@@YAHN@Z	ENDS
_TEXT	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
$2$2_2il0floatpacket$43	DD 0a0b5ed8dH,03eb0c6f7H	; xf64
$2$2_2il0floatpacket$45	DD 0a0b5ed8dH,03eb0c6f7H	; xf64
$2$2_2il0floatpacket$47	DD 000000000H,0412e8480H	; xf64
_DATA1	ENDS
_DATA	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA	ENDS
; -- End  ?checktick@@YAHN@Z
_DATA	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA	ENDS
_TEXT	SEGMENT PARA PUBLIC USE32 'CODE'
;	COMDAT ?second@@YANN@Z
; -- Begin  ?second@@YANN@Z
; mark_begin;
       ALIGN     4                                             ;
	PUBLIC   ?second@@YANN@Z
?second@@YANN@Z	PROC NEAR
$B3$1:                          ; Preds $B3$0

;;; {

        push      ebp                                           ; 336.1
        mov       ebp, esp                                      ; 336.1
        sub       esp, 40                                       ; 336.1
                                ; LOE ebp esp
$B3$5:                          ; Preds $B3$1

;;; 	unsigned long clk_time_hi=0;

        xor       eax, eax                                      ; 337.16
        mov       DWORD PTR [ebp-32], eax                       ; 337.16

;;; 	unsigned long clk_time_lo=0;

        mov       DWORD PTR [ebp-28], eax                       ; 338.16

;;; 	double clk_time = 0.0;

        fld       QWORD PTR $2$3_2il0floatpacket$49             ; 339.9
        fstp      QWORD PTR [ebp-40]                            ; 339.9
                                ; LOE ebp esp
$B3$6:                          ; Preds $B3$5
; Begin ASM

;;; 	
;;; 	__asm {
;;; 		_emit 0x0F

        DB        15                                            ; 342.3

;;; 		_emit 0x31

        DB        49                                            ; 343.3

;;; 		mov clk_time_lo, eax

        mov       DWORD PTR [ebp-28], eax                       ; 344.3

;;; 		mov clk_time_hi, edx

        mov       DWORD PTR [ebp-32], edx                       ; 345.3
; End ASM
                                ; LOE ebp esp
$B3$2:                          ; Preds $B3$6

;;; 	}
;;; 	
;;; 	clk_time = (double)clk_time_hi * 4294967295.0; // upshift by 32bits

        mov       eax, DWORD PTR [ebp-32]                       ; 348.21
        xor       edx, edx                                      ; 348.21
        mov       DWORD PTR [ebp-20], edx                       ; 348.21
        mov       DWORD PTR [ebp-24], eax                       ; 348.21
        fild      QWORD PTR [ebp-24]                            ; 348.21
        fmul      QWORD PTR $2$3_2il0floatpacket$51             ; 348.21
        fstp      QWORD PTR [ebp-40]                            ; 348.2

;;; 	clk_time += (double)clk_time_lo;

        mov       eax, DWORD PTR [ebp-28]                       ; 349.22
        mov       DWORD PTR [ebp-20], edx                       ; 349.22
        mov       DWORD PTR [ebp-24], eax                       ; 349.22
        fild      QWORD PTR [ebp-24]                            ; 349.22
        fadd      QWORD PTR [ebp-40]                            ; 349.2
        fstp      QWORD PTR [ebp-40]                            ; 349.2

;;; 	return (clk_time / core_freq);

        fld       QWORD PTR [ebp-40]                            ; 350.10
        fdiv      QWORD PTR [ebp+8]                             ; 350.21
        mov       esp, ebp                                      ; 350.21
        pop       ebp                                           ; 350.21
        ret                                                     ; 350.21
        ALIGN     4                                             ;
                                ; LOE ebp esp
; mark_end;
?second@@YANN@Z ENDP
;?second@@YANN@Z	ENDS
_TEXT	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
$2$3_2il0floatpacket$49	DD 000000000H,000000000H	; xf64
$2$3_2il0floatpacket$51	DD 0ffe00000H,041efffffH	; xf64
$2$3_2il0floatpacket$53	DD 000000000H,03ff00000H	; xf64
_DATA1	ENDS
_DATA	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA	ENDS
; -- End  ?second@@YANN@Z
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0M@A@Copy?3?5?5?5?5?5?5?$AA@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 67	; s8
	DB 111	; s8
	DB 112	; s8
	DB 121	; s8
	DB 58	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0M@A@Scale?3?5?5?5?5?5?$AA@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 83	; s8
	DB 99	; s8
	DB 97	; s8
	DB 108	; s8
	DB 101	; s8
	DB 58	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0M@A@Add?3?5?5?5?5?5?5?5?$AA@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 65	; s8
	DB 100	; s8
	DB 100	; s8
	DB 58	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0M@A@Triad?3?5?5?5?5?5?$AA@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 84	; s8
	DB 114	; s8
	DB 105	; s8
	DB 97	; s8
	DB 100	; s8
	DB 58	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0DA@CNBAEGDJ@?6?5usage?3?5?$CFs?5?$DMcore_frequency?$CIMHz?$CJ@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 10	; s8
	DB 32	; s8
	DB 117	; s8
	DB 115	; s8
	DB 97	; s8
	DB 103	; s8
	DB 101	; s8
	DB 58	; s8
	DB 32	; s8
	DB 37	; s8
	DB 115	; s8
	DB 32	; s8
	DB 60	; s8
	DB 99	; s8
	DB 111	; s8
	DB 114	; s8
	DB 101	; s8
	DB 95	; s8
	DB 102	; s8
	DB 114	; s8
	DB 101	; s8
	DB 113	; s8
	DB 117	; s8
	DB 101	; s8
	DB 110	; s8
	DB 99	; s8
	DB 121	; s8
	DB 40	; s8
	DB 77	; s8
	DB 72	; s8
	DB 122	; s8
	DB 41	; s8
	DB 62	; s8
	DB 32	; s8
	DB 60	; s8
	DB 105	; s8
	DB 116	; s8
	DB 101	; s8
	DB 114	; s8
	DB 97	; s8
	DB 116	; s8
	DB 105	; s8
	DB 111	; s8
	DB 110	; s8
	DB 115	; s8
	DB 62	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0CF@FMCPCEEA@?6Error?5allocating?5arrays?4?5Quitti@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 10	; s8
	DB 69	; s8
	DB 114	; s8
	DB 114	; s8
	DB 111	; s8
	DB 114	; s8
	DB 32	; s8
	DB 97	; s8
	DB 108	; s8
	DB 108	; s8
	DB 111	; s8
	DB 99	; s8
	DB 97	; s8
	DB 116	; s8
	DB 105	; s8
	DB 110	; s8
	DB 103	; s8
	DB 32	; s8
	DB 97	; s8
	DB 114	; s8
	DB 114	; s8
	DB 97	; s8
	DB 121	; s8
	DB 115	; s8
	DB 46	; s8
	DB 32	; s8
	DB 81	; s8
	DB 117	; s8
	DB 105	; s8
	DB 116	; s8
	DB 116	; s8
	DB 105	; s8
	DB 110	; s8
	DB 103	; s8
	DB 46	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0DP@LMFECGLD@?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9?9@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 45	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0DG@OCCAPABI@This?5system?5uses?5?$CFd?5bytes?5per?5DO@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 84	; s8
	DB 104	; s8
	DB 105	; s8
	DB 115	; s8
	DB 32	; s8
	DB 115	; s8
	DB 121	; s8
	DB 115	; s8
	DB 116	; s8
	DB 101	; s8
	DB 109	; s8
	DB 32	; s8
	DB 117	; s8
	DB 115	; s8
	DB 101	; s8
	DB 115	; s8
	DB 32	; s8
	DB 37	; s8
	DB 100	; s8
	DB 32	; s8
	DB 98	; s8
	DB 121	; s8
	DB 116	; s8
	DB 101	; s8
	DB 115	; s8
	DB 32	; s8
	DB 112	; s8
	DB 101	; s8
	DB 114	; s8
	DB 32	; s8
	DB 68	; s8
	DB 79	; s8
	DB 85	; s8
	DB 66	; s8
	DB 76	; s8
	DB 69	; s8
	DB 32	; s8
	DB 80	; s8
	DB 82	; s8
	DB 69	; s8
	DB 67	; s8
	DB 73	; s8
	DB 83	; s8
	DB 73	; s8
	DB 79	; s8
	DB 78	; s8
	DB 32	; s8
	DB 119	; s8
	DB 111	; s8
	DB 114	; s8
	DB 100	; s8
	DB 46	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0BB@A@Array?5size?5?$DN?5?$CFd?6?$AA@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 65	; s8
	DB 114	; s8
	DB 114	; s8
	DB 97	; s8
	DB 121	; s8
	DB 32	; s8
	DB 115	; s8
	DB 105	; s8
	DB 122	; s8
	DB 101	; s8
	DB 32	; s8
	DB 61	; s8
	DB 32	; s8
	DB 37	; s8
	DB 100	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0CC@CGC@Total?5memory?5required?5?$DN?5?$CF?41f?5MB?4@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 84	; s8
	DB 111	; s8
	DB 116	; s8
	DB 97	; s8
	DB 108	; s8
	DB 32	; s8
	DB 109	; s8
	DB 101	; s8
	DB 109	; s8
	DB 111	; s8
	DB 114	; s8
	DB 121	; s8
	DB 32	; s8
	DB 114	; s8
	DB 101	; s8
	DB 113	; s8
	DB 117	; s8
	DB 105	; s8
	DB 114	; s8
	DB 101	; s8
	DB 100	; s8
	DB 32	; s8
	DB 61	; s8
	DB 32	; s8
	DB 37	; s8
	DB 46	; s8
	DB 49	; s8
	DB 102	; s8
	DB 32	; s8
	DB 77	; s8
	DB 66	; s8
	DB 46	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0CF@FMEELHJM@Each?5test?5is?5run?5?$CFd?5times?0?5but?5o@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 69	; s8
	DB 97	; s8
	DB 99	; s8
	DB 104	; s8
	DB 32	; s8
	DB 116	; s8
	DB 101	; s8
	DB 115	; s8
	DB 116	; s8
	DB 32	; s8
	DB 105	; s8
	DB 115	; s8
	DB 32	; s8
	DB 114	; s8
	DB 117	; s8
	DB 110	; s8
	DB 32	; s8
	DB 37	; s8
	DB 100	; s8
	DB 32	; s8
	DB 116	; s8
	DB 105	; s8
	DB 109	; s8
	DB 101	; s8
	DB 115	; s8
	DB 44	; s8
	DB 32	; s8
	DB 98	; s8
	DB 117	; s8
	DB 116	; s8
	DB 32	; s8
	DB 111	; s8
	DB 110	; s8
	DB 108	; s8
	DB 121	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0CD@CJPAA@the?5?$CKbest?$CK?5time?5for?5each?5is?5used@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 116	; s8
	DB 104	; s8
	DB 101	; s8
	DB 32	; s8
	DB 42	; s8
	DB 98	; s8
	DB 101	; s8
	DB 115	; s8
	DB 116	; s8
	DB 42	; s8
	DB 32	; s8
	DB 116	; s8
	DB 105	; s8
	DB 109	; s8
	DB 101	; s8
	DB 32	; s8
	DB 102	; s8
	DB 111	; s8
	DB 114	; s8
	DB 32	; s8
	DB 101	; s8
	DB 97	; s8
	DB 99	; s8
	DB 104	; s8
	DB 32	; s8
	DB 105	; s8
	DB 115	; s8
	DB 32	; s8
	DB 117	; s8
	DB 115	; s8
	DB 101	; s8
	DB 100	; s8
	DB 46	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0EB@DNIEJKDD@Your?5clock?5granularity?1precision@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 89	; s8
	DB 111	; s8
	DB 117	; s8
	DB 114	; s8
	DB 32	; s8
	DB 99	; s8
	DB 108	; s8
	DB 111	; s8
	DB 99	; s8
	DB 107	; s8
	DB 32	; s8
	DB 103	; s8
	DB 114	; s8
	DB 97	; s8
	DB 110	; s8
	DB 117	; s8
	DB 108	; s8
	DB 97	; s8
	DB 114	; s8
	DB 105	; s8
	DB 116	; s8
	DB 121	; s8
	DB 47	; s8
	DB 112	; s8
	DB 114	; s8
	DB 101	; s8
	DB 99	; s8
	DB 105	; s8
	DB 115	; s8
	DB 105	; s8
	DB 111	; s8
	DB 110	; s8
	DB 32	; s8
	DB 97	; s8
	DB 112	; s8
	DB 112	; s8
	DB 101	; s8
	DB 97	; s8
	DB 114	; s8
	DB 115	; s8
	DB 32	; s8
	DB 116	; s8
	DB 111	; s8
	DB 32	; s8
	DB 98	; s8
	DB 101	; s8
	DB 32	; s8
	DB 37	; s8
	DB 100	; s8
	DB 32	; s8
	DB 109	; s8
	DB 105	; s8
	DB 99	; s8
	DB 114	; s8
	DB 111	; s8
	DB 115	; s8
	DB 101	; s8
	DB 99	; s8
	DB 111	; s8
	DB 110	; s8
	DB 100	; s8
	DB 115	; s8
	DB 46	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0EB@GHNAPMKF@Your?5clock?5granularity?5appears?5t@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 89	; s8
	DB 111	; s8
	DB 117	; s8
	DB 114	; s8
	DB 32	; s8
	DB 99	; s8
	DB 108	; s8
	DB 111	; s8
	DB 99	; s8
	DB 107	; s8
	DB 32	; s8
	DB 103	; s8
	DB 114	; s8
	DB 97	; s8
	DB 110	; s8
	DB 117	; s8
	DB 108	; s8
	DB 97	; s8
	DB 114	; s8
	DB 105	; s8
	DB 116	; s8
	DB 121	; s8
	DB 32	; s8
	DB 97	; s8
	DB 112	; s8
	DB 112	; s8
	DB 101	; s8
	DB 97	; s8
	DB 114	; s8
	DB 115	; s8
	DB 32	; s8
	DB 116	; s8
	DB 111	; s8
	DB 32	; s8
	DB 98	; s8
	DB 101	; s8
	DB 32	; s8
	DB 108	; s8
	DB 101	; s8
	DB 115	; s8
	DB 115	; s8
	DB 32	; s8
	DB 116	; s8
	DB 104	; s8
	DB 97	; s8
	DB 110	; s8
	DB 32	; s8
	DB 111	; s8
	DB 110	; s8
	DB 101	; s8
	DB 32	; s8
	DB 109	; s8
	DB 105	; s8
	DB 99	; s8
	DB 114	; s8
	DB 111	; s8
	DB 115	; s8
	DB 101	; s8
	DB 99	; s8
	DB 111	; s8
	DB 110	; s8
	DB 100	; s8
	DB 46	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0BJ@A@Error?5allocating?5arrays?6?$AA@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 69	; s8
	DB 114	; s8
	DB 114	; s8
	DB 111	; s8
	DB 114	; s8
	DB 32	; s8
	DB 97	; s8
	DB 108	; s8
	DB 108	; s8
	DB 111	; s8
	DB 99	; s8
	DB 97	; s8
	DB 116	; s8
	DB 105	; s8
	DB 110	; s8
	DB 103	; s8
	DB 32	; s8
	DB 97	; s8
	DB 114	; s8
	DB 114	; s8
	DB 97	; s8
	DB 121	; s8
	DB 115	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0DM@KJOJGAEE@Each?5test?5below?5will?5take?5on?5the@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 69	; s8
	DB 97	; s8
	DB 99	; s8
	DB 104	; s8
	DB 32	; s8
	DB 116	; s8
	DB 101	; s8
	DB 115	; s8
	DB 116	; s8
	DB 32	; s8
	DB 98	; s8
	DB 101	; s8
	DB 108	; s8
	DB 111	; s8
	DB 119	; s8
	DB 32	; s8
	DB 119	; s8
	DB 105	; s8
	DB 108	; s8
	DB 108	; s8
	DB 32	; s8
	DB 116	; s8
	DB 97	; s8
	DB 107	; s8
	DB 101	; s8
	DB 32	; s8
	DB 111	; s8
	DB 110	; s8
	DB 32	; s8
	DB 116	; s8
	DB 104	; s8
	DB 101	; s8
	DB 32	; s8
	DB 111	; s8
	DB 114	; s8
	DB 100	; s8
	DB 101	; s8
	DB 114	; s8
	DB 32	; s8
	DB 111	; s8
	DB 102	; s8
	DB 32	; s8
	DB 37	; s8
	DB 100	; s8
	DB 32	; s8
	DB 109	; s8
	DB 105	; s8
	DB 99	; s8
	DB 114	; s8
	DB 111	; s8
	DB 115	; s8
	DB 101	; s8
	DB 99	; s8
	DB 111	; s8
	DB 110	; s8
	DB 100	; s8
	DB 115	; s8
	DB 46	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0BH@A@?5?5?5?$CI?$DN?5?$CFd?5clock?5ticks?$CJ?6?$AA@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 40	; s8
	DB 61	; s8
	DB 32	; s8
	DB 37	; s8
	DB 100	; s8
	DB 32	; s8
	DB 99	; s8
	DB 108	; s8
	DB 111	; s8
	DB 99	; s8
	DB 107	; s8
	DB 32	; s8
	DB 116	; s8
	DB 105	; s8
	DB 99	; s8
	DB 107	; s8
	DB 115	; s8
	DB 41	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0DE@LKLKBFJA@Increase?5the?5size?5of?5the?5arrays?5@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 73	; s8
	DB 110	; s8
	DB 99	; s8
	DB 114	; s8
	DB 101	; s8
	DB 97	; s8
	DB 115	; s8
	DB 101	; s8
	DB 32	; s8
	DB 116	; s8
	DB 104	; s8
	DB 101	; s8
	DB 32	; s8
	DB 115	; s8
	DB 105	; s8
	DB 122	; s8
	DB 101	; s8
	DB 32	; s8
	DB 111	; s8
	DB 102	; s8
	DB 32	; s8
	DB 116	; s8
	DB 104	; s8
	DB 101	; s8
	DB 32	; s8
	DB 97	; s8
	DB 114	; s8
	DB 114	; s8
	DB 97	; s8
	DB 121	; s8
	DB 115	; s8
	DB 32	; s8
	DB 105	; s8
	DB 102	; s8
	DB 32	; s8
	DB 116	; s8
	DB 104	; s8
	DB 105	; s8
	DB 115	; s8
	DB 32	; s8
	DB 115	; s8
	DB 104	; s8
	DB 111	; s8
	DB 119	; s8
	DB 115	; s8
	DB 32	; s8
	DB 116	; s8
	DB 104	; s8
	DB 97	; s8
	DB 116	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0DH@EBDCDCK@you?5are?5not?5getting?5at?5least?520?5@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 121	; s8
	DB 111	; s8
	DB 117	; s8
	DB 32	; s8
	DB 97	; s8
	DB 114	; s8
	DB 101	; s8
	DB 32	; s8
	DB 110	; s8
	DB 111	; s8
	DB 116	; s8
	DB 32	; s8
	DB 103	; s8
	DB 101	; s8
	DB 116	; s8
	DB 116	; s8
	DB 105	; s8
	DB 110	; s8
	DB 103	; s8
	DB 32	; s8
	DB 97	; s8
	DB 116	; s8
	DB 32	; s8
	DB 108	; s8
	DB 101	; s8
	DB 97	; s8
	DB 115	; s8
	DB 116	; s8
	DB 32	; s8
	DB 50	; s8
	DB 48	; s8
	DB 32	; s8
	DB 99	; s8
	DB 108	; s8
	DB 111	; s8
	DB 99	; s8
	DB 107	; s8
	DB 32	; s8
	DB 116	; s8
	DB 105	; s8
	DB 99	; s8
	DB 107	; s8
	DB 115	; s8
	DB 32	; s8
	DB 112	; s8
	DB 101	; s8
	DB 114	; s8
	DB 32	; s8
	DB 116	; s8
	DB 101	; s8
	DB 115	; s8
	DB 116	; s8
	DB 46	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0DB@HCLFLMNE@WARNING?5?9?9?5The?5above?5is?5only?5a?5r@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 87	; s8
	DB 65	; s8
	DB 82	; s8
	DB 78	; s8
	DB 73	; s8
	DB 78	; s8
	DB 71	; s8
	DB 32	; s8
	DB 45	; s8
	DB 45	; s8
	DB 32	; s8
	DB 84	; s8
	DB 104	; s8
	DB 101	; s8
	DB 32	; s8
	DB 97	; s8
	DB 98	; s8
	DB 111	; s8
	DB 118	; s8
	DB 101	; s8
	DB 32	; s8
	DB 105	; s8
	DB 115	; s8
	DB 32	; s8
	DB 111	; s8
	DB 110	; s8
	DB 108	; s8
	DB 121	; s8
	DB 32	; s8
	DB 97	; s8
	DB 32	; s8
	DB 114	; s8
	DB 111	; s8
	DB 117	; s8
	DB 103	; s8
	DB 104	; s8
	DB 32	; s8
	DB 103	; s8
	DB 117	; s8
	DB 105	; s8
	DB 100	; s8
	DB 101	; s8
	DB 108	; s8
	DB 105	; s8
	DB 110	; s8
	DB 101	; s8
	DB 46	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0CP@BINKKLJE@For?5best?5results?0?5please?5be?5sure@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 70	; s8
	DB 111	; s8
	DB 114	; s8
	DB 32	; s8
	DB 98	; s8
	DB 101	; s8
	DB 115	; s8
	DB 116	; s8
	DB 32	; s8
	DB 114	; s8
	DB 101	; s8
	DB 115	; s8
	DB 117	; s8
	DB 108	; s8
	DB 116	; s8
	DB 115	; s8
	DB 44	; s8
	DB 32	; s8
	DB 112	; s8
	DB 108	; s8
	DB 101	; s8
	DB 97	; s8
	DB 115	; s8
	DB 101	; s8
	DB 32	; s8
	DB 98	; s8
	DB 101	; s8
	DB 32	; s8
	DB 115	; s8
	DB 117	; s8
	DB 114	; s8
	DB 101	; s8
	DB 32	; s8
	DB 121	; s8
	DB 111	; s8
	DB 117	; s8
	DB 32	; s8
	DB 107	; s8
	DB 110	; s8
	DB 111	; s8
	DB 119	; s8
	DB 32	; s8
	DB 116	; s8
	DB 104	; s8
	DB 101	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0CB@A@precision?5of?5your?5system?5timer?4?6@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 112	; s8
	DB 114	; s8
	DB 101	; s8
	DB 99	; s8
	DB 105	; s8
	DB 115	; s8
	DB 105	; s8
	DB 111	; s8
	DB 110	; s8
	DB 32	; s8
	DB 111	; s8
	DB 102	; s8
	DB 32	; s8
	DB 121	; s8
	DB 111	; s8
	DB 117	; s8
	DB 114	; s8
	DB 32	; s8
	DB 115	; s8
	DB 121	; s8
	DB 115	; s8
	DB 116	; s8
	DB 101	; s8
	DB 109	; s8
	DB 32	; s8
	DB 116	; s8
	DB 105	; s8
	DB 109	; s8
	DB 101	; s8
	DB 114	; s8
	DB 46	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0BK@A@?6error?5allocating?5arrays?6?$AA@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 10	; s8
	DB 101	; s8
	DB 114	; s8
	DB 114	; s8
	DB 111	; s8
	DB 114	; s8
	DB 32	; s8
	DB 97	; s8
	DB 108	; s8
	DB 108	; s8
	DB 111	; s8
	DB 99	; s8
	DB 97	; s8
	DB 116	; s8
	DB 105	; s8
	DB 110	; s8
	DB 103	; s8
	DB 32	; s8
	DB 97	; s8
	DB 114	; s8
	DB 114	; s8
	DB 97	; s8
	DB 121	; s8
	DB 115	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_09A@times?4txt?$AA@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 116	; s8
	DB 105	; s8
	DB 109	; s8
	DB 101	; s8
	DB 115	; s8
	DB 46	; s8
	DB 116	; s8
	DB 120	; s8
	DB 116	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_01A@w?$AA@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 119	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0BK@A@?6couldn?8t?5open?5times?4txt?6?$AA@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 10	; s8
	DB 99	; s8
	DB 111	; s8
	DB 117	; s8
	DB 108	; s8
	DB 100	; s8
	DB 110	; s8
	DB 39	; s8
	DB 116	; s8
	DB 32	; s8
	DB 111	; s8
	DB 112	; s8
	DB 101	; s8
	DB 110	; s8
	DB 32	; s8
	DB 116	; s8
	DB 105	; s8
	DB 109	; s8
	DB 101	; s8
	DB 115	; s8
	DB 46	; s8
	DB 116	; s8
	DB 120	; s8
	DB 116	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0BG@A@copy?7scale?7add?7triad?6?$AA@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 99	; s8
	DB 111	; s8
	DB 112	; s8
	DB 121	; s8
	DB 9	; s8
	DB 115	; s8
	DB 99	; s8
	DB 97	; s8
	DB 108	; s8
	DB 101	; s8
	DB 9	; s8
	DB 97	; s8
	DB 100	; s8
	DB 100	; s8
	DB 9	; s8
	DB 116	; s8
	DB 114	; s8
	DB 105	; s8
	DB 97	; s8
	DB 100	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0N@A@?$CFf?7?$CFf?7?$CFf?7?$CFf?6?$AA@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 37	; s8
	DB 102	; s8
	DB 9	; s8
	DB 37	; s8
	DB 102	; s8
	DB 9	; s8
	DB 37	; s8
	DB 102	; s8
	DB 9	; s8
	DB 37	; s8
	DB 102	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0EA@KCIKNIDN@Function?5?5?5?5?5?5Rate?5?$CIMB?1s?$CJ?5?5?5RMS?5@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 70	; s8
	DB 117	; s8
	DB 110	; s8
	DB 99	; s8
	DB 116	; s8
	DB 105	; s8
	DB 111	; s8
	DB 110	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 82	; s8
	DB 97	; s8
	DB 116	; s8
	DB 101	; s8
	DB 32	; s8
	DB 40	; s8
	DB 77	; s8
	DB 66	; s8
	DB 47	; s8
	DB 115	; s8
	DB 41	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 82	; s8
	DB 77	; s8
	DB 83	; s8
	DB 32	; s8
	DB 116	; s8
	DB 105	; s8
	DB 109	; s8
	DB 101	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 77	; s8
	DB 105	; s8
	DB 110	; s8
	DB 32	; s8
	DB 116	; s8
	DB 105	; s8
	DB 109	; s8
	DB 101	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 32	; s8
	DB 77	; s8
	DB 97	; s8
	DB 120	; s8
	DB 32	; s8
	DB 116	; s8
	DB 105	; s8
	DB 109	; s8
	DB 101	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
_DATA1	ENDS
;	COMDAT ??_C@_0CC@CGC@?$CFs?$CF11?44f?5?5?$CF11?44f?5?5?$CF11?44f?5?5?$CF11?44f@
_DATA1	SEGMENT PARA PUBLIC USE32 'DATA'
	DB 37	; s8
	DB 115	; s8
	DB 37	; s8
	DB 49	; s8
	DB 49	; s8
	DB 46	; s8
	DB 52	; s8
	DB 102	; s8
	DB 32	; s8
	DB 32	; s8
	DB 37	; s8
	DB 49	; s8
	DB 49	; s8
	DB 46	; s8
	DB 52	; s8
	DB 102	; s8
	DB 32	; s8
	DB 32	; s8
	DB 37	; s8
	DB 49	; s8
	DB 49	; s8
	DB 46	; s8
	DB 52	; s8
	DB 102	; s8
	DB 32	; s8
	DB 32	; s8
	DB 37	; s8
	DB 49	; s8
	DB 49	; s8
	DB 46	; s8
	DB 52	; s8
	DB 102	; s8
	DB 10	; s8
	DB 0	; s8
_DATA1	ENDS
_DATA	SEGMENT PARA PUBLIC USE32 'DATA'
EXTRN	__imp__SetPriorityClass@8:BYTE
EXTRN	__imp__SetThreadPriority@8:BYTE
EXTRN	__imp__GetCurrentThread@0:BYTE
EXTRN	__imp__GetCurrentProcess@0:BYTE
_DATA	ENDS
EXTRN	_fputs:PROC
; mark_proc_addr_taken ?second@@YANN@Z;
; mark_proc_addr_taken ?checktick@@YAHN@Z;
; mark_proc_addr_taken _main;
EXTRN	_exit:PROC
EXTRN	_atoi:PROC
EXTRN	_atof:PROC
EXTRN	_printf:PROC
EXTRN	_fprintf:PROC
EXTRN	_fopen:PROC
EXTRN	_fclose:PROC
EXTRN	??3@YAXPAX@Z:PROC
EXTRN	??2@YAPAXI@Z:PROC
EXTRN	__fltused:BYTE
	END